@flowgram.ai/free-auto-layout-plugin 0.1.0-alpha.14 → 0.1.0-alpha.16

package/dist/esm/index.js

@@ -2081,10 +2081,12 @@ import { definePluginCreator } from "@flowgram.ai/core";
 
 // src/services.ts
 import { inject, injectable } from "inversify";
+import { Rectangle } from "@flowgram.ai/utils";
 import {
   WorkflowDocument,
-  WorkflowNodeLinesData as WorkflowNodeLinesData2
+  WorkflowNodeLinesData
 } from "@flowgram.ai/free-layout-core";
+import { Playground } from "@flowgram.ai/core";
 
 // src/layout/constant.ts
 var DefaultLayoutConfig = {
@@ -2100,14 +2102,13 @@ var DefaultLayoutConfig = {
 };
 var DefaultLayoutOptions = {
   getFollowNode: void 0,
-  enableAnimation: false
+  disableFitView: false,
+  enableAnimation: false,
+  animationDuration: 300
 };
 
 // src/layout/store.ts
-import {
-  WorkflowNodeLinesData
-} from "@flowgram.ai/free-layout-core";
-import { FlowNodeBaseType, FlowNodeTransformData } from "@flowgram.ai/document";
+import { FlowNodeBaseType } from "@flowgram.ai/document";
 var LayoutStore = class {
   constructor(config) {
     this.config = config;
@@ -2136,6 +2137,7 @@ var LayoutStore = class {
     return Array.from(this.store.edges.values());
   }
   create(params, options) {
+    this.container = params.container;
     this.store = this.createStore(params);
     this.indexMap = this.createIndexMap();
     this.setOptions(options);
@@ -2143,10 +2145,7 @@ var LayoutStore = class {
   }
   /** 创建布局数据 */
   createStore(params) {
-    const { nodes, edges, container } = params;
-    this.container = container;
-    const layoutNodes = this.createLayoutNodes(nodes);
-    const layoutEdges = this.createEdgesStore(edges);
+    const { layoutNodes, layoutEdges } = params;
     const virtualEdges = this.createVirtualEdges(params);
     const store = {
       nodes: /* @__PURE__ */ new Map(),
@@ -2156,53 +2155,11 @@ var LayoutStore = class {
     layoutEdges.concat(virtualEdges).forEach((edge) => store.edges.set(edge.id, edge));
     return store;
   }
-  /** 创建节点布局数据 */
-  createLayoutNodes(nodes) {
-    const layoutNodes = nodes.map((node, index) => {
-      const { bounds } = node.getData(FlowNodeTransformData);
-      const layoutNode = {
-        id: node.id,
-        entity: node,
-        index: "",
-        // 初始化时，index 未计算
-        rank: -1,
-        // 初始化时，节点还未布局，层级为-1
-        order: -1,
-        // 初始化时，节点还未布局，顺序为-1
-        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
-      };
-      return layoutNode;
-    });
-    return layoutNodes;
-  }
-  /** 创建线条布局数据 */
-  createEdgesStore(edges) {
-    const layoutEdges = edges.map((edge) => {
-      const { from, to } = edge.info;
-      if (!from || !to || edge.vertical) {
-        return;
-      }
-      const layoutEdge = {
-        id: edge.id,
-        entity: edge,
-        from,
-        to,
-        fromIndex: "",
-        // 初始化时，index 未计算
-        toIndex: "",
-        // 初始化时，index 未计算
-        name: edge.id
-      };
-      return layoutEdge;
-    }).filter(Boolean);
-    return layoutEdges;
-  }
   /** 创建虚拟线条数据 */
   createVirtualEdges(params) {
-    const { nodes, edges } = params;
+    const { layoutNodes, layoutEdges } = params;
+    const nodes = layoutNodes.map((layoutNode) => layoutNode.entity);
+    const edges = layoutEdges.map((layoutEdge) => layoutEdge.entity);
     const groupNodes = nodes.filter((n) => n.flowNodeType === FlowNodeBaseType.GROUP);
     const virtualEdges = groupNodes.map((group) => {
       const { id: groupId, blocks = [] } = group;
@@ -2289,7 +2246,7 @@ var LayoutStore = class {
     });
     const visited = /* @__PURE__ */ new Set();
     const visit = (node) => {
-      if (visited.has(node.id)) {
+      if (!node || visited.has(node.id)) {
         return;
       }
       visited.add(node.id);
@@ -2297,7 +2254,7 @@ var LayoutStore = class {
       node.blocks.forEach((child) => {
         visit(child);
       });
-      const { outputLines } = node.getData(WorkflowNodeLinesData);
+      const { outputLines } = node.lines;
       const sortedLines = outputLines.sort((a, b) => {
         const aNode = this.getNode(a.to?.id);
         const bNode = this.getNode(b.to?.id);
@@ -2319,7 +2276,7 @@ var LayoutStore = class {
         visit(to);
       });
     };
-    visit(this.container);
+    visit(this.container.entity);
     const uniqueNodeIds = nodeIdList.reduceRight((acc, nodeId) => {
       if (!acc.includes(nodeId)) {
         acc.unshift(nodeId);
@@ -2352,7 +2309,7 @@ var LayoutStore = class {
 };
 
 // src/layout/position.ts
-import { startTween, TransformData } from "@flowgram.ai/core";
+import { startTween } from "@flowgram.ai/core";
 var LayoutPosition = class {
   constructor(store) {
     this.store = store;
@@ -2373,7 +2330,7 @@ var LayoutPosition = class {
       startTween({
         from: { d: 0 },
         to: { d: 100 },
-        duration: 300,
+        duration: this.store.options.animationDuration ?? 0,
         onUpdate: (v) => {
           this.store.nodes.forEach((layoutNode) => {
             this.updateNodePosition({ layoutNode, step: v.d });
@@ -2387,18 +2344,20 @@ var LayoutPosition = class {
   }
   updateNodePosition(params) {
     const { layoutNode, step } = params;
-    const transform = layoutNode.entity.getData(TransformData);
-    const position2 = {
+    const { transform } = layoutNode.entity.transform;
+    const layoutPosition = {
       x: layoutNode.position.x + layoutNode.offset.x,
-      y: layoutNode.position.y + layoutNode.offset.y
+      // layoutNode.position.y 是中心点，但画布节点原点在上边沿的中间，所以 y 坐标需要转化后一下
+      y: layoutNode.position.y - layoutNode.size.height / 2 + layoutNode.offset.y
+    };
+    const deltaX = (layoutPosition.x - transform.position.x) * step / 100;
+    const deltaY = (layoutPosition.y - transform.position.y) * step / 100;
+    const position2 = {
+      x: transform.position.x + deltaX,
+      y: transform.position.y + deltaY
     };
-    const deltaX = (position2.x - transform.position.x) * step / 100;
-    const deltaY = (position2.y - transform.bounds.height / 2 - transform.position.y) * step / 100;
     transform.update({
-      position: {
-        x: transform.position.x + deltaX,
-        y: transform.position.y + deltaY
-      }
+      position: position2
     });
     const document = layoutNode.entity.document;
     document.layout.updateAffectedTransform(layoutNode.entity);
@@ -2406,7 +2365,6 @@ var LayoutPosition = class {
 };
 
 // src/layout/dagre.ts
-import { FlowNodeTransformData as FlowNodeTransformData2 } from "@flowgram.ai/document";
 import { Graph as DagreGraph } from "@dagrejs/graphlib";
 var DagreLayout = class {
   constructor(store) {
@@ -2460,13 +2418,7 @@ var DagreLayout = class {
     return graph;
   }
   graphSetData() {
-    const nodes = Array.from(this.store.nodes.values());
-    const edges = Array.from(this.store.edges.values()).sort((next, prev) => {
-      if (next.fromIndex === prev.fromIndex) {
-        return next.toIndex < prev.toIndex ? -1 : 1;
-      }
-      return next.fromIndex < prev.fromIndex ? -1 : 1;
-    });
+    const { nodes, edges } = this.store;
     nodes.forEach((layoutNode) => {
       this.graph.setNode(layoutNode.index, {
         originID: layoutNode.id,
@@ -2474,7 +2426,12 @@ var DagreLayout = class {
         height: layoutNode.size.height
       });
     });
-    edges.forEach((layoutEdge) => {
+    edges.sort((next, prev) => {
+      if (next.fromIndex === prev.fromIndex) {
+        return next.toIndex < prev.toIndex ? -1 : 1;
+      }
+      return next.fromIndex < prev.fromIndex ? -1 : 1;
+    }).forEach((layoutEdge) => {
       this.graph.setEdge({
         v: layoutEdge.fromIndex,
         w: layoutEdge.toIndex,
@@ -2505,12 +2462,11 @@ var DagreLayout = class {
     return Number.isNaN(number) ? 0 : number;
   }
   getOffsetX(layoutNode) {
-    if (!layoutNode.hasChildren) {
+    if (layoutNode.layoutNodes.length === 0) {
       return 0;
     }
-    const nodeTransform = layoutNode.entity.getData(FlowNodeTransformData2);
-    const { bounds, padding } = nodeTransform;
-    const leftOffset = -bounds.width / 2 + padding.left;
+    const { padding } = layoutNode;
+    const leftOffset = -layoutNode.size.width / 2 + padding.left;
     return leftOffset;
   }
   setOrderAndRank(g) {
@@ -2612,33 +2568,122 @@ var AutoLayoutService = class {
     };
   }
   async layout(options = {}) {
-    await this.layoutNode(this.document.root, {
+    const layoutOptions = {
       ...DefaultLayoutOptions,
       ...options
-    });
-  }
-  async layoutNode(node, options) {
-    const nodes = node.blocks;
-    if (!nodes || !Array.isArray(nodes) || !nodes.length) {
+    };
+    const containerNode = layoutOptions.containerNode ?? this.document.root;
+    const container = this.createLayoutNode(containerNode, options);
+    const layouts = await this.layoutNode(container, layoutOptions);
+    const rect = this.getLayoutNodeRect(container);
+    const positionPromise = layouts.map((layout2) => layout2.position());
+    const fitViewPromise = this.fitView(layoutOptions, rect);
+    await Promise.all([...positionPromise, fitViewPromise]);
+  }
+  async fitView(options, rect) {
+    if (options.disableFitView === true) {
       return;
     }
-    const edges = this.getNodesAllLines(nodes);
-    await Promise.all(nodes.map(async (child) => this.layoutNode(child, options)));
+    return this.playground.config.fitView(rect, options.enableAnimation, 30);
+  }
+  async layoutNode(container, options) {
+    const { layoutNodes, layoutEdges } = container;
+    if (layoutNodes.length === 0) {
+      return [];
+    }
+    const childrenLayouts = (await Promise.all(layoutNodes.map((n) => this.layoutNode(n, options)))).flat();
     const layout2 = new Layout(this.layoutConfig);
-    layout2.init({ nodes, edges, container: node }, options);
+    layout2.init({ container, layoutNodes, layoutEdges }, options);
     layout2.layout();
-    await layout2.position();
+    const rect = this.getLayoutNodeRect(container);
+    container.size = {
+      width: rect.width,
+      height: rect.height
+    };
+    return [...childrenLayouts, layout2];
+  }
+  createLayoutNodes(nodes, options) {
+    return nodes.map((node) => this.createLayoutNode(node, options));
+  }
+  /** 创建节点布局数据 */
+  createLayoutNode(node, options) {
+    const { blocks } = node;
+    const edges = this.getNodesAllLines(blocks);
+    const layoutNodes = this.createLayoutNodes(blocks, options);
+    const layoutEdges = this.createLayoutEdges(edges);
+    const { bounds, padding } = node.transform;
+    const { width: width2, height, center } = bounds;
+    const { x, y } = center;
+    const layoutNode = {
+      id: node.id,
+      entity: node,
+      index: "",
+      // 初始化时，index 未计算
+      rank: -1,
+      // 初始化时，节点还未布局，层级为-1
+      order: -1,
+      // 初始化时，节点还未布局，顺序为-1
+      position: { x, y },
+      offset: { x: 0, y: 0 },
+      padding,
+      size: { width: width2, height },
+      layoutNodes,
+      layoutEdges
+    };
+    return layoutNode;
+  }
+  createLayoutEdges(edges) {
+    const layoutEdges = edges.map((edge) => this.createLayoutEdge(edge)).filter(Boolean);
+    return layoutEdges;
+  }
+  /** 创建线条布局数据 */
+  createLayoutEdge(edge) {
+    const { from, to } = edge.info;
+    if (!from || !to || edge.vertical) {
+      return;
+    }
+    const layoutEdge = {
+      id: edge.id,
+      entity: edge,
+      from,
+      to,
+      fromIndex: "",
+      // 初始化时，index 未计算
+      toIndex: "",
+      // 初始化时，index 未计算
+      name: edge.id
+    };
+    return layoutEdge;
   }
   getNodesAllLines(nodes) {
     const lines = nodes.map((node) => {
-      const linesData = node.getData(WorkflowNodeLinesData2);
+      const linesData = node.getData(WorkflowNodeLinesData);
       const outputLines = linesData.outputLines.filter(Boolean);
       const inputLines = linesData.inputLines.filter(Boolean);
       return [...outputLines, ...inputLines];
     }).flat();
     return lines;
   }
+  getLayoutNodeRect(layoutNode) {
+    const rects = layoutNode.layoutNodes.map((node) => this.layoutNodeRect(node));
+    const rect = Rectangle.enlarge(rects);
+    const { padding } = layoutNode;
+    const width2 = rect.width + padding.left + padding.right;
+    const height = rect.height + padding.top + padding.bottom;
+    const x = rect.x - padding.left;
+    const y = rect.y - padding.top;
+    return new Rectangle(x, y, width2, height);
+  }
+  layoutNodeRect(layoutNode) {
+    const { width: width2, height } = layoutNode.size;
+    const x = layoutNode.position.x - width2 / 2;
+    const y = layoutNode.position.y - height / 2;
+    return new Rectangle(x, y, width2, height);
+  }
 };
+__decorateClass([
+  inject(Playground)
+], AutoLayoutService.prototype, "playground", 2);
 __decorateClass([
   inject(WorkflowDocument)
 ], AutoLayoutService.prototype, "document", 2);