@super-linear/supertopo 0.0.1

package/src/layouts/clos.ts

@@ -0,0 +1,590 @@
+/**
+ * Clos Topology Layout - Cytoscape Extension
+ *
+ * 直接使用 Cytoscape API 获取节点连接关系
+ * 动态分类：Spine（脊节点）和 Leaf（叶节点）
+ */
+
+import type { CollectionArgument } from "cytoscape";
+
+/**
+ * 自然排序：正确处理数字排序（gpu9 < gpu10，part2 < part10）
+ */
+function naturalSortCompare(a: string, b: string): number {
+  const numA = parseInt(a.match(/\d+/g)?.join("") || "0");
+  const numB = parseInt(b.match(/\d+/g)?.join("") || "0");
+
+  if (numA !== numB) return numA - numB;
+  return a.localeCompare(b);
+}
+
+class UnionFind {
+  parent = new Map<string, string>();
+  rank = new Map<string, number>();
+
+  makeSet(x: string) {
+    this.parent.set(x, x);
+    this.rank.set(x, 0);
+  }
+
+  find(x: string): string {
+    if (!this.parent.has(x)) this.makeSet(x);
+    const px = this.parent.get(x)!;
+    if (px === x) return x;
+    const root = this.find(px);
+    this.parent.set(x, root);
+    return root;
+  }
+
+  union(x: string, y: string) {
+    const px = this.find(x),
+      py = this.find(y);
+    if (px === py) return;
+    const rx = this.rank.get(px) || 0,
+      ry = this.rank.get(py) || 0;
+    if (rx < ry) this.parent.set(px, py);
+    else if (rx > ry) this.parent.set(py, px);
+    else {
+      this.parent.set(py, px);
+      this.rank.set(px, rx + 1);
+    }
+  }
+}
+
+function classifyNodes(nodes: any[], switchElements: any, serverElements: any) {
+  const servers: any[] = [];
+  const switches: any[] = [];
+
+  nodes.forEach((n) => {
+    const type = String(n.data("type") || "").toLowerCase();
+    if (type === "switch") {
+      switches.push(n);
+    } else {
+      servers.push(n);
+    }
+  });
+
+  if (switches.length === 0) {
+    return { servers, leaf: [], spine: [], maxSpineSize: 0 };
+  }
+
+  const switchIdSet = new Set(switches.map((s) => String(s.id())));
+  const serverIdSet = new Set(servers.map((s) => String(s.id())));
+
+  const switchInfo = new Map<
+    string,
+    {
+      id: string;
+      connectedToServers: Set<string>;
+      connectedToSwitches: Set<string>;
+    }
+  >();
+
+  switches.forEach((sw: any) => {
+    const swId = String(sw.id());
+    const swNode = switchElements.getElementById(swId);
+
+    if (swNode && swNode.length > 0) {
+      const neighbors = swNode.neighborhood().nodes();
+      const connectedToServers = new Set<string>();
+      const connectedToSwitches = new Set<string>();
+
+      neighbors.forEach((neighborNode: any) => {
+        const neighborId = String(neighborNode.id());
+        if (serverIdSet.has(neighborId)) {
+          connectedToServers.add(neighborId);
+        } else if (switchIdSet.has(neighborId)) {
+          connectedToSwitches.add(neighborId);
+        }
+      });
+
+      switchInfo.set(swId, {
+        id: swId,
+        connectedToServers,
+        connectedToSwitches,
+      });
+    }
+  });
+
+  // 算法：识别 Spine 和 Leaf
+  // 第一步：找出所有不和任何 server 连接的 switch，这些一定是 spine
+  const spine: any[] = [];
+  switches.forEach((sw: any) => {
+    const info = switchInfo.get(String(sw.id()));
+    if (!info) return;
+
+    if (info.connectedToServers.size === 0) {
+      spine.push(sw);
+    }
+  });
+
+  const spineIdSet = new Set(spine.map((s) => String(s.id())));
+
+  // 第二步：遍历剩下的 switches
+  // 如果某个 switch 不连接任何已确定的 spine，则判定为 spine
+  const remainingSwitches = switches.filter(
+    (sw: any) => !spineIdSet.has(String(sw.id())),
+  );
+
+  remainingSwitches.forEach((sw: any) => {
+    const swId = String(sw.id());
+    const info = switchInfo.get(swId);
+    if (!info) return;
+
+    // 检查是否连接到任何一个已确定的 spine
+    const connectsToSpine = Array.from(info.connectedToSwitches).some((swId) =>
+      spineIdSet.has(swId),
+    );
+
+    // 如果不连接任何 spine，则加入 spine 组
+    if (!connectsToSpine) {
+      spine.push(sw);
+      spineIdSet.add(swId);
+    }
+  });
+
+  // 第三步：剩下的所有 switch 都是 leaf
+  const leaf: any[] = switches.filter(
+    (sw: any) => !spineIdSet.has(String(sw.id())),
+  );
+
+  const maxSpineSize =
+    spine.length > 0 ? Math.max(...spine.map((s) => s.data("size") || 40)) : 0;
+
+  console.log("[CLOS] 节点分类结果:");
+  console.log("  Server:", servers.length);
+  console.log("  Leaf (连接到 spine):", leaf.length);
+  console.log("  Spine (不连接 server 或 spine):", spine.length);
+
+  return { servers, leaf, spine, maxSpineSize };
+}
+
+function groupBySU(
+  servers: any[],
+  leaf: any[],
+  allElements: any,
+  suScope?: any,
+): Map<string, { leaves: any[]; servers: any[]; maxNodeSize: number }> {
+  const validServerIds = new Set<string>();
+  const serverMap = new Map<string, any>();
+
+  servers.forEach((s) => {
+    const id = String(s.id());
+    // 创建混合对象，既有扁平属性又有 Cytoscape API
+    // 用户可以通过 node.id 或 node.id() 访问 ID
+    const serverNode = s as any;
+    if (suScope?.exclude?.(serverNode)) return;
+    if (suScope?.include && !suScope.include(serverNode)) return;
+    validServerIds.add(id);
+    serverMap.set(id, s);
+  });
+
+  const leafToValidServers = new Map<string, Set<string>>();
+
+  leaf.forEach((l) => {
+    const lNode = allElements.getElementById(String(l.id()));
+    if (lNode && lNode.length > 0) {
+      const neighbors = lNode.neighborhood().nodes();
+      const connected = new Set<string>();
+
+      neighbors.forEach((neighbor: any) => {
+        const neighborId = String(neighbor.id());
+        if (validServerIds.has(neighborId)) {
+          connected.add(neighborId);
+        }
+      });
+
+      leafToValidServers.set(String(l.id()), connected);
+    }
+  });
+
+  const uf = new UnionFind();
+  leaf.forEach((l) => uf.makeSet(String(l.id())));
+
+  const leafIds = Array.from(leafToValidServers.keys());
+  for (let i = 0; i < leafIds.length; i++) {
+    for (let j = i + 1; j < leafIds.length; j++) {
+      const a = leafIds[i]!,
+        b = leafIds[j]!;
+      const serversA = leafToValidServers.get(a) || new Set();
+      const serversB = leafToValidServers.get(b) || new Set();
+      for (const sid of serversA) {
+        if (serversB.has(sid)) {
+          uf.union(a, b);
+          break;
+        }
+      }
+    }
+  }
+
+  const leafGroupsByRoot = new Map<string, string[]>();
+  leafIds.forEach((leafId) => {
+    const root = uf.find(leafId);
+    const group = leafGroupsByRoot.get(root) || [];
+    group.push(leafId);
+    leafGroupsByRoot.set(root, group);
+  });
+
+  const sortedLeafGroups: { root: string; leafGroup: string[] }[] = [];
+  leafGroupsByRoot.forEach((leafGroup, root) => {
+    if (!root) return;
+    leafGroup.sort((a, b) => {
+      const nodeA = leaf.find((l) => String(l.id()) === a);
+      const nodeB = leaf.find((l) => String(l.id()) === b);
+      const labelA = String(nodeA?.data("label") || nodeA?.id() || a).toLowerCase();
+      const labelB = String(nodeB?.data("label") || nodeB?.id() || b).toLowerCase();
+      return labelA.localeCompare(labelB);
+    });
+    sortedLeafGroups.push({ root, leafGroup });
+  });
+
+  const leafToAllServers = new Map<string, Set<string>>();
+  leaf.forEach((l) => {
+    const lNode = allElements.getElementById(String(l.id()));
+    if (lNode && lNode.length > 0) {
+      const neighbors = lNode.neighborhood().nodes();
+      const connected = new Set<string>();
+
+      neighbors.forEach((neighbor: any) => {
+        const neighborId = String(neighbor.id());
+        if (servers.some((s) => String(s.id()) === neighborId)) {
+          connected.add(neighborId);
+        }
+      });
+
+      leafToAllServers.set(String(l.id()), connected);
+    }
+  });
+
+  const invalidServerToFirstLeaf = new Map<string, string>();
+  servers.forEach((s) => {
+    const sid = String(s.id());
+    if (!validServerIds.has(sid)) {
+      const connectedLeaves: string[] = [];
+
+      leafToAllServers.forEach((serversSet, leafId) => {
+        if (serversSet.has(sid)) {
+          connectedLeaves.push(leafId);
+        }
+      });
+
+      connectedLeaves.sort((a, b) => {
+        const nodeA = leaf.find((l) => String(l.id()) === a);
+        const nodeB = leaf.find((l) => String(l.id()) === b);
+        return (nodeA?.data("label") || nodeA?.id() || a).localeCompare(
+          nodeB?.data("label") || nodeB?.id() || b,
+        );
+      });
+
+      if (connectedLeaves.length > 0) {
+        invalidServerToFirstLeaf.set(sid, connectedLeaves[0]!);
+      }
+    }
+  });
+
+  const leafToSuRoot = new Map<string, string>();
+  sortedLeafGroups.forEach(({ leafGroup, root }) => {
+    leafGroup.forEach((leafId) => leafToSuRoot.set(leafId, root));
+  });
+
+  const suGroups = new Map<string, any>();
+
+  sortedLeafGroups.forEach(({ leafGroup, root }) => {
+    const suGroup: any = {
+      leaves: [],
+      servers: [],
+      maxNodeSize: 0,
+    };
+
+    let maxSize = 0;
+    leafGroup.forEach((leafId) => {
+      const leafNode = leaf.find((l) => String(l.id()) === leafId);
+      if (leafNode) {
+        suGroup.leaves.push(leafNode);
+        maxSize = Math.max(maxSize, leafNode.data("size") || 35);
+      }
+    });
+
+    suGroup.maxNodeSize = maxSize;
+    suGroups.set(root, suGroup);
+  });
+
+  const assignedServerIds = new Set<string>();
+  sortedLeafGroups.forEach(({ leafGroup }) => {
+    leafGroup.forEach((leafId) => {
+      const validServers = leafToValidServers.get(leafId) || new Set();
+      validServers.forEach((sid) => {
+        if (!assignedServerIds.has(sid)) {
+          const serverNode = serverMap.get(sid);
+          if (serverNode) {
+            const root = leafToSuRoot.get(leafId);
+            if (root) {
+              const suGroup = suGroups.get(root);
+              if (suGroup) {
+                suGroup.servers.push(serverNode);
+                suGroup.maxNodeSize = Math.max(
+                  suGroup.maxNodeSize,
+                  serverNode.data("size") || 25,
+                );
+                assignedServerIds.add(sid);
+              }
+            }
+          }
+        }
+      });
+    });
+  });
+
+  servers.forEach((s) => {
+    const sid = String(s.id());
+    if (!validServerIds.has(sid)) {
+      const firstLeaf = invalidServerToFirstLeaf.get(sid);
+      if (firstLeaf) {
+        const root = leafToSuRoot.get(firstLeaf);
+        if (root) {
+          const suGroup = suGroups.get(root);
+          if (suGroup && !assignedServerIds.has(sid)) {
+            suGroup.servers.push(s);
+            suGroup.maxNodeSize = Math.max(suGroup.maxNodeSize, s.data("size") || 25);
+            assignedServerIds.add(sid);
+          }
+        }
+      }
+    }
+  });
+
+  suGroups.forEach((suGroup) => {
+    suGroup.servers.sort((a: any, b: any) => {
+      const isValidA = validServerIds.has(String(a.id()));
+      const isValidB = validServerIds.has(String(b.id()));
+
+      // 有效服务器在前，无效服务器在后
+      if (isValidA && !isValidB) return -1;
+      if (!isValidA && isValidB) return 1;
+
+      // 同类型的项目按自然序排序
+      const labelA = String(a.data("label") || a.id()).toLowerCase();
+      const labelB = String(b.data("label") || b.id()).toLowerCase();
+      return naturalSortCompare(labelA, labelB);
+    });
+  });
+
+  return suGroups;
+}
+
+interface CyLayoutOptions {
+  eles: CollectionArgument;
+  devicesPerRow?: number;
+  horizontalSpacingFactor?: number;
+  spineToLeafSpacingFactor?: number;
+  suVerticalSpacingFactor?: number;
+  suSpacingFactor?: number;
+  spineCoverageFactor?: number;
+  scaleFactor?: number;
+  suScope?: any;
+}
+
+const defaultOptions = {
+  devicesPerRow: 8,
+  horizontalSpacingFactor: 2.0,
+  spineToLeafSpacingFactor: 8.0,
+  suVerticalSpacingFactor: 4.0,
+  suSpacingFactor: 2.0,
+  spineCoverageFactor: 0.8,
+  scaleFactor: 0.5,
+};
+
+export function CyLayout(this: any, options: CyLayoutOptions) {
+  this.options = { ...defaultOptions, ...options };
+}
+
+CyLayout.prototype.run = function () {
+  const {
+    scaleFactor = 0.5,
+    devicesPerRow = 8,
+    horizontalSpacingFactor = 2.0,
+    spineToLeafSpacingFactor = 8.0,
+    suVerticalSpacingFactor = 4.0,
+    suSpacingFactor = 2.0,
+    spineCoverageFactor = 0.8,
+    suScope,
+  } = this.options;
+
+  const eles = this.options.eles;
+  const nodes = eles.nodes();
+  const edges = eles.edges();
+
+  console.log("[CLOS 布局] 节点分类统计:");
+  console.log("  节点总数:", nodes.length);
+  console.log("  链路数:", edges.length);
+
+  const switchElements = nodes.filter((n: any) => {
+    const type = String(n.data("type") || "").toLowerCase();
+    return type === "switch";
+  });
+
+  const serverElements = nodes.filter((n: any) => {
+    const type = String(n.data("type") || "").toLowerCase();
+    return type !== "switch";
+  });
+
+  const { servers, leaf, spine, maxSpineSize } = classifyNodes(
+    nodes,
+    switchElements,
+    serverElements,
+  );
+
+  console.log("[CLOS 布局] 节点分类:");
+  console.log("  SPINE:", spine.length);
+  console.log("  LEAF:", leaf.length);
+  console.log("  SERVER:", servers.length);
+
+  const sortedSpine = [...spine].sort((a, b) => {
+    return (a.data("label") || a.id()).localeCompare(b.data("label") || b.id());
+  });
+
+  const suGroups = groupBySU(servers, leaf, eles.nodes(), suScope);
+
+  console.log("[CLOS 布局] SU 分组结果:");
+  console.log("  SU 组数:", suGroups.size);
+  let idx = 1;
+  suGroups.forEach((group, root) => {
+    console.log(
+      `  SU${idx} (${root}): ${group.leaves.length} leaves, ${group.servers.length} servers`,
+    );
+    idx++;
+  });
+
+  const suList = Array.from(suGroups.entries()).sort(
+    ([, groupA], [, groupB]) => {
+      // 获取每个 SU 中最小的有效 server label
+      const validServersA = groupA.servers.filter((s) => {
+        if (!suScope) return true;
+        if (suScope.exclude?.(s)) return false;
+        if (suScope.include && !suScope.include(s)) return false;
+        return true;
+      });
+      const validServersB = groupB.servers.filter((s) => {
+        if (!suScope) return true;
+        if (suScope.exclude?.(s)) return false;
+        if (suScope.include && !suScope.include(s)) return false;
+        return true;
+      });
+
+      const minLabelA = validServersA.reduce(
+        (min, s) => {
+          const label = String(s.data("label") || s.id()).toLowerCase();
+          return naturalSortCompare(label, min) < 0 ? label : min;
+        },
+        String(
+          validServersA[0]?.data("label") || validServersA[0]?.id() || "",
+        ).toLowerCase(),
+      );
+
+      const minLabelB = validServersB.reduce(
+        (min, s) => {
+          const label = String(s.data("label") || s.id()).toLowerCase();
+          return naturalSortCompare(label, min) < 0 ? label : min;
+        },
+        String(
+          validServersB[0]?.data("label") || validServersB[0]?.id() || "",
+        ).toLowerCase(),
+      );
+
+      return naturalSortCompare(minLabelA, minLabelB);
+    },
+  );
+
+  const firstSu = suGroups.values().next().value;
+  const horizontalSpacing =
+    (firstSu?.maxNodeSize || 40) * horizontalSpacingFactor;
+  let maxSuWidth = 0;
+  suList.forEach(([, su]) => {
+    const suNodeCount = Math.max(
+      su.leaves.length,
+      Math.ceil(su.servers.length / devicesPerRow),
+    );
+    const width =
+      suNodeCount * su.maxNodeSize + (suNodeCount - 1) * horizontalSpacing;
+    maxSuWidth = Math.max(maxSuWidth, width);
+  });
+
+  const suSpacing = horizontalSpacing * suSpacingFactor;
+  const spineToLeafSpacing = maxSpineSize * spineToLeafSpacingFactor;
+
+  const positions: any = {};
+  const suPositions: Array<{ left: number; right: number }> = [];
+
+  let currentX = 0;
+
+  suList.forEach(([, su]) => {
+    const verticalSpacing = su.maxNodeSize * suVerticalSpacingFactor;
+
+    const suLeftX = currentX;
+    const leafContentWidth =
+      su.leaves.length * su.maxNodeSize +
+      (su.leaves.length - 1) * horizontalSpacing;
+    const serverContentWidth =
+      Math.min(su.servers.length, devicesPerRow) * su.maxNodeSize +
+      (Math.min(su.servers.length, devicesPerRow) - 1) * horizontalSpacing;
+
+    const contentLeft = suLeftX;
+    const contentRight =
+      suLeftX + Math.max(leafContentWidth, serverContentWidth);
+    const contentWidth = contentRight - contentLeft;
+
+    const leafY = spineToLeafSpacing;
+    const leafStartX =
+      contentLeft + (contentWidth - leafContentWidth) / 2 + su.maxNodeSize / 2;
+    su.leaves.forEach((l, i) => {
+      const leafX = leafStartX + i * (su.maxNodeSize + horizontalSpacing);
+      positions[l.id()] = { x: leafX * scaleFactor, y: leafY * scaleFactor };
+    });
+
+    su.servers.forEach((s, i) => {
+      const row = Math.floor(i / devicesPerRow);
+      const col = i % devicesPerRow;
+      const serverX =
+        contentLeft +
+        (contentWidth - serverContentWidth) / 2 +
+        col * (su.maxNodeSize + horizontalSpacing) +
+        su.maxNodeSize / 2;
+      const serverY =
+        spineToLeafSpacing +
+        su.maxNodeSize +
+        verticalSpacing +
+        row * (su.maxNodeSize + verticalSpacing);
+      positions[s.id()] = { x: serverX * scaleFactor, y: serverY * scaleFactor };
+    });
+
+    suPositions.push({ left: contentLeft, right: contentLeft + contentWidth });
+    currentX += contentWidth + suSpacing;
+  });
+
+  if (sortedSpine.length > 0 && suPositions.length > 0) {
+    const firstSu = suPositions[0]!;
+    const lastSu = suPositions[suPositions.length - 1]!;
+    const totalSuWidth = lastSu.right - firstSu.left;
+    const spineAreaWidth = totalSuWidth * spineCoverageFactor;
+    const startX = firstSu.left + (totalSuWidth - spineAreaWidth) / 2;
+
+    if (sortedSpine.length > 1) {
+      const spacing = spineAreaWidth / (sortedSpine.length - 1);
+      sortedSpine.forEach((sp, i) => {
+        const spineX = startX + i * spacing;
+        positions[sp.id()] = { x: spineX * scaleFactor, y: 0 };
+      });
+    } else if (sortedSpine[0]) {
+      const spineX = startX + spineAreaWidth / 2;
+      positions[sortedSpine[0].id()] = { x: spineX * scaleFactor, y: 0 };
+    }
+  }
+
+  nodes.layoutPositions(this, this.options, (node: any) => {
+    return positions[node.id()] || { x: 0, y: 0 };
+  });
+};
+
+export function register(cytoscape: any) {
+  cytoscape("layout", "clos", CyLayout);
+}

package/src/layouts/index.ts

@@ -0,0 +1,9 @@
+/**
+ * 布局插件导出
+ * 
+ * Clos 布局已通过 Graph 类内的 cytoscape 实例自动注册
+ * 此文件仅导出类型
+ */
+
+// SUScope 类型定义已在 packages/supergraph 中
+// SuperTopo 暂时不导出此类型