@flowgram.ai/fixed-layout-core 0.1.0

package/dist/index.js

@@ -0,0 +1,1503 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  FixedLayoutContainerModule: () => FixedLayoutContainerModule,
+  FixedLayoutRegistries: () => FixedLayoutRegistries
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/fixed-layout-container-module.ts
+var import_inversify2 = require("inversify");
+var import_renderer7 = require("@flowgram.ai/renderer");
+var import_document24 = require("@flowgram.ai/document");
+var import_core2 = require("@flowgram.ai/core");
+var import_utils6 = require("@flowgram.ai/utils");
+
+// src/flow-registers.ts
+var import_inversify = require("inversify");
+var import_renderer6 = require("@flowgram.ai/renderer");
+var import_document23 = require("@flowgram.ai/document");
+var import_core = require("@flowgram.ai/core");
+
+// src/activities/end.ts
+var import_document = require("@flowgram.ai/document");
+var EndRegistry = {
+  type: import_document.FlowNodeBaseType.END,
+  meta: {
+    draggable: false,
+    isNodeEnd: true,
+    selectable: false,
+    copyDisable: true
+  },
+  // 结束节点没有出边和 label
+  getLines() {
+    return [];
+  },
+  getLabels() {
+    return [];
+  }
+};
+
+// src/activities/dynamic-split.ts
+var import_document2 = require("@flowgram.ai/document");
+var DynamicSplitRegistry = {
+  type: import_document2.FlowNodeSplitType.DYNAMIC_SPLIT,
+  meta: {
+    hidden: true,
+    inlineSpacingAfter: (node) => node.collapsed && node.entity.collapsedChildren.length > 1 ? 21 : 0,
+    // 判断是否有分支节点
+    spacing: (node) => {
+      const spacing = (0, import_document2.getDefaultSpacing)(node.entity, import_document2.ConstantKeys.NODE_SPACING);
+      return node.children.length === 1 ? spacing : spacing / 2;
+    }
+  },
+  getLabels(transition) {
+    if (transition.isNodeEnd) {
+      return [];
+    }
+    return [
+      {
+        type: import_document2.FlowTransitionLabelEnum.ADDER_LABEL,
+        offset: transition.transform.outputPoint
+      }
+    ];
+  },
+  onCreate(node, json) {
+    return node.document.addInlineBlocks(node, json.blocks || []);
+  },
+  getInputPoint(transform) {
+    return transform.firstChild?.inputPoint || transform.defaultInputPoint;
+  },
+  getOutputPoint(transform, layout) {
+    const isVertical = import_document2.FlowLayoutDefault.isVertical(layout);
+    const noInlineBlocks = transform.children.length === 1;
+    const lastChildOutput = transform.lastChild?.outputPoint;
+    const spacing = (0, import_document2.getDefaultSpacing)(transform.entity, import_document2.ConstantKeys.NODE_SPACING);
+    if (isVertical) {
+      return {
+        x: lastChildOutput ? lastChildOutput.x : transform.bounds.center.x,
+        y: transform.bounds.bottom + (noInlineBlocks ? spacing / 2 : 0)
+      };
+    }
+    return {
+      x: transform.bounds.right + (noInlineBlocks ? spacing / 2 : 0),
+      y: lastChildOutput ? lastChildOutput.y : transform.bounds.center.y
+    };
+  },
+  addChild(node, json, options = {}) {
+    const { index } = options;
+    const document = node.document;
+    const parentId = `$inlineBlocks$${node.id}`;
+    let parent = document.getNode(parentId);
+    if (!parent) {
+      parent = document.addNode({
+        id: parentId,
+        type: "inlineBlocks",
+        originParent: node,
+        parent: node
+      });
+    }
+    return document.addBlock(node, json, void 0, void 0, index);
+  }
+};
+
+// src/activities/static-split.ts
+var import_document3 = require("@flowgram.ai/document");
+var StaticSplitRegistry = {
+  extend: import_document3.FlowNodeSplitType.DYNAMIC_SPLIT,
+  type: import_document3.FlowNodeSplitType.STATIC_SPLIT,
+  extendChildRegistries: [
+    {
+      type: import_document3.FlowNodeBaseType.INLINE_BLOCKS,
+      getLabels() {
+        return [];
+      }
+    }
+  ]
+};
+
+// src/activities/block.ts
+var import_document4 = require("@flowgram.ai/document");
+var BlockRegistry = {
+  type: import_document4.FlowNodeBaseType.BLOCK,
+  meta: {
+    spacing: import_document4.DEFAULT_SPACING.NULL,
+    inlineSpacingAfter: import_document4.DEFAULT_SPACING.INLINE_BLOCK_PADDING_BOTTOM,
+    hidden: true
+  },
+  getLines(transition) {
+    const currentTransform = transition.transform;
+    const { isVertical } = transition.entity;
+    const lines = [
+      {
+        type: import_document4.FlowTransitionLineEnum.DIVERGE_LINE,
+        from: currentTransform.parent.inputPoint,
+        to: currentTransform.inputPoint,
+        side: import_document4.LABEL_SIDE_TYPE.NORMAL_BRANCH
+      }
+    ];
+    const hasBranchDraggingAdder = currentTransform && currentTransform.entity.isInlineBlock && transition.renderData.draggable;
+    if (hasBranchDraggingAdder) {
+      if (isVertical) {
+        const currentOffsetRightX = currentTransform.firstChild?.bounds?.right || 0;
+        const nextOffsetLeftX = currentTransform.next?.firstChild?.bounds?.left || 0;
+        const currentInputPointY = currentTransform.inputPoint.y;
+        if (currentTransform?.next) {
+          lines.push({
+            type: import_document4.FlowTransitionLineEnum.DRAGGING_LINE,
+            from: currentTransform.parent.inputPoint,
+            to: {
+              x: (currentOffsetRightX + nextOffsetLeftX) / 2,
+              y: currentInputPointY
+            },
+            side: import_document4.LABEL_SIDE_TYPE.NORMAL_BRANCH
+          });
+        }
+      } else {
+        const currentOffsetRightY = currentTransform.firstChild?.bounds?.bottom || 0;
+        const nextOffsetLeftY = currentTransform.next?.firstChild?.bounds?.top || 0;
+        const currentInputPointX = currentTransform.inputPoint.x;
+        if (currentTransform?.next) {
+          lines.push({
+            type: import_document4.FlowTransitionLineEnum.DRAGGING_LINE,
+            from: currentTransform.parent.inputPoint,
+            to: {
+              x: currentInputPointX,
+              y: (currentOffsetRightY + nextOffsetLeftY) / 2
+            },
+            side: import_document4.LABEL_SIDE_TYPE.NORMAL_BRANCH
+          });
+        }
+      }
+    }
+    if (!transition.isNodeEnd) {
+      lines.push({
+        type: import_document4.FlowTransitionLineEnum.MERGE_LINE,
+        from: currentTransform.outputPoint,
+        to: currentTransform.parent.outputPoint,
+        side: import_document4.LABEL_SIDE_TYPE.NORMAL_BRANCH
+      });
+    }
+    return lines;
+  },
+  getInputPoint(trans) {
+    const child = trans.firstChild;
+    return child ? child.inputPoint : trans.defaultInputPoint;
+  },
+  getOutputPoint(trans, layout) {
+    const isVertical = import_document4.FlowLayoutDefault.isVertical(layout);
+    const child = trans.lastChild;
+    if (isVertical) {
+      return {
+        x: child ? child.outputPoint.x : trans.bounds.bottomCenter.x,
+        y: trans.bounds.bottom
+      };
+    }
+    return {
+      x: trans.bounds.right,
+      y: child ? child.outputPoint.y : trans.bounds.rightCenter.y
+    };
+  },
+  getLabels(transition) {
+    const currentTransform = transition.transform;
+    const { isVertical } = transition.entity;
+    const draggingLabel = [];
+    const hasBranchDraggingAdder = currentTransform && currentTransform.entity.isInlineBlock && transition.renderData.draggable;
+    if (hasBranchDraggingAdder) {
+      if (isVertical) {
+        const currentOffsetRightX = currentTransform.firstChild?.bounds?.right || 0;
+        const nextOffsetLeftX = currentTransform.next?.firstChild?.bounds?.left || 0;
+        const currentInputPointY = currentTransform.inputPoint.y;
+        if (currentTransform?.next) {
+          draggingLabel.push({
+            offset: {
+              x: (currentOffsetRightX + nextOffsetLeftX) / 2,
+              y: currentInputPointY
+            },
+            type: import_document4.FlowTransitionLabelEnum.BRANCH_DRAGGING_LABEL,
+            width: nextOffsetLeftX - currentOffsetRightX,
+            props: {
+              side: import_document4.LABEL_SIDE_TYPE.NORMAL_BRANCH
+            }
+          });
+        }
+      } else {
+        const currentOffsetRightY = currentTransform.firstChild?.bounds?.bottom || 0;
+        const nextOffsetLeftY = currentTransform.next?.firstChild?.bounds?.top || 0;
+        const currentInputPointX = currentTransform.inputPoint.x;
+        if (currentTransform?.next) {
+          draggingLabel.push({
+            offset: {
+              x: currentInputPointX,
+              y: (currentOffsetRightY + nextOffsetLeftY) / 2
+            },
+            type: import_document4.FlowTransitionLabelEnum.BRANCH_DRAGGING_LABEL,
+            width: nextOffsetLeftY - currentOffsetRightY,
+            props: {
+              side: import_document4.LABEL_SIDE_TYPE.NORMAL_BRANCH
+            }
+          });
+        }
+      }
+    }
+    return [...draggingLabel];
+  },
+  addChild(node, json, options = {}) {
+    const { index } = options;
+    const document = node.document;
+    return document.addNode({
+      ...json,
+      ...options,
+      parent: node,
+      index: typeof index === "number" ? index + 1 : void 0
+    });
+  }
+};
+
+// src/activities/inline-blocks.ts
+var import_utils = require("@flowgram.ai/utils");
+var import_renderer = require("@flowgram.ai/renderer");
+var import_document5 = require("@flowgram.ai/document");
+var InlineBlocksRegistry = {
+  type: import_document5.FlowNodeBaseType.INLINE_BLOCKS,
+  meta: {
+    hidden: true,
+    spacing: (node) => (0, import_document5.getDefaultSpacing)(node.entity, import_document5.ConstantKeys.NODE_SPACING),
+    isInlineBlocks: true,
+    inlineSpacingPre: import_document5.DEFAULT_SPACING.INLINE_BLOCKS_PADDING_TOP,
+    inlineSpacingAfter: (node) => (0, import_document5.getDefaultSpacing)(node.entity, import_document5.ConstantKeys.INLINE_BLOCKS_PADDING_BOTTOM)
+  },
+  /**
+   * 控制子分支的间距
+   * @param child
+   */
+  getChildDelta(child, layout) {
+    const isVertical = import_document5.FlowLayoutDefault.isVertical(layout);
+    const preTransform = child.entity.pre?.getData(import_document5.FlowNodeTransformData);
+    if (preTransform) {
+      const { localBounds: preBounds } = preTransform;
+      if (isVertical) {
+        const leftSpacing = preTransform.size.width + preTransform.originDeltaX;
+        const delta = Math.max(
+          child.parent.minInlineBlockSpacing - leftSpacing,
+          import_document5.DEFAULT_SPACING.MARGIN_RIGHT - child.originDeltaX
+        );
+        return {
+          // 这里需要加上原点的偏移量，并加上水平间距
+          x: preBounds.right + delta,
+          y: 0
+        };
+      } else {
+        const bottomSpacing = preTransform.size.height + preTransform.originDeltaY;
+        const delta = Math.max(
+          child.parent.minInlineBlockSpacing - bottomSpacing,
+          import_document5.DEFAULT_SPACING.MARGIN_RIGHT - child.originDeltaY
+        );
+        return {
+          x: 0,
+          // 这里需要加上原点的偏移量，并加上垂直间距
+          y: preBounds.bottom + delta
+        };
+      }
+    }
+    return {
+      x: 0,
+      y: 0
+    };
+  },
+  /**
+   * 控制条件分支居中布局
+   * @param trans
+   */
+  getDelta(trans, layout) {
+    const isVertical = import_document5.FlowLayoutDefault.isVertical(layout);
+    const { pre, collapsed } = trans;
+    if (collapsed) {
+      return { x: 0, y: 0 };
+    }
+    if (isVertical) {
+      const preCenter2 = pre.localBounds.center.x;
+      const firstBlockX = trans.firstChild?.transform.position.x || 0;
+      const lastBlockX = trans.lastChild?.transform.position.x || 0;
+      const currentCenter2 = (lastBlockX - firstBlockX) / 2;
+      return {
+        x: preCenter2 - currentCenter2,
+        y: 0
+      };
+    }
+    const preCenter = pre.localBounds.center.y;
+    const firstBlockY = trans.firstChild?.transform.position.y || 0;
+    const lastBlockY = trans.lastChild?.transform.position.y || 0;
+    const currentCenter = (lastBlockY - firstBlockY) / 2;
+    return {
+      x: 0,
+      y: preCenter - currentCenter
+    };
+  },
+  getLabels(transition) {
+    return getBranchAdderLabel(transition);
+  },
+  getLines() {
+    return [];
+  },
+  // 和前序节点对齐
+  getInputPoint(transform, layout) {
+    const isVertical = import_document5.FlowLayoutDefault.isVertical(layout);
+    if (isVertical) {
+      return {
+        x: transform.pre?.outputPoint.x || 0,
+        y: transform.bounds.top
+      };
+    }
+    return {
+      x: transform.bounds.left,
+      y: transform.pre?.outputPoint.y || 0
+    };
+  },
+  getOutputPoint(transform, layout) {
+    const isVertical = import_document5.FlowLayoutDefault.isVertical(layout);
+    if (transform.collapsed) {
+      return transform.inputPoint;
+    }
+    if (isVertical) {
+      return {
+        x: transform.pre?.outputPoint.x || 0,
+        y: transform.bounds.bottom
+      };
+    }
+    return {
+      x: transform.bounds.right,
+      y: transform.pre?.outputPoint.y || 0
+    };
+  }
+};
+function getBranchAdderLabel(transition) {
+  const { isVertical } = transition.entity;
+  const currentTransform = transition.transform;
+  if (currentTransform.collapsed) {
+    return [
+      {
+        type: import_document5.FlowTransitionLabelEnum.COLLAPSE_LABEL,
+        offset: import_utils.Point.move(currentTransform.inputPoint, isVertical ? { y: 10 } : { x: 10 }),
+        props: {
+          activateNode: transition.entity.pre
+        }
+      }
+    ];
+  }
+  return [
+    {
+      type: import_document5.FlowTransitionLabelEnum.CUSTOM_LABEL,
+      renderKey: import_renderer.FlowRendererKey.BRANCH_ADDER,
+      offset: import_utils.Point.move(currentTransform.inputPoint, isVertical ? { y: 10 } : { x: 10 }),
+      props: {
+        // 激活状态
+        activated: transition.entity.getData(import_document5.FlowNodeRenderData).activated,
+        transform: currentTransform,
+        // 传给外部使用的 node 信息
+        node: currentTransform.originParent?.entity
+      }
+    }
+  ];
+}
+
+// src/activities/block-icon.ts
+var import_utils2 = require("@flowgram.ai/utils");
+var import_document6 = require("@flowgram.ai/document");
+var import_document7 = require("@flowgram.ai/document");
+var BlockIconRegistry = {
+  type: import_document7.FlowNodeBaseType.BLOCK_ICON,
+  meta: {
+    spacing: 20,
+    // 占位节点下边偏小
+    // 条件分支 icon 默认的高度比较高，在流程里下边有文字
+    size: { width: 250, height: 84 }
+  },
+  /**
+   * 是一个占位节点，后续要加上 label 展开收起的图标
+   */
+  getLabels(transition) {
+    const currentTransform = transition.transform;
+    const { isVertical } = transition.entity;
+    if (transition.entity.parent.collapsedChildren.length <= 1) {
+      return [];
+    }
+    const collapsedSpacing = (0, import_document6.getDefaultSpacing)(
+      transition.entity,
+      import_document6.DefaultSpacingKey.COLLAPSED_SPACING
+    );
+    return [
+      {
+        type: import_document7.FlowTransitionLabelEnum.COLLAPSE_LABEL,
+        offset: import_utils2.Point.move(
+          currentTransform.outputPoint,
+          isVertical ? { y: collapsedSpacing } : { x: collapsedSpacing }
+        ),
+        props: {
+          collapseNode: transition.entity.parent,
+          activateNode: transition.entity
+        }
+      }
+    ];
+  }
+};
+
+// src/activities/block-order-icon.ts
+var import_utils3 = require("@flowgram.ai/utils");
+var import_document8 = require("@flowgram.ai/document");
+var import_document9 = require("@flowgram.ai/document");
+var BlockOrderIconRegistry = {
+  type: import_document9.FlowNodeBaseType.BLOCK_ORDER_ICON,
+  meta: {
+    spacing: 40
+  },
+  getLabels(transition) {
+    const currentTransform = transition.transform;
+    const { isVertical } = transition.entity;
+    const currentOutput = currentTransform.outputPoint;
+    const nextTransform = currentTransform.next;
+    const parentTransform = currentTransform.parent;
+    if (transition.entity.parent.collapsedChildren.length <= 1) {
+      const parentOutput = parentTransform?.outputPoint;
+      return [
+        {
+          offset: parentOutput,
+          type: import_document9.FlowTransitionLabelEnum.ADDER_LABEL
+        }
+      ];
+    }
+    const collapsedSpacing = (0, import_document8.getDefaultSpacing)(
+      transition.entity,
+      import_document8.DefaultSpacingKey.COLLAPSED_SPACING
+    );
+    return [
+      {
+        offset: nextTransform ? import_utils3.Point.getMiddlePoint(currentOutput, nextTransform.inputPoint) : import_utils3.Point.move(
+          currentOutput,
+          isVertical ? { y: collapsedSpacing } : { x: collapsedSpacing }
+        ),
+        // 收起展开复合按钮
+        type: import_document9.FlowTransitionLabelEnum.COLLAPSE_ADDER_LABEL,
+        props: {
+          activateNode: transition.entity,
+          collapseNode: transition.entity.parent
+        }
+      }
+    ];
+  }
+};
+
+// src/activities/start.ts
+var import_document10 = require("@flowgram.ai/document");
+var StartRegistry = {
+  type: import_document10.FlowNodeBaseType.START,
+  meta: {
+    isStart: true,
+    draggable: false,
+    selectable: false,
+    // 触发器等开始节点不能被框选
+    deleteDisable: true,
+    // 禁止删除
+    copyDisable: true,
+    // 禁止copy
+    addDisable: true
+    // 禁止添加
+  }
+};
+
+// src/activities/try-catch.ts
+var import_document16 = require("@flowgram.ai/document");
+
+// src/activities/try-catch-extends/catch-block.ts
+var import_document11 = require("@flowgram.ai/document");
+var CatchBlockRegistry = {
+  extend: import_document11.FlowNodeBaseType.BLOCK,
+  type: "catchBlock" /* CATCH_BLOCK */,
+  meta: {
+    hidden: true,
+    spacing: import_document11.DEFAULT_SPACING.NULL
+  },
+  getLines(transition) {
+    const { transform } = transition;
+    const { isVertical } = transition.entity;
+    const parentPoint = transform.parent;
+    const { inputPoint, outputPoint } = transform;
+    let parentInputPoint;
+    if (isVertical) {
+      parentInputPoint = {
+        x: parentPoint.inputPoint.x,
+        y: parentPoint.inputPoint.y - 20 /* CATCH_INLINE_SPACING */
+      };
+    } else {
+      parentInputPoint = {
+        x: parentPoint.inputPoint.x - 20 /* CATCH_INLINE_SPACING */,
+        y: parentPoint.inputPoint.y
+      };
+    }
+    const lines = [
+      {
+        type: import_document11.FlowTransitionLineEnum.DIVERGE_LINE,
+        from: parentInputPoint,
+        to: inputPoint
+      }
+    ];
+    if (!transition.isNodeEnd) {
+      let mergePoint;
+      if (isVertical) {
+        mergePoint = {
+          x: parentPoint.outputPoint.x,
+          y: parentPoint.bounds.bottom
+        };
+      } else {
+        mergePoint = {
+          x: parentPoint.bounds.right,
+          y: parentPoint.outputPoint.y
+        };
+      }
+      lines.push({
+        type: import_document11.FlowTransitionLineEnum.MERGE_LINE,
+        from: outputPoint,
+        to: mergePoint
+      });
+    }
+    return lines;
+  },
+  getLabels() {
+    return [];
+  }
+};
+
+// src/activities/try-catch-extends/catch-inline-blocks.ts
+var import_renderer2 = require("@flowgram.ai/renderer");
+var import_document12 = require("@flowgram.ai/document");
+var CatchInlineBlocksRegistry = {
+  extend: import_document12.FlowNodeBaseType.INLINE_BLOCKS,
+  type: "catchInlineBlocks" /* CATCH_INLINE_BLOCKS */,
+  meta: {
+    spacing: import_document12.DEFAULT_SPACING.NULL,
+    inlineSpacingPre: import_document12.DEFAULT_SPACING.NULL
+    // inlineSpacingAfter: DEFAULT_SPACING.NULL,
+  },
+  getDelta() {
+    return void 0;
+  },
+  getLines(transition) {
+    const { transform } = transition;
+    const mainInlineBlocks = transform.parent;
+    const lines = [
+      {
+        type: import_document12.FlowTransitionLineEnum.DIVERGE_LINE,
+        from: mainInlineBlocks.pre.outputPoint,
+        to: transform.inputPoint
+      }
+    ];
+    if (!transform.entity.isNodeEnd) {
+      lines.push({
+        type: import_document12.FlowTransitionLineEnum.MERGE_LINE,
+        from: transform.outputPoint,
+        to: mainInlineBlocks.outputPoint
+      });
+    }
+    return lines;
+  },
+  getOriginDeltaX(transform) {
+    const { firstChild } = transform;
+    if (!firstChild) return 0;
+    return firstChild.originDeltaX;
+  },
+  getLabels(transition) {
+    const { inputPoint } = transition.transform;
+    const { isVertical } = transition.entity;
+    const currentTransform = transition.transform;
+    const actualInputPoint = {
+      x: isVertical ? inputPoint.x : inputPoint.x - 20 /* CATCH_INLINE_SPACING */,
+      y: isVertical ? inputPoint.y - 20 /* CATCH_INLINE_SPACING */ : inputPoint.y
+    };
+    if (currentTransform.collapsed) {
+      return [];
+    }
+    return [
+      {
+        type: import_document12.FlowTransitionLabelEnum.CUSTOM_LABEL,
+        renderKey: import_renderer2.FlowRendererKey.BRANCH_ADDER,
+        offset: actualInputPoint,
+        props: {
+          // 激活状态
+          activated: transition.entity.getData(import_document12.FlowNodeRenderData).activated,
+          transform: currentTransform,
+          // 传给外部使用的 node 信息
+          node: currentTransform.originParent?.entity
+        }
+      }
+    ];
+  },
+  getInputPoint(transform, layout) {
+    const isVertical = import_document12.FlowLayoutDefault.isVertical(layout);
+    const firstCatchBlock = transform.firstChild;
+    if (firstCatchBlock) {
+      return firstCatchBlock.inputPoint;
+    }
+    return isVertical ? transform.bounds.topCenter : transform.bounds.rightCenter;
+  },
+  getOutputPoint(transform, layout) {
+    const isVertical = import_document12.FlowLayoutDefault.isVertical(layout);
+    if (transform.collapsed) {
+      return transform.inputPoint;
+    }
+    const firstCatchBlock = transform.firstChild;
+    if (firstCatchBlock) {
+      return isVertical ? {
+        x: firstCatchBlock.outputPoint?.x,
+        y: transform.bounds.bottom
+      } : {
+        x: transform.bounds.right,
+        y: firstCatchBlock.outputPoint?.y
+      };
+    }
+    return isVertical ? transform.bounds.bottomCenter : transform.bounds.rightCenter;
+  }
+};
+
+// src/activities/try-catch-extends/main-inline-blocks.ts
+var import_renderer3 = require("@flowgram.ai/renderer");
+var import_document13 = require("@flowgram.ai/document");
+var MainInlineBlocksRegistry = {
+  extend: import_document13.FlowNodeBaseType.INLINE_BLOCKS,
+  type: "mainInlineBlocks" /* MAIN_INLINE_BLOCKS */,
+  meta: {
+    inlineSpacingPre: 20 /* MAIN_INLINE_SPACING_TOP */,
+    inlineSpacingAfter: 40 /* MAIN_INLINE_SPACING_BOTTOM */
+  },
+  getLines(transition) {
+    const { transform } = transition;
+    const tryBranch = transform.firstChild;
+    const lines = [
+      {
+        type: import_document13.FlowTransitionLineEnum.STRAIGHT_LINE,
+        from: tryBranch.outputPoint,
+        to: transform.originParent.outputPoint
+      }
+    ];
+    return lines;
+  },
+  getLabels(transition) {
+    const { transform } = transition;
+    const { isVertical } = transition.entity;
+    const catchInlineBlocks = transform.children[1];
+    const errLabelX = isVertical ? (transform.parent.outputPoint.x + catchInlineBlocks.inputPoint.x) / 2 : transform.inputPoint.x - 54 /* INLINE_SPACING_TOP */;
+    const errLabelY = isVertical ? transform.inputPoint.y - 54 /* INLINE_SPACING_TOP */ : (transform.parent.outputPoint.y + catchInlineBlocks.inputPoint.y) / 2;
+    const errorLabelX = errLabelX;
+    const errorLabelY = errLabelY;
+    return [
+      {
+        type: import_document13.FlowTransitionLabelEnum.TEXT_LABEL,
+        renderKey: import_renderer3.FlowTextKey.TRY_START_TEXT,
+        offset: {
+          x: isVertical ? transform.inputPoint.x : transform.inputPoint.x + -20 /* TRY_START_LABEL_DELTA */,
+          y: isVertical ? transform.inputPoint.y + -20 /* TRY_START_LABEL_DELTA */ : transform.inputPoint.y
+        }
+      },
+      {
+        type: import_document13.FlowTransitionLabelEnum.TEXT_LABEL,
+        renderKey: import_renderer3.FlowTextKey.TRY_END_TEXT,
+        offset: {
+          x: isVertical ? transform.inputPoint.x : transform.originParent.outputPoint.x + -20 /* TRY_END_LABEL_DELTA */,
+          y: isVertical ? transform.originParent.outputPoint.y + -20 /* TRY_END_LABEL_DELTA */ : transform.inputPoint.y
+        }
+      },
+      // 错误分支收起
+      {
+        type: import_document13.FlowTransitionLabelEnum.CUSTOM_LABEL,
+        renderKey: import_renderer3.FlowRendererKey.TRY_CATCH_COLLAPSE,
+        offset: {
+          x: errorLabelX,
+          y: errorLabelY
+        },
+        props: {
+          node: transform.lastChild?.entity
+        }
+      }
+    ];
+  },
+  getInputPoint(transform) {
+    const tryBlock = transform.firstChild;
+    return tryBlock.inputPoint;
+  },
+  getOutputPoint(transform, layout) {
+    const tryBlock = transform.firstChild;
+    const isVertical = import_document13.FlowLayoutDefault.isVertical(layout);
+    if (isVertical) {
+      return {
+        x: tryBlock.outputPoint.x,
+        y: transform.bounds.bottom + 20 /* CATCH_INLINE_SPACING */
+      };
+    }
+    return {
+      x: transform.bounds.right + 20 /* CATCH_INLINE_SPACING */,
+      y: tryBlock.outputPoint.y
+    };
+  },
+  getDelta() {
+    return void 0;
+  },
+  getChildDelta(child, layout) {
+    const preTransform = child.entity.pre?.getData(import_document13.FlowNodeTransformData);
+    const isVertical = import_document13.FlowLayoutDefault.isVertical(layout);
+    if (preTransform) {
+      const { localBounds: preBounds } = preTransform;
+      let delta = 0;
+      if (isVertical) {
+        delta = Math.max(
+          child.parent.minInlineBlockSpacing,
+          -child.originDeltaX + import_document13.DEFAULT_SPACING.MARGIN_RIGHT
+        );
+      } else {
+        delta = Math.max(
+          child.parent.minInlineBlockSpacing,
+          -child.originDeltaY + import_document13.DEFAULT_SPACING.MARGIN_RIGHT
+        );
+      }
+      return {
+        // 分支只有两个所以这里可以写死间隔宽度
+        x: isVertical ? preBounds.right + delta : 0,
+        y: isVertical ? 0 : preBounds.bottom + delta
+      };
+    }
+    return {
+      x: 0,
+      y: 0
+    };
+  }
+};
+
+// src/activities/try-catch-extends/try-block.ts
+var import_document14 = require("@flowgram.ai/document");
+var TryBlockRegistry = {
+  extend: import_document14.FlowNodeBaseType.BLOCK,
+  type: "tryBlock" /* TRY_BLOCK */,
+  meta: {
+    hidden: true,
+    spacing: import_document14.DEFAULT_SPACING.NULL
+  },
+  getLines() {
+    return [];
+  },
+  getLabels() {
+    return [];
+  }
+};
+
+// src/activities/try-catch-extends/try-slot.ts
+var import_document15 = require("@flowgram.ai/document");
+var TrySlotRegistry = {
+  extend: import_document15.FlowNodeBaseType.EMPTY,
+  type: "trySlot" /* TRY_SLOT */
+  // getLabels() {
+  //   return []
+  // },
+};
+
+// src/activities/try-catch.ts
+var TryCatchRegistry = {
+  type: "tryCatch",
+  meta: {
+    hidden: true,
+    inlineSpacingAfter: 0 /* INLINE_SPACING_BOTTOM */
+  },
+  /**
+   * 结构
+   * tryCatch
+   *    - tryCatchIcon
+   *    - mainInlineBlocks
+   *        - tryBlock // try 分支
+   *          - trySlot // 空节点用来占位，try 分支一开始没有节点
+   *        - catchInlineBlocks
+   *            - catchBlock // catch 分支 1
+   *              - blockOrderIcon
+   *              - node1
+   *            - catchBlock // catch 分支 2
+   *              - blockOrderIcon
+   *              - node 2
+   * @param node
+   * @param json
+   */
+  onCreate(node, json) {
+    const { document } = node;
+    const [tryBlock, ...catchBlocks] = json.blocks || [];
+    const addedNodes = [];
+    const tryCatchIconNode = document.addNode({
+      id: `$tryCatchIcon$${node.id}`,
+      type: import_document16.FlowNodeBaseType.BLOCK_ICON,
+      originParent: node,
+      parent: node
+    });
+    const mainBlockNode = document.addNode({
+      id: `$mainInlineBlocks$${node.id}`,
+      type: "mainInlineBlocks" /* MAIN_INLINE_BLOCKS */,
+      originParent: node,
+      parent: node
+    });
+    const tryBlockNode = document.addNode({
+      id: `$tryBlock$${tryBlock.id}`,
+      type: "tryBlock" /* TRY_BLOCK */,
+      originParent: node,
+      parent: mainBlockNode
+    });
+    const trySlotNode = document.addNode({
+      id: tryBlock.id,
+      type: "trySlot" /* TRY_SLOT */,
+      // 占位节点
+      originParent: node,
+      parent: tryBlockNode
+    });
+    const catchInlineBlocksNode = document.addNode({
+      id: `$catchInlineBlocks$${node.id}`,
+      type: "catchInlineBlocks" /* CATCH_INLINE_BLOCKS */,
+      originParent: node,
+      parent: mainBlockNode
+    });
+    addedNodes.push(
+      tryCatchIconNode,
+      mainBlockNode,
+      tryBlockNode,
+      trySlotNode,
+      catchInlineBlocksNode
+    );
+    catchBlocks.forEach((blockData) => {
+      node.document.addBlock(node, blockData, addedNodes);
+    });
+    return addedNodes;
+  },
+  /**
+   * 添加 catch 分支
+   * @param node
+   * @param blockData
+   * @param addedNodes
+   */
+  onBlockChildCreate(node, blockData, addedNodes) {
+    const parent = node.document.getNode(`$catchInlineBlocks$${node.id}`);
+    const block = node.document.addNode({
+      id: blockData.id,
+      type: "catchBlock" /* CATCH_BLOCK */,
+      originParent: node,
+      parent
+    });
+    const blockOrderIcon = node.document.addNode({
+      id: `$blockOrderIcon$${blockData.id}`,
+      type: import_document16.FlowNodeBaseType.BLOCK_ORDER_ICON,
+      originParent: node,
+      parent: block
+    });
+    if (blockData.blocks) {
+      node.document.addBlocksAsChildren(block, blockData.blocks || [], addedNodes);
+    }
+    addedNodes?.push(block, blockOrderIcon);
+    return block;
+  },
+  getInputPoint(transform) {
+    const tryCatchIcon = transform.firstChild;
+    return tryCatchIcon.inputPoint;
+  },
+  getOutputPoint(transform, layout) {
+    const isVertical = import_document16.FlowLayoutDefault.isVertical(layout);
+    const tryCatchIcon = transform.firstChild;
+    if (isVertical) {
+      return {
+        x: tryCatchIcon.inputPoint.x,
+        y: transform.bounds.bottom
+      };
+    }
+    return {
+      x: transform.bounds.right,
+      y: tryCatchIcon.inputPoint.y
+    };
+  },
+  /**
+   * tryCatch 子节点配置
+   */
+  extendChildRegistries: [
+    /**
+     * icon 节点
+     */
+    {
+      type: import_document16.FlowNodeBaseType.BLOCK_ICON,
+      meta: {
+        spacing: 54 /* INLINE_SPACING_TOP */
+      },
+      getLabels() {
+        return [];
+      }
+    },
+    MainInlineBlocksRegistry,
+    CatchInlineBlocksRegistry,
+    TryBlockRegistry,
+    CatchBlockRegistry,
+    TrySlotRegistry
+  ]
+};
+
+// src/activities/loop.ts
+var import_utils5 = require("@flowgram.ai/utils");
+var import_renderer5 = require("@flowgram.ai/renderer");
+var import_document20 = require("@flowgram.ai/document");
+
+// src/activities/loop-extends/constants.ts
+var import_document17 = require("@flowgram.ai/document");
+var LoopSpacings = {
+  SPACING: 16,
+  // 距离下面节点距离
+  COLLAPSE_INLINE_SPACING_BOTTOM: 60,
+  // 距离下面节点距离
+  [import_document17.ConstantKeys.INLINE_SPACING_BOTTOM]: 48,
+  // 下边空白
+  MIN_INLINE_BLOCK_SPACING: 280,
+  // 最小循环圈宽度
+  HORIZONTAL_MIN_INLINE_BLOCK_SPACING: 180,
+  // 水平布局下的最小循环圈高度
+  LEFT_EMPTY_BLOCK_WIDTH: 80,
+  // 左边空分支宽度
+  EMPTY_BRANCH_SPACING: 20,
+  // 左边空分支宽度
+  LOOP_BLOCK_ICON_SPACING: 13,
+  // inlineBlocks 的 inlineBottom
+  [import_document17.ConstantKeys.INLINE_BLOCKS_INLINE_SPACING_BOTTOM]: 23,
+  // inlineBlocks 的 inlineBottom
+  INLINE_BLOCKS_INLINE_SPACING_TOP: 30
+  // inlineBlocks 的 inlineTop
+};
+
+// src/activities/loop-extends/loop-left-empty-block.ts
+var LoopLeftEmptyBlockRegistry = {
+  type: "loopLeftEmptyBlock" /* LOOP_LEFT_EMPTY_BLOCK */,
+  meta: {
+    inlineSpacingAfter: 0,
+    spacing: 0,
+    size: {
+      width: LoopSpacings.LEFT_EMPTY_BLOCK_WIDTH,
+      height: 0
+    }
+  },
+  onAfterUpdateLocalTransform(transform) {
+    if (transform.entity.isVertical) {
+      transform.data.size = {
+        width: LoopSpacings.LEFT_EMPTY_BLOCK_WIDTH,
+        height: 0
+      };
+    } else {
+      transform.data.size = {
+        width: 0,
+        height: LoopSpacings.LEFT_EMPTY_BLOCK_WIDTH
+      };
+    }
+    transform.transform.update({
+      size: transform.data.size
+    });
+  },
+  getLines() {
+    return [];
+  },
+  getLabels() {
+    return [];
+  }
+};
+
+// src/activities/loop-extends/loop-right-empty-block.ts
+var LoopRightEmptyBlockRegistry = {
+  ...BlockRegistry,
+  type: "loopRightEmptyBlock" /* LOOP_RIGHT_EMPTY_BLOCK */,
+  meta: {
+    ...BlockRegistry.meta,
+    inlineSpacingAfter: 0
+  }
+};
+
+// src/activities/loop-extends/loop-empty-branch.ts
+var import_document18 = require("@flowgram.ai/document");
+var LoopEmptyBranchRegistry = {
+  type: "loopEmptyBranch" /* LOOP_EMPTY_BRANCH */,
+  meta: {
+    inlineSpacingAfter: 0,
+    spacing: LoopSpacings.EMPTY_BRANCH_SPACING,
+    size: {
+      width: 100,
+      height: 0
+    }
+  },
+  getLabels(transition) {
+    const { isVertical } = transition.entity;
+    const currentTransform = transition.transform;
+    if (isVertical) {
+      return [
+        {
+          type: import_document18.FlowTransitionLabelEnum.ADDER_LABEL,
+          offset: {
+            x: currentTransform.inputPoint.x,
+            y: currentTransform.bounds.center.y + 8
+            // 右边空节点
+          }
+        }
+      ];
+    }
+    return [
+      {
+        type: import_document18.FlowTransitionLabelEnum.ADDER_LABEL,
+        offset: {
+          x: currentTransform.bounds.center.x + 8,
+          y: currentTransform.inputPoint.y
+        }
+      }
+    ];
+  },
+  onAfterUpdateLocalTransform(transform) {
+    if (transform.entity.isVertical) {
+      transform.data.size = {
+        width: 100,
+        height: 0
+      };
+    } else {
+      transform.data.size = {
+        width: 0,
+        height: 100
+      };
+    }
+    transform.transform.update({
+      size: transform.data.size
+    });
+  }
+};
+
+// src/activities/loop-extends/loop-inline-blocks.ts
+var import_utils4 = require("@flowgram.ai/utils");
+var import_renderer4 = require("@flowgram.ai/renderer");
+var import_document19 = require("@flowgram.ai/document");
+var LoopInlineBlocksNodeRegistry = {
+  type: import_document19.FlowNodeBaseType.INLINE_BLOCKS,
+  meta: {
+    inlineSpacingPre: (node) => {
+      const inlineBlocksInlineSpacingTop = (0, import_document19.getDefaultSpacing)(
+        node.entity,
+        import_document19.ConstantKeys.INLINE_BLOCKS_INLINE_SPACING_TOP,
+        LoopSpacings.INLINE_BLOCKS_INLINE_SPACING_TOP
+      );
+      return inlineBlocksInlineSpacingTop;
+    },
+    inlineSpacingAfter: (node) => {
+      const inlineBlocksInlineSpacingBottom = (0, import_document19.getDefaultSpacing)(
+        node.entity,
+        import_document19.ConstantKeys.INLINE_BLOCKS_INLINE_SPACING_BOTTOM,
+        LoopSpacings.INLINE_BLOCKS_INLINE_SPACING_BOTTOM
+      );
+      return inlineBlocksInlineSpacingBottom;
+    },
+    minInlineBlockSpacing: (node) => node.entity.isVertical ? LoopSpacings.MIN_INLINE_BLOCK_SPACING : LoopSpacings.HORIZONTAL_MIN_INLINE_BLOCK_SPACING
+  },
+  getLines(transition) {
+    const currentTransform = transition.transform;
+    const parentTransform = currentTransform.parent;
+    const { isVertical } = transition.entity;
+    const lines = [
+      // 循环结束线
+      {
+        type: import_document19.FlowTransitionLineEnum.STRAIGHT_LINE,
+        from: currentTransform.outputPoint,
+        to: parentTransform.outputPoint
+      }
+    ];
+    if (currentTransform.collapsed) {
+      return lines;
+    }
+    const [leftBlockTransform] = currentTransform.children;
+    return [
+      ...lines,
+      // 循环回撤线 - 1 分成两段可以被 viewport 识别出矩阵区域
+      {
+        type: import_document19.FlowTransitionLineEnum.ROUNDED_LINE,
+        from: currentTransform.outputPoint,
+        to: leftBlockTransform.outputPoint,
+        vertices: [
+          isVertical ? { x: leftBlockTransform.inputPoint.x, y: currentTransform.bounds.bottom } : { x: currentTransform.bounds.right, y: leftBlockTransform.inputPoint.y }
+        ]
+      },
+      // 循环回撤线 - 2
+      {
+        type: import_document19.FlowTransitionLineEnum.ROUNDED_LINE,
+        from: leftBlockTransform.outputPoint,
+        to: import_utils4.Point.move(
+          currentTransform.inputPoint,
+          isVertical ? { x: -12, y: 10 } : { x: 10, y: -12 }
+        ),
+        vertices: [
+          isVertical ? { x: leftBlockTransform.inputPoint.x, y: currentTransform.bounds.top + 10 } : { x: currentTransform.bounds.left + 10, y: leftBlockTransform.inputPoint.y }
+        ],
+        arrow: true
+      }
+    ];
+  },
+  getLabels(transition) {
+    const currentTransform = transition.transform;
+    const { isVertical } = transition.entity;
+    const labels = [];
+    if (currentTransform.collapsed) {
+      return labels;
+    }
+    const leftBlockTransform = currentTransform.children[0];
+    const rightBlockTransform = currentTransform.children[1];
+    if (transition.entity.originParent?.id.startsWith("while_")) {
+      labels.push({
+        type: import_document19.FlowTransitionLabelEnum.TEXT_LABEL,
+        renderKey: import_renderer4.FlowTextKey.LOOP_WHILE_TEXT,
+        rotate: isVertical ? "" : "-90deg",
+        offset: isVertical ? {
+          x: (currentTransform.inputPoint.x + rightBlockTransform.inputPoint.x) / 2,
+          y: currentTransform.inputPoint.y + 10
+        } : {
+          x: currentTransform.inputPoint.x + 10,
+          y: (currentTransform.inputPoint.y + rightBlockTransform.inputPoint.y) / 2
+        }
+      });
+    } else {
+      labels.push({
+        type: import_document19.FlowTransitionLabelEnum.TEXT_LABEL,
+        renderKey: import_renderer4.FlowTextKey.LOOP_TRAVERSE_TEXT,
+        // rotate: isVertical ? '' : '-90deg',
+        offset: isVertical ? { x: leftBlockTransform.inputPoint.x, y: currentTransform.bounds.center.y + 5 } : { x: currentTransform.bounds.center.x + 5, y: leftBlockTransform.inputPoint.y }
+      });
+    }
+    return labels;
+  }
+};
+
+// src/activities/loop.ts
+var LoopRegistry = {
+  type: "loop",
+  meta: {
+    hidden: true,
+    inlineSpacingAfter: (node) => {
+      if (node.collapsed) {
+        return LoopSpacings.COLLAPSE_INLINE_SPACING_BOTTOM;
+      }
+      const inlineSpacingBottom = (0, import_document20.getDefaultSpacing)(
+        node.entity,
+        import_document20.ConstantKeys.INLINE_SPACING_BOTTOM,
+        LoopSpacings.INLINE_SPACING_BOTTOM
+      );
+      return inlineSpacingBottom;
+    },
+    spacing: LoopSpacings.SPACING
+  },
+  /**
+   * - loopNode
+   *  - loopBlockIcon
+   *  - loopInlineBlocks
+   *    - loopEmptyBlock 左侧占位区域
+   *    - loopBlock
+   *      - xxx
+   *      - xxx
+   * @param node
+   * @param json
+   */
+  onCreate(node, json) {
+    const { document } = node;
+    const loopBlocks = json.blocks || [];
+    const loopIconNode = document.addNode({
+      id: `$blockIcon$${node.id}`,
+      type: import_document20.FlowNodeBaseType.BLOCK_ICON,
+      originParent: node,
+      parent: node
+    });
+    const loopInlineBlocks = document.addNode({
+      id: `$inlineBlocks$${node.id}`,
+      hidden: true,
+      type: import_document20.FlowNodeBaseType.INLINE_BLOCKS,
+      originParent: node,
+      parent: node
+    });
+    const loopEmptyBlockNode = document.addNode({
+      id: `$loopLeftEmpty$${node.id}`,
+      hidden: true,
+      type: "loopLeftEmptyBlock" /* LOOP_LEFT_EMPTY_BLOCK */,
+      originParent: node,
+      parent: loopInlineBlocks
+    });
+    const loopBlockNode = document.addNode({
+      id: `$block$${node.id}`,
+      hidden: true,
+      type: import_document20.FlowNodeBaseType.BLOCK,
+      // : LoopTypeEnum.LOOP_RIGHT_EMPTY_BLOCK,
+      originParent: node,
+      parent: loopInlineBlocks
+    });
+    const loopBranch = document.addNode({
+      id: `$loopRightEmpty$${node.id}`,
+      hidden: true,
+      type: "loopEmptyBranch" /* LOOP_EMPTY_BRANCH */,
+      originParent: node,
+      parent: loopBlockNode
+    });
+    const otherNodes = [];
+    loopBlocks.forEach(
+      (b) => document.addNode(
+        {
+          ...b,
+          type: b.type,
+          parent: loopBlockNode
+        },
+        otherNodes
+      )
+    );
+    return [
+      loopIconNode,
+      loopEmptyBlockNode,
+      loopInlineBlocks,
+      loopBlockNode,
+      loopBranch,
+      ...otherNodes
+    ];
+  },
+  getLabels(transition) {
+    const currentTransform = transition.transform;
+    const { isVertical } = transition.entity;
+    return [
+      // 循环结束
+      {
+        type: import_document20.FlowTransitionLabelEnum.TEXT_LABEL,
+        renderKey: import_renderer5.FlowTextKey.LOOP_END_TEXT,
+        // 循环 label 垂直样式展示，而非 rotate 旋转文案
+        props: isVertical ? void 0 : {
+          style: {
+            maxWidth: "20px",
+            lineHeight: "12px",
+            whiteSpace: "pre-wrap"
+          }
+        },
+        offset: import_utils5.Point.move(currentTransform.outputPoint, isVertical ? { y: -26 } : { x: -26 })
+      },
+      {
+        type: import_document20.FlowTransitionLabelEnum.ADDER_LABEL,
+        offset: currentTransform.outputPoint
+      }
+    ];
+  },
+  // 和前序节点对齐
+  getInputPoint(transform) {
+    const { isVertical } = transform.entity;
+    if (isVertical) {
+      return {
+        x: transform.pre?.outputPoint.x || transform.firstChild?.outputPoint.x || 0,
+        y: transform.bounds.top
+      };
+    }
+    return {
+      x: transform.bounds.left,
+      y: transform.pre?.outputPoint.y || transform.firstChild?.outputPoint.y || 0
+    };
+  },
+  getOutputPoint(transform) {
+    const { isVertical } = transform.entity;
+    if (isVertical) {
+      return {
+        x: transform.pre?.outputPoint.x || transform.firstChild?.outputPoint.x || 0,
+        y: transform.bounds.bottom
+      };
+    }
+    return {
+      x: transform.bounds.right,
+      y: transform.pre?.outputPoint.y || transform.firstChild?.outputPoint.y || 0
+    };
+  },
+  extendChildRegistries: [
+    {
+      type: import_document20.FlowNodeBaseType.BLOCK_ICON,
+      meta: {
+        spacing: LoopSpacings.LOOP_BLOCK_ICON_SPACING
+      }
+    },
+    LoopLeftEmptyBlockRegistry,
+    LoopEmptyBranchRegistry,
+    LoopRightEmptyBlockRegistry,
+    LoopInlineBlocksNodeRegistry
+  ],
+  addChild(node, json, options = {}) {
+    const { index } = options;
+    const document = node.document;
+    return document.addNode({
+      ...json,
+      ...options,
+      parent: document.getNode(`$block$${node.id}`),
+      index: typeof index === "number" ? index + 1 : void 0
+    });
+  }
+};
+
+// src/activities/root.ts
+var import_document21 = require("@flowgram.ai/document");
+var RootRegistry = {
+  type: import_document21.FlowNodeBaseType.ROOT,
+  meta: {
+    spacing: import_document21.DEFAULT_SPACING.NULL,
+    hidden: true
+  },
+  getInputPoint(transform) {
+    return transform.firstChild?.inputPoint || transform.bounds.topCenter;
+  },
+  getOutputPoint(transform) {
+    return transform.firstChild?.outputPoint || transform.bounds.bottomCenter;
+  }
+};
+
+// src/activities/empty.ts
+var import_document22 = require("@flowgram.ai/document");
+var EmptyRegistry = {
+  type: import_document22.FlowNodeBaseType.EMPTY,
+  meta: {
+    spacing: (node) => {
+      const spacing = (0, import_document22.getDefaultSpacing)(node.entity, import_document22.ConstantKeys.NODE_SPACING);
+      return spacing / 2;
+    },
+    size: { width: 0, height: 0 },
+    hidden: true
+  },
+  getLabels(transition) {
+    return [
+      {
+        offset: transition.transform.bounds,
+        type: import_document22.FlowTransitionLabelEnum.ADDER_LABEL
+      }
+    ];
+  }
+};
+
+// src/flow-registers.ts
+var FlowRegisters = class {
+  /**
+   * 注册数据层
+   * @param document
+   */
+  registerDocument(document) {
+    document.registerFlowNodes(
+      RootRegistry,
+      // 根节点
+      StartRegistry,
+      // 开始节点
+      DynamicSplitRegistry,
+      // 动态分支（并行、排他）
+      StaticSplitRegistry,
+      // 静态分支（审批）
+      BlockRegistry,
+      // 单条 block 注册
+      InlineBlocksRegistry,
+      // 多个 block 组成的 block 列表
+      BlockIconRegistry,
+      // icon 节点，如条件分支的菱形图标
+      BlockOrderIconRegistry,
+      // 带顺序的图标节点，一般为 block 第一个分支节点
+      TryCatchRegistry,
+      // TryCatch
+      EndRegistry,
+      // 结束节点
+      LoopRegistry,
+      // 循环节点
+      EmptyRegistry
+      // 占位节点
+    );
+    document.registerNodeDatas(
+      import_document23.FlowNodeRenderData,
+      // 渲染节点相关数据
+      import_document23.FlowNodeTransitionData,
+      // 线条绘制数据
+      import_document23.FlowNodeTransformData
+      // 坐标计算数据
+    );
+  }
+  /**
+   * 注册渲染层
+   * @param renderer
+   */
+  registerRenderer(renderer) {
+    renderer.registerLayers(
+      import_renderer6.FlowNodesTransformLayer,
+      // 节点位置渲染
+      import_renderer6.FlowNodesContentLayer,
+      // 节点内容渲染
+      import_renderer6.FlowLinesLayer,
+      // 线条渲染
+      import_renderer6.FlowLabelsLayer,
+      // Label 渲染
+      import_core.PlaygroundLayer,
+      // 画布基础层，提供缩放、手势等能力
+      import_renderer6.FlowScrollLimitLayer,
+      // 控制滚动范围
+      import_renderer6.FlowScrollBarLayer
+      // 滚动条
+    );
+  }
+  /**
+   * 画布开始渲染 (hook)
+   */
+  onReady() {
+  }
+  /**
+   * 画布销毁 (hook)
+   */
+  onDispose() {
+  }
+};
+FlowRegisters = __decorateClass([
+  (0, import_inversify.injectable)()
+], FlowRegisters);
+
+// src/fixed-layout-container-module.ts
+var FixedLayoutContainerModule = new import_inversify2.ContainerModule((bind) => {
+  (0, import_utils6.bindContributions)(bind, FlowRegisters, [
+    import_document24.FlowDocumentContribution,
+    import_renderer7.FlowRendererContribution,
+    import_core2.PlaygroundContribution
+  ]);
+});
+
+// src/index.ts
+var FixedLayoutRegistries = {
+  BlockIconRegistry,
+  BlockOrderIconRegistry,
+  BlockRegistry,
+  DynamicSplitRegistry,
+  EmptyRegistry,
+  LoopRegistry,
+  StaticSplitRegistry,
+  TryCatchRegistry,
+  StartRegistry,
+  RootRegistry
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FixedLayoutContainerModule,
+  FixedLayoutRegistries
+});
+//# sourceMappingURL=index.js.map