@flowgram.ai/free-auto-layout-plugin 0.1.0-alpha.6 → 0.1.0-alpha.8

package/dist/esm/index.js

@@ -2083,11 +2083,14 @@ import { definePluginCreator } from "@flowgram.ai/core";
 import { inject, injectable } from "inversify";
 import {
   WorkflowDocument,
-  WorkflowNodeLinesData
+  WorkflowNodeLinesData as WorkflowNodeLinesData2
 } from "@flowgram.ai/free-layout-core";
 
 // src/layout/store.ts
-import { FlowNodeTransformData } from "@flowgram.ai/document";
+import {
+  WorkflowNodeLinesData
+} from "@flowgram.ai/free-layout-core";
+import { FlowNodeBaseType, FlowNodeTransformData } from "@flowgram.ai/document";
 var LayoutStore = class {
   constructor() {
     this.init = false;
@@ -2118,12 +2121,23 @@ var LayoutStore = class {
   }
   /** 创建布局数据 */
   createStore(params) {
-    const { nodes, edges } = params;
+    const { nodes, edges, container } = params;
+    this.container = container;
+    const layoutNodes = this.createLayoutNodes(nodes);
+    const layoutEdges = this.createEdgesStore(edges);
+    const virtualEdges = this.createVirtualEdges(params);
     const store = {
       nodes: /* @__PURE__ */ new Map(),
       edges: /* @__PURE__ */ new Map()
     };
-    nodes.forEach((node, index) => {
+    layoutNodes.forEach((node) => store.nodes.set(node.id, node));
+    layoutEdges.concat(virtualEdges).forEach((edge) => store.edges.set(edge.id, edge));
+    return store;
+  }
+  /** 创建节点布局数据 */
+  createLayoutNodes(nodes) {
+    const layoutNodes = nodes.map((node, index) => {
+      var _a;
       const { bounds } = node.getData(FlowNodeTransformData);
       const layoutNode = {
         id: node.id,
@@ -2137,11 +2151,15 @@ var LayoutStore = class {
         position: { x: bounds.center.x, y: bounds.center.y },
         offset: { x: 0, y: 0 },
         size: { width: bounds.width, height: bounds.height },
-        hasChildren: node.collapsedChildren?.length > 0
+        hasChildren: ((_a = node.collapsedChildren) == null ? void 0 : _a.length) > 0
       };
-      store.nodes.set(layoutNode.id, layoutNode);
+      return layoutNode;
     });
-    edges.forEach((edge) => {
+    return layoutNodes;
+  }
+  /** 创建线条布局数据 */
+  createEdgesStore(edges) {
+    const layoutEdges = edges.map((edge) => {
       const { from, to } = edge.info;
       if (!from || !to || edge.vertical) {
         return;
@@ -2157,9 +2175,64 @@ var LayoutStore = class {
         // 初始化时，index 未计算
         name: edge.id
       };
-      store.edges.set(layoutEdge.id, layoutEdge);
-    });
-    return store;
+      return layoutEdge;
+    }).filter(Boolean);
+    return layoutEdges;
+  }
+  /** 创建虚拟线条数据 */
+  createVirtualEdges(params) {
+    const { nodes, edges } = params;
+    const groupNodes = nodes.filter((n) => n.flowNodeType === FlowNodeBaseType.GROUP);
+    const virtualEdges = groupNodes.map((group) => {
+      const { id: groupId, blocks = [] } = group;
+      const blockIdSet = new Set(blocks.map((b) => b.id));
+      const groupFromEdges = edges.filter((edge) => {
+        var _a, _b;
+        return blockIdSet.has((_b = (_a = edge.to) == null ? void 0 : _a.id) != null ? _b : "");
+      }).map((edge) => {
+        const { from, to } = edge.info;
+        if (!from || !to || edge.vertical) {
+          return;
+        }
+        const id = `virtual_${groupId}_${to}`;
+        const layoutEdge = {
+          id,
+          entity: edge,
+          from,
+          to: groupId,
+          fromIndex: "",
+          // 初始化时，index 未计算
+          toIndex: "",
+          // 初始化时，index 未计算
+          name: id
+        };
+        return layoutEdge;
+      }).filter(Boolean);
+      const groupToEdges = edges.filter((edge) => {
+        var _a;
+        return blockIdSet.has((_a = edge.from.id) != null ? _a : "");
+      }).map((edge) => {
+        const { from, to } = edge.info;
+        if (!from || !to || edge.vertical) {
+          return;
+        }
+        const id = `virtual_${groupId}_${from}`;
+        const layoutEdge = {
+          id,
+          entity: edge,
+          from: groupId,
+          to,
+          fromIndex: "",
+          // 初始化时，index 未计算
+          toIndex: "",
+          // 初始化时，index 未计算
+          name: id
+        };
+        return layoutEdge;
+      }).filter(Boolean);
+      return [...groupFromEdges, ...groupToEdges];
+    }).flat();
+    return virtualEdges;
   }
   /** 创建节点索引映射 */
   createIndexMap() {
@@ -2196,27 +2269,37 @@ var LayoutStore = class {
     this.nodes.forEach((node) => {
       nodeIdList.push(node.id);
     });
-    const sameFromEdges = /* @__PURE__ */ new Map();
     this.edges.forEach((edge) => {
       nodeIdList.push(edge.to);
-      if (edge.entity.info.fromPort) {
-        const edgesForFrom = sameFromEdges.get(edge.from) || [];
-        sameFromEdges.set(edge.from, [...edgesForFrom, edge]);
-      }
     });
-    sameFromEdges.forEach((edges, from) => {
-      const sortedEdges = edges.sort((a, b) => {
-        const aPort = a.entity.fromPort;
-        const bPort = b.entity.fromPort;
+    const visited = /* @__PURE__ */ new Set();
+    const visit = (node) => {
+      if (visited.has(node.id)) {
+        return;
+      }
+      visited.add(node.id);
+      nodeIdList.push(node.id);
+      node.blocks.forEach((child) => {
+        visit(child);
+      });
+      const { outputLines } = node.getData(WorkflowNodeLinesData);
+      const sortedLines = outputLines.sort((a, b) => {
+        const aPort = a.fromPort;
+        const bPort = b.fromPort;
         if (aPort && bPort) {
           return aPort.point.y - bPort.point.y;
         }
         return 0;
       });
-      sortedEdges.forEach((edge) => {
-        nodeIdList.push(edge.to);
+      sortedLines.forEach((line) => {
+        const { to } = line;
+        if (!to) {
+          return;
+        }
+        visit(to);
       });
-    });
+    };
+    visit(this.container);
     const uniqueNodeIds = nodeIdList.reduceRight((acc, nodeId) => {
       if (!acc.includes(nodeId)) {
         acc.unshift(nodeId);
@@ -2228,7 +2311,6 @@ var LayoutStore = class {
 };
 
 // src/layout/position.ts
-import { FlowNodeTransformData as FlowNodeTransformData2 } from "@flowgram.ai/document";
 import { startTween, TransformData } from "@flowgram.ai/core";
 var LayoutPosition = class {
   constructor(store) {
@@ -2260,23 +2342,19 @@ var LayoutPosition = class {
     };
     const deltaX = (position2.x - transform.position.x) * step / 100;
     const deltaY = (position2.y - transform.bounds.height / 2 - transform.position.y) * step / 100;
-    if (layoutNode.hasChildren) {
-      layoutNode.entity.collapsedChildren.forEach((childNode) => {
-        const childNodeTransformData = childNode.getData(FlowNodeTransformData2);
-        childNodeTransformData.fireChange();
-      });
-    }
     transform.update({
       position: {
         x: transform.position.x + deltaX,
         y: transform.position.y + deltaY
       }
     });
+    const document = layoutNode.entity.document;
+    document.layout.updateAffectedTransform(layoutNode.entity);
   }
 };
 
 // src/layout/dagre.ts
-import { FlowNodeTransformData as FlowNodeTransformData3 } from "@flowgram.ai/document";
+import { FlowNodeTransformData as FlowNodeTransformData2 } from "@flowgram.ai/document";
 import { Graph as DagreGraph } from "@dagrejs/graphlib";
 
 // src/layout/constant.ts
@@ -2364,6 +2442,7 @@ var DagreLayout = class {
   }
   layoutSetPosition() {
     this.store.nodes.forEach((layoutNode) => {
+      var _a;
       const offsetX = this.getOffsetX(layoutNode);
       const graphNode = this.graph.node(layoutNode.index);
       if (!graphNode) {
@@ -2374,7 +2453,7 @@ var DagreLayout = class {
         };
         return;
       }
-      layoutNode.rank = graphNode.rank ?? -1;
+      layoutNode.rank = (_a = graphNode.rank) != null ? _a : -1;
       layoutNode.position = {
         x: this.normalizeNumber(graphNode.x) + offsetX,
         y: this.normalizeNumber(graphNode.y)
@@ -2388,7 +2467,7 @@ var DagreLayout = class {
     if (!layoutNode.hasChildren) {
       return 0;
     }
-    const nodeTransform = layoutNode.entity.getData(FlowNodeTransformData3);
+    const nodeTransform = layoutNode.entity.getData(FlowNodeTransformData2);
     const { bounds, padding } = nodeTransform;
     const leftOffset = -bounds.width / 2 + padding.left;
     return leftOffset;
@@ -2404,10 +2483,13 @@ var DagreLayout = class {
     g.nodes().forEach((i) => {
       const graphNode = g.node(i);
       const layoutNode = this.store.getNodeByIndex(i);
-      if (!graphNode || !layoutNode?.followedBy) return;
+      if (!graphNode || !(layoutNode == null ? void 0 : layoutNode.followedBy)) return;
       const { followedBy } = layoutNode;
       const { rank: targetRank, order: targetOrder } = graphNode;
-      const followIndexes = followedBy.map((id) => this.store.getNode(id)?.index).filter(Boolean);
+      const followIndexes = followedBy.map((id) => {
+        var _a;
+        return (_a = this.store.getNode(id)) == null ? void 0 : _a.index;
+      }).filter(Boolean);
       const followSet = new Set(followIndexes);
       const rankIndexes = rankGroup.get(targetRank);
       if (!rankIndexes) return;
@@ -2421,12 +2503,13 @@ var DagreLayout = class {
         graphNode2.order = graphNode2.order + followedBy.length;
       });
       followIndexes.forEach((followIndex, index) => {
+        var _a, _b;
         const graphNode2 = g.node(followIndex);
         graphNode2.order = targetOrder + index + 1;
         const originRank = graphNode2.rank;
         graphNode2.rank = targetRank;
-        rankGroup.get(originRank)?.delete(followIndex);
-        rankGroup.get(targetRank)?.add(followIndex);
+        (_a = rankGroup.get(originRank)) == null ? void 0 : _a.delete(followIndex);
+        (_b = rankGroup.get(targetRank)) == null ? void 0 : _b.add(followIndex);
       });
     });
   }
@@ -2445,12 +2528,13 @@ var DagreLayout = class {
   rankGroup(g) {
     const rankGroup = /* @__PURE__ */ new Map();
     g.nodes().forEach((i) => {
+      var _a;
       const graphNode = g.node(i);
       const rank2 = graphNode.rank;
       if (!rankGroup.has(rank2)) {
         rankGroup.set(rank2, /* @__PURE__ */ new Set());
       }
-      rankGroup.get(rank2)?.add(i);
+      (_a = rankGroup.get(rank2)) == null ? void 0 : _a.add(i);
     });
     return rankGroup;
   }
@@ -2483,7 +2567,8 @@ var Layout = class {
     if (!getFollowNode) return;
     const context = { store: this._store };
     this._store.nodes.forEach((node) => {
-      const followTo = getFollowNode(node, context)?.followTo;
+      var _a;
+      const followTo = (_a = getFollowNode(node, context)) == null ? void 0 : _a.followTo;
       if (!followTo) return;
       const followToNode = this._store.getNode(followTo);
       if (!followToNode) return;
@@ -2502,20 +2587,26 @@ var AutoLayoutService = class {
     await this.layoutNode(this.document.root, options);
   }
   async layoutNode(node, options) {
-    const nodes = node.collapsedChildren;
+    const nodes = node.blocks;
     if (!nodes || !Array.isArray(nodes) || !nodes.length) {
       return;
     }
-    const edges = node.collapsedChildren.map((child) => {
-      const childLinesData = child.getData(WorkflowNodeLinesData);
-      return childLinesData.outputLines.filter(Boolean);
-    }).flat();
+    const edges = this.getNodesAllLines(nodes);
     await Promise.all(nodes.map(async (child) => this.layoutNode(child, options)));
     const layout2 = new Layout();
-    layout2.init({ nodes, edges }, options);
+    layout2.init({ nodes, edges, container: node }, options);
     layout2.layout();
     await layout2.position();
   }
+  getNodesAllLines(nodes) {
+    const lines = nodes.map((node) => {
+      const linesData = node.getData(WorkflowNodeLinesData2);
+      const outputLines = linesData.outputLines.filter(Boolean);
+      const inputLines = linesData.inputLines.filter(Boolean);
+      return [...outputLines, ...inputLines];
+    }).flat();
+    return lines;
+  }
 };
 __decorateClass([
   inject(WorkflowDocument)