Function layoutGraph

deployments/desktop/static/desktop.js:3640–3702

(nodes, edges)

  }

  function layoutGraph(nodes, edges) {
    const sourceNodes = uniqueGraphNodes((nodes || []).filter((node) => graphId(node).trim()));
    const sourceNodeIds = new Set(sourceNodes.map((node) => graphId(node)));
    const sourceEdges = (edges || [])
      .map(normalizeGraphEdge)
      .filter((edge) => sourceNodeIds.has(edge.src_id) && sourceNodeIds.has(edge.dst_id));
    const degree = graphDegreeMap(sourceNodes, sourceEdges);
    const groups = {
      topic: { x: 26, y: 31, nodes: [] },
      paper: { x: 42, y: 64, nodes: [] },
      method: { x: 70, y: 58, nodes: [] },
      frontier: { x: 74, y: 28, nodes: [] }
    };
    sourceNodes
      .slice()
      .sort((a, b) => (degree[graphId(b)] || 0) - (degree[graphId(a)] || 0))
      .forEach((node) => {
        const type = graphType(node);
        (groups[type] || groups.topic).nodes.push(node);
      });

    const mapNodes = [];
    Object.entries(groups).forEach(([type, group]) => {
      const count = Math.max(1, group.nodes.length);
      group.nodes.forEach((node, index) => {
        const ring = Math.floor(index / 18);
        const slot = index % 18;
        const angle = (slot / Math.min(18, count)) * Math.PI * 2 + ring * 0.38;
        const radiusX = 7 + ring * 6 + (type === "paper" ? 3 : 0);
        const radiusY = 6 + ring * 4.5 + (type === "paper" ? 2 : 0);
        const id = graphId(node);
        const score = degree[id] || 0;
        mapNodes.push({
          ...node,
          id,
          node_id: id,
          type,
          x: clamp(group.x + Math.cos(angle) * radiusX, 5, 94),
          y: clamp(group.y + Math.sin(angle) * radiusY, 8, 91),
          size: score >= 2.5 ? "large" : score >= 1.0 ? "medium" : "small",
          real_node_id: id
        });
      });
    });
    const map = {
      nodes: mapNodes,
      edges: sourceEdges,
      sourceNodes,
      sourceEdges,
      byId: Object.fromEntries(mapNodes.map((node) => [node.id, node]))
    };
    state.wikiMap = map;
    const focusId = state.currentWikiNodeId && map.byId[state.currentWikiNodeId]
      ? state.currentWikiNodeId
      : pickWikiFocusNodeId();
    return {
      nodes: map.nodes.map((node) => ({ ...node, x: node.x, y: node.y, type: node.type, size: node.size })),
      edges: map.edges,