@flowgram-vue/fixed-layout-core 0.2.0

package/dist/index.js

@@ -0,0 +1,2323 @@
+import { injectable, ContainerModule } from 'inversify';
+import { FlowRendererKey, FlowRendererContribution, FlowTextKey, FlowNodesTransformLayer, FlowNodesContentLayer, FlowLinesLayer, FlowLabelsLayer } from '@flowgram-vue/renderer';
+import { FlowNodeBaseType, FlowNodeSplitType, DEFAULT_SPACING, ConstantKeys, getDefaultSpacing, FlowTransitionLabelEnum, FlowNodeRenderData, FlowDocumentContribution, FlowNodeTransformData, FlowLayoutDefault, FlowTransitionLineEnum, LABEL_SIDE_TYPE, FlowNodeTransitionData, DefaultSpacingKey } from '@flowgram-vue/document';
+import { PlaygroundContribution, PlaygroundLayer } from '@flowgram-vue/core';
+import { Point, bindContributions } from '@flowgram-vue/utils';
+import { mean } from 'lodash-es';
+
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+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 = (decorator(result)) || result;
+  return result;
+};
+var EndRegistry = {
+  type: FlowNodeBaseType.END,
+  meta: {
+    draggable: false,
+    isNodeEnd: true,
+    selectable: false,
+    copyDisable: true
+  },
+  // 结束节点没有出边和 label
+  getLines() {
+    return [];
+  },
+  getLabels() {
+    return [];
+  }
+};
+var DynamicSplitRegistry = {
+  type: FlowNodeSplitType.DYNAMIC_SPLIT,
+  meta: {
+    hidden: true,
+    inlineSpacingAfter: (node) => node.collapsed && node.entity.collapsedChildren.length > 1 ? 21 : 0,
+    // 判断是否有分支节点
+    spacing: (node) => {
+      const spacing = getDefaultSpacing(node.entity, ConstantKeys.NODE_SPACING);
+      return node.children.length === 1 ? spacing : spacing / 2;
+    }
+  },
+  getLabels(transition) {
+    if (transition.isNodeEnd) {
+      return [];
+    }
+    return [
+      {
+        type: 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 = FlowLayoutDefault.isVertical(layout);
+    const noInlineBlocks = transform.children.length === 1;
+    const lastChildOutput = transform.lastChild?.outputPoint;
+    const spacing = getDefaultSpacing(transform.entity, 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
+    };
+  },
+  /**
+   * @depreacted
+   */
+  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);
+  }
+};
+var StaticSplitRegistry = {
+  extend: FlowNodeSplitType.DYNAMIC_SPLIT,
+  type: FlowNodeSplitType.STATIC_SPLIT,
+  extendChildRegistries: [
+    {
+      type: FlowNodeBaseType.INLINE_BLOCKS,
+      getLabels() {
+        return [];
+      }
+    }
+  ]
+};
+var BlockRegistry = {
+  type: FlowNodeBaseType.BLOCK,
+  meta: {
+    spacing: DEFAULT_SPACING.NULL,
+    inlineSpacingAfter: DEFAULT_SPACING.INLINE_BLOCK_PADDING_BOTTOM,
+    hidden: true
+  },
+  getLines(transition) {
+    const currentTransform = transition.transform;
+    const { isVertical } = transition.entity;
+    const lines = [
+      {
+        type: FlowTransitionLineEnum.DIVERGE_LINE,
+        from: currentTransform.parent.inputPoint,
+        to: currentTransform.inputPoint,
+        side: LABEL_SIDE_TYPE.NORMAL_BRANCH
+      }
+    ];
+    const hasBranchDraggingAdder = currentTransform && currentTransform.entity.isInlineBlock && transition.renderData.draggable;
+    if (hasBranchDraggingAdder) {
+      if (isVertical) {
+        const currentOffsetRightX = currentTransform.firstChild ? currentTransform.firstChild.bounds.right : currentTransform.bounds.right;
+        const nextOffsetLeftX = (currentTransform.next?.firstChild ? currentTransform.next?.firstChild.bounds?.left : currentTransform.next?.bounds?.left) || 0;
+        const currentInputPointY = currentTransform.inputPoint.y;
+        if (currentTransform?.next) {
+          lines.push({
+            type: FlowTransitionLineEnum.DRAGGING_LINE,
+            from: currentTransform.parent.inputPoint,
+            to: {
+              x: (currentOffsetRightX + nextOffsetLeftX) / 2,
+              y: currentInputPointY
+            },
+            side: LABEL_SIDE_TYPE.NORMAL_BRANCH
+          });
+        }
+      } else {
+        const currentOffsetBottomX = currentTransform.firstChild ? currentTransform.firstChild.bounds.bottom : currentTransform.bounds.bottom;
+        const nextOffsetTopX = (currentTransform.next?.firstChild ? currentTransform.next?.firstChild.bounds?.top : currentTransform.next?.bounds?.top) || 0;
+        const currentInputPointX = currentTransform.inputPoint.x;
+        if (currentTransform?.next) {
+          lines.push({
+            type: FlowTransitionLineEnum.DRAGGING_LINE,
+            from: currentTransform.parent.inputPoint,
+            to: {
+              x: currentInputPointX,
+              y: (currentOffsetBottomX + nextOffsetTopX) / 2
+            },
+            side: LABEL_SIDE_TYPE.NORMAL_BRANCH
+          });
+        }
+      }
+    }
+    if (!transition.isNodeEnd) {
+      lines.push({
+        type: FlowTransitionLineEnum.MERGE_LINE,
+        from: currentTransform.outputPoint,
+        to: currentTransform.parent.outputPoint,
+        side: LABEL_SIDE_TYPE.NORMAL_BRANCH
+      });
+    }
+    return lines;
+  },
+  getInputPoint(trans) {
+    const child = trans.firstChild;
+    return child ? child.inputPoint : trans.defaultInputPoint;
+  },
+  getOutputPoint(trans, layout) {
+    const isVertical = 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 ? currentTransform.firstChild.bounds.right : currentTransform.bounds.right;
+        const nextOffsetLeftX = (currentTransform.next?.firstChild ? currentTransform.next.firstChild.bounds?.left : currentTransform.next?.bounds?.left) || 0;
+        const currentInputPointY = currentTransform.inputPoint.y;
+        if (currentTransform?.next) {
+          draggingLabel.push({
+            offset: {
+              x: (currentOffsetRightX + nextOffsetLeftX) / 2,
+              y: currentInputPointY
+            },
+            type: FlowTransitionLabelEnum.BRANCH_DRAGGING_LABEL,
+            width: nextOffsetLeftX - currentOffsetRightX,
+            props: {
+              side: LABEL_SIDE_TYPE.NORMAL_BRANCH
+            }
+          });
+        }
+      } else {
+        const currentOffsetBottomX = currentTransform.firstChild ? currentTransform.firstChild.bounds.bottom : currentTransform.bounds.bottom;
+        const nextOffsetTopX = (currentTransform.next?.firstChild ? currentTransform.next.firstChild.bounds?.top : currentTransform.next?.bounds?.top) || 0;
+        const currentInputPointX = currentTransform.inputPoint.x;
+        if (currentTransform?.next) {
+          draggingLabel.push({
+            offset: {
+              x: currentInputPointX,
+              y: (currentOffsetBottomX + nextOffsetTopX) / 2
+            },
+            type: FlowTransitionLabelEnum.BRANCH_DRAGGING_LABEL,
+            width: nextOffsetTopX - currentOffsetBottomX,
+            props: {
+              side: LABEL_SIDE_TYPE.NORMAL_BRANCH
+            }
+          });
+        }
+      }
+    }
+    return [...draggingLabel];
+  },
+  /**
+   * @depreacted
+   */
+  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
+    });
+  }
+};
+var InlineBlocksRegistry = {
+  type: FlowNodeBaseType.INLINE_BLOCKS,
+  meta: {
+    hidden: true,
+    spacing: (node) => getDefaultSpacing(node.entity, ConstantKeys.NODE_SPACING),
+    isInlineBlocks: true,
+    inlineSpacingPre: (transform) => {
+      if (transform.entity.blocks.length === 0) {
+        return 0;
+      }
+      return getDefaultSpacing(transform.entity, ConstantKeys.INLINE_BLOCKS_PADDING_TOP) || DEFAULT_SPACING.INLINE_BLOCKS_PADDING_TOP;
+    },
+    inlineSpacingAfter: (transform) => {
+      if (transform.entity.blocks.length === 0) {
+        return 0;
+      }
+      return getDefaultSpacing(transform.entity, ConstantKeys.INLINE_BLOCKS_PADDING_BOTTOM);
+    }
+  },
+  /**
+   * 控制子分支的间距
+   * @param child
+   */
+  getChildDelta(child, layout) {
+    const isVertical = FlowLayoutDefault.isVertical(layout);
+    const preTransform = child.entity.pre?.getData(FlowNodeTransformData);
+    if (preTransform) {
+      const { localBounds: preBounds } = preTransform;
+      if (isVertical) {
+        const leftSpacing = preTransform.size.width + preTransform.originDeltaX;
+        const delta = Math.max(
+          child.parent.minInlineBlockSpacing - leftSpacing,
+          getDefaultSpacing(child.entity, ConstantKeys.BRANCH_SPACING) - 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,
+          getDefaultSpacing(child.entity, ConstantKeys.BRANCH_SPACING) - child.originDeltaY
+        );
+        return {
+          x: 0,
+          // 这里需要加上原点的偏移量，并加上垂直间距
+          y: preBounds.bottom + delta
+        };
+      }
+    }
+    return {
+      x: 0,
+      y: 0
+    };
+  },
+  /**
+   * 控制条件分支居中布局
+   * @param trans
+   */
+  getDelta(trans, layout) {
+    const isVertical = 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 = 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 = 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: FlowTransitionLabelEnum.COLLAPSE_LABEL,
+        offset: Point.move(currentTransform.inputPoint, isVertical ? { y: 10 } : { x: 10 }),
+        props: {
+          activateNode: transition.entity.pre
+        }
+      }
+    ];
+  }
+  return [
+    {
+      type: FlowTransitionLabelEnum.CUSTOM_LABEL,
+      renderKey: FlowRendererKey.BRANCH_ADDER,
+      offset: Point.move(currentTransform.inputPoint, isVertical ? { y: 10 } : { x: 10 }),
+      props: {
+        // 激活状态
+        activated: transition.entity.getData(FlowNodeRenderData).activated,
+        transform: currentTransform,
+        // 传给外部使用的 node 信息
+        node: currentTransform.originParent?.entity
+      }
+    }
+  ];
+}
+var BlockIconRegistry = {
+  type: 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 = getDefaultSpacing(
+      transition.entity,
+      DefaultSpacingKey.COLLAPSED_SPACING
+    );
+    return [
+      {
+        type: FlowTransitionLabelEnum.COLLAPSE_LABEL,
+        offset: Point.move(
+          currentTransform.outputPoint,
+          isVertical ? { y: collapsedSpacing } : { x: collapsedSpacing }
+        ),
+        props: {
+          collapseNode: transition.entity.parent,
+          activateNode: transition.entity
+        }
+      }
+    ];
+  }
+};
+var BlockOrderIconRegistry = {
+  type: 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: FlowTransitionLabelEnum.ADDER_LABEL
+        }
+      ];
+    }
+    const collapsedSpacing = getDefaultSpacing(
+      transition.entity,
+      DefaultSpacingKey.COLLAPSED_SPACING
+    );
+    return [
+      {
+        offset: nextTransform ? Point.getMiddlePoint(currentOutput, nextTransform.inputPoint) : Point.move(
+          currentOutput,
+          isVertical ? { y: collapsedSpacing } : { x: collapsedSpacing }
+        ),
+        // 收起展开复合按钮
+        type: FlowTransitionLabelEnum.COLLAPSE_ADDER_LABEL,
+        props: {
+          activateNode: transition.entity,
+          collapseNode: transition.entity.parent
+        }
+      }
+    ];
+  }
+};
+var StartRegistry = {
+  type: FlowNodeBaseType.START,
+  meta: {
+    isStart: true,
+    draggable: false,
+    selectable: false,
+    // 触发器等开始节点不能被框选
+    deleteDisable: true,
+    // 禁止删除
+    copyDisable: true,
+    // 禁止copy
+    addDisable: true
+    // 禁止添加
+  }
+};
+var CatchBlockRegistry = {
+  extend: FlowNodeBaseType.BLOCK,
+  type: "catchBlock" /* CATCH_BLOCK */,
+  meta: {
+    hidden: true,
+    spacing: 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: 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: FlowTransitionLineEnum.MERGE_LINE,
+        from: outputPoint,
+        to: mergePoint
+      });
+    }
+    return lines;
+  },
+  getLabels() {
+    return [];
+  }
+};
+var CatchInlineBlocksRegistry = {
+  extend: FlowNodeBaseType.INLINE_BLOCKS,
+  type: "catchInlineBlocks" /* CATCH_INLINE_BLOCKS */,
+  meta: {
+    spacing: DEFAULT_SPACING.NULL,
+    inlineSpacingPre: DEFAULT_SPACING.NULL
+    // inlineSpacingAfter: DEFAULT_SPACING.NULL,
+  },
+  getDelta() {
+    return void 0;
+  },
+  getLines(transition) {
+    const { transform } = transition;
+    const mainInlineBlocks = transform.parent;
+    const lines = [
+      {
+        type: FlowTransitionLineEnum.DIVERGE_LINE,
+        from: mainInlineBlocks.pre.outputPoint,
+        to: transform.inputPoint
+      }
+    ];
+    if (!transform.entity.isNodeEnd) {
+      lines.push({
+        type: 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: FlowTransitionLabelEnum.CUSTOM_LABEL,
+        renderKey: FlowRendererKey.BRANCH_ADDER,
+        offset: actualInputPoint,
+        props: {
+          // 激活状态
+          activated: transition.entity.getData(FlowNodeRenderData).activated,
+          transform: currentTransform,
+          // 传给外部使用的 node 信息
+          node: currentTransform.originParent?.entity
+        }
+      }
+    ];
+  },
+  getInputPoint(transform, layout) {
+    const isVertical = 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 = 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;
+  }
+};
+var MainInlineBlocksRegistry = {
+  extend: 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: 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: FlowTransitionLabelEnum.TEXT_LABEL,
+        renderKey: 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: FlowTransitionLabelEnum.TEXT_LABEL,
+        renderKey: 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: FlowTransitionLabelEnum.CUSTOM_LABEL,
+        renderKey: 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 = 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(FlowNodeTransformData);
+    const isVertical = FlowLayoutDefault.isVertical(layout);
+    if (preTransform) {
+      const { localBounds: preBounds } = preTransform;
+      let delta = 0;
+      if (isVertical) {
+        delta = Math.max(
+          child.parent.minInlineBlockSpacing,
+          -child.originDeltaX + getDefaultSpacing(child.entity, ConstantKeys.BRANCH_SPACING)
+        );
+      } else {
+        delta = Math.max(
+          child.parent.minInlineBlockSpacing,
+          -child.originDeltaY + getDefaultSpacing(child.entity, ConstantKeys.BRANCH_SPACING)
+        );
+      }
+      return {
+        // 分支只有两个所以这里可以写死间隔宽度
+        x: isVertical ? preBounds.right + delta : 0,
+        y: isVertical ? 0 : preBounds.bottom + delta
+      };
+    }
+    return {
+      x: 0,
+      y: 0
+    };
+  }
+};
+var TryBlockRegistry = {
+  extend: FlowNodeBaseType.BLOCK,
+  type: "tryBlock" /* TRY_BLOCK */,
+  meta: {
+    hidden: true,
+    spacing: DEFAULT_SPACING.NULL
+  },
+  getLines() {
+    return [];
+  },
+  getLabels() {
+    return [];
+  }
+};
+var TrySlotRegistry = {
+  type: "trySlot" /* TRY_SLOT */,
+  meta: {
+    inlineSpacingAfter: 16,
+    spacing: 0,
+    size: {
+      width: 16,
+      height: 0
+    }
+  },
+  onAfterUpdateLocalTransform(transform) {
+    if (transform.entity.isVertical) {
+      transform.data.size = {
+        width: 16,
+        height: 0
+      };
+    } else {
+      transform.data.size = {
+        width: 0,
+        height: 16
+      };
+    }
+    transform.transform.update({
+      size: transform.data.size
+    });
+  },
+  getLabels(transition) {
+    return [
+      {
+        offset: transition.transform.bounds.center,
+        type: FlowTransitionLabelEnum.ADDER_LABEL
+      }
+    ];
+  }
+};
+
+// 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: 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.id,
+      type: tryBlock.type || "tryBlock" /* TRY_BLOCK */,
+      originParent: node,
+      parent: mainBlockNode,
+      data: tryBlock.data
+    });
+    const trySlotNode = document.addNode({
+      id: `$trySlot$${tryBlock.id}`,
+      hidden: true,
+      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
+    );
+    (tryBlock.blocks || []).forEach((blockData) => {
+      document.addNode(
+        {
+          ...blockData,
+          parent: tryBlockNode
+        },
+        addedNodes
+      );
+    });
+    catchBlocks.forEach((blockData) => {
+      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: blockData.type || "catchBlock" /* CATCH_BLOCK */,
+      originParent: node,
+      parent,
+      data: blockData.data
+    });
+    const blockOrderIcon = node.document.addNode({
+      id: `$blockOrderIcon$${blockData.id}`,
+      type: 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 = 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: FlowNodeBaseType.BLOCK_ICON,
+      meta: {
+        spacing: 54 /* INLINE_SPACING_TOP */
+      },
+      getLabels() {
+        return [];
+      }
+    },
+    MainInlineBlocksRegistry,
+    CatchInlineBlocksRegistry,
+    TryBlockRegistry,
+    CatchBlockRegistry,
+    TrySlotRegistry
+  ]
+};
+var LoopSpacings = {
+  SPACING: 16,
+  // 距离下面节点距离
+  COLLAPSE_INLINE_SPACING_BOTTOM: 60,
+  // 距离下面节点距离
+  [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
+  [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
+  }
+};
+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: FlowTransitionLabelEnum.ADDER_LABEL,
+          offset: {
+            x: currentTransform.inputPoint.x,
+            y: currentTransform.bounds.center.y + 8
+            // 右边空节点
+          }
+        }
+      ];
+    }
+    return [
+      {
+        type: 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
+    });
+  }
+};
+var LoopInlineBlocksNodeRegistry = {
+  type: FlowNodeBaseType.INLINE_BLOCKS,
+  meta: {
+    inlineSpacingPre: (node) => {
+      const inlineBlocksInlineSpacingTop = getDefaultSpacing(
+        node.entity,
+        ConstantKeys.INLINE_BLOCKS_INLINE_SPACING_TOP,
+        LoopSpacings.INLINE_BLOCKS_INLINE_SPACING_TOP
+      );
+      return inlineBlocksInlineSpacingTop;
+    },
+    inlineSpacingAfter: (node) => {
+      const inlineBlocksInlineSpacingBottom = getDefaultSpacing(
+        node.entity,
+        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: FlowTransitionLineEnum.STRAIGHT_LINE,
+        from: currentTransform.outputPoint,
+        to: parentTransform.outputPoint
+      }
+    ];
+    if (currentTransform.collapsed) {
+      return lines;
+    }
+    const [leftBlockTransform] = currentTransform.children;
+    return [
+      ...lines,
+      // 循环回撤线 - 1 分成两段可以被 viewport 识别出矩阵区域
+      {
+        type: 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: FlowTransitionLineEnum.ROUNDED_LINE,
+        from: leftBlockTransform.outputPoint,
+        to: 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: FlowTransitionLabelEnum.TEXT_LABEL,
+        renderKey: 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: FlowTransitionLabelEnum.TEXT_LABEL,
+        renderKey: 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 = getDefaultSpacing(
+        node.entity,
+        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: FlowNodeBaseType.BLOCK_ICON,
+      originParent: node,
+      parent: node
+    });
+    const loopInlineBlocks = document.addNode({
+      id: `$inlineBlocks$${node.id}`,
+      hidden: true,
+      type: 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: 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: FlowTransitionLabelEnum.TEXT_LABEL,
+        renderKey: FlowTextKey.LOOP_END_TEXT,
+        // 循环 label 垂直样式展示，而非 rotate 旋转文案
+        props: isVertical ? void 0 : {
+          style: {
+            maxWidth: "20px",
+            lineHeight: "12px",
+            whiteSpace: "pre-wrap"
+          }
+        },
+        offset: Point.move(currentTransform.outputPoint, isVertical ? { y: -26 } : { x: -26 })
+      },
+      {
+        type: 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: FlowNodeBaseType.BLOCK_ICON,
+      meta: {
+        spacing: LoopSpacings.LOOP_BLOCK_ICON_SPACING
+      }
+    },
+    LoopLeftEmptyBlockRegistry,
+    LoopEmptyBranchRegistry,
+    LoopRightEmptyBlockRegistry,
+    LoopInlineBlocksNodeRegistry
+  ],
+  /**
+   * @depreacted
+   */
+  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
+    });
+  }
+};
+var RootRegistry = {
+  type: FlowNodeBaseType.ROOT,
+  meta: {
+    spacing: DEFAULT_SPACING.NULL,
+    hidden: true
+  },
+  getInputPoint(transform) {
+    return transform.firstChild?.inputPoint || transform.bounds.topCenter;
+  },
+  getOutputPoint(transform) {
+    return transform.lastChild?.outputPoint || transform.bounds.bottomCenter;
+  }
+};
+var EmptyRegistry = {
+  type: FlowNodeBaseType.EMPTY,
+  meta: {
+    spacing: (node) => {
+      const spacing = getDefaultSpacing(node.entity, ConstantKeys.NODE_SPACING);
+      return spacing / 2;
+    },
+    size: { width: 0, height: 0 },
+    hidden: true
+  },
+  getLabels(transition) {
+    return [
+      {
+        offset: transition.transform.bounds,
+        type: FlowTransitionLabelEnum.ADDER_LABEL
+      }
+    ];
+  }
+};
+var SimpleSplitRegistry = {
+  type: FlowNodeSplitType.SIMPLE_SPLIT,
+  extend: FlowNodeSplitType.DYNAMIC_SPLIT,
+  onBlockChildCreate(originParent, blockData, addedNodes = []) {
+    const { document } = originParent;
+    const parent = document.getNode(`$inlineBlocks$${originParent.id}`);
+    const realBlock = document.addNode(
+      {
+        ...blockData,
+        type: blockData.type || FlowNodeBaseType.BLOCK,
+        parent
+      },
+      addedNodes
+    );
+    addedNodes.push(realBlock);
+    return realBlock;
+  }
+  // addChild(node, json, options = {}) {
+  //   const { index } = options;
+  //   const document = node.document;
+  //   return document.addBlock(node, json, undefined, undefined, index);
+  // }
+};
+var BreakRegistry = {
+  type: FlowNodeBaseType.BREAK,
+  extend: FlowNodeBaseType.END
+};
+var InputRegistry = {
+  type: FlowNodeBaseType.INPUT,
+  extend: FlowNodeBaseType.BLOCK,
+  meta: {
+    hidden: false
+  },
+  getLines(transition, layout) {
+    const currentTransform = transition.transform;
+    const { isVertical } = transition.entity;
+    const lines = [];
+    const hasBranchDraggingAdder = currentTransform && currentTransform.entity.isInlineBlock && transition.renderData.draggable;
+    if (hasBranchDraggingAdder) {
+      if (isVertical) {
+        const currentOffsetRightX = currentTransform.firstChild ? currentTransform.firstChild.bounds.right : currentTransform.bounds.right;
+        const nextOffsetLeftX = (currentTransform.next?.firstChild ? currentTransform.next?.firstChild.bounds?.left : currentTransform.next?.bounds?.left) || 0;
+        const currentInputPointY = currentTransform.outputPoint.y;
+        if (currentTransform?.next) {
+          lines.push({
+            type: FlowTransitionLineEnum.MERGE_LINE,
+            isDraggingLine: true,
+            from: {
+              x: (currentOffsetRightX + nextOffsetLeftX) / 2,
+              y: currentInputPointY
+            },
+            to: currentTransform.parent.outputPoint,
+            side: LABEL_SIDE_TYPE.NORMAL_BRANCH
+          });
+        }
+      } else {
+        const currentOffsetBottomX = currentTransform.firstChild ? currentTransform.firstChild.bounds.bottom : currentTransform.bounds.bottom;
+        const nextOffsetTopX = (currentTransform.next?.firstChild ? currentTransform.next?.firstChild.bounds?.top : currentTransform.next?.bounds?.top) || 0;
+        const currentInputPointX = currentTransform.outputPoint.x;
+        if (currentTransform?.next) {
+          lines.push({
+            type: FlowTransitionLineEnum.MERGE_LINE,
+            isDraggingLine: true,
+            from: {
+              x: currentInputPointX,
+              y: (currentOffsetBottomX + nextOffsetTopX) / 2
+            },
+            to: currentTransform.parent.outputPoint,
+            side: LABEL_SIDE_TYPE.NORMAL_BRANCH
+          });
+        }
+      }
+    }
+    if (!transition.isNodeEnd) {
+      lines.push({
+        type: FlowTransitionLineEnum.MERGE_LINE,
+        from: currentTransform.outputPoint,
+        to: currentTransform.parent.outputPoint,
+        side: LABEL_SIDE_TYPE.NORMAL_BRANCH
+      });
+    }
+    return lines;
+  },
+  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 ? currentTransform.firstChild.bounds.right : currentTransform.bounds.right;
+        const nextOffsetLeftX = (currentTransform.next?.firstChild ? currentTransform.next.firstChild.bounds?.left : currentTransform.next?.bounds?.left) || 0;
+        const currentInputPointY = currentTransform.outputPoint.y;
+        if (currentTransform?.next) {
+          draggingLabel.push({
+            offset: {
+              x: (currentOffsetRightX + nextOffsetLeftX) / 2,
+              y: currentInputPointY
+            },
+            type: FlowTransitionLabelEnum.BRANCH_DRAGGING_LABEL,
+            width: nextOffsetLeftX - currentOffsetRightX,
+            props: {
+              side: LABEL_SIDE_TYPE.NORMAL_BRANCH
+            }
+          });
+        }
+      } else {
+        const currentOffsetBottomX = currentTransform.firstChild ? currentTransform.firstChild.bounds.bottom : currentTransform.bounds.bottom;
+        const nextOffsetTopX = (currentTransform.next?.firstChild ? currentTransform.next.firstChild.bounds?.top : currentTransform.next?.bounds?.top) || 0;
+        const currentInputPointX = currentTransform.outputPoint.x;
+        if (currentTransform?.next) {
+          draggingLabel.push({
+            offset: {
+              x: currentInputPointX,
+              y: (currentOffsetBottomX + nextOffsetTopX) / 2
+            },
+            type: FlowTransitionLabelEnum.BRANCH_DRAGGING_LABEL,
+            width: nextOffsetTopX - currentOffsetBottomX,
+            props: {
+              side: LABEL_SIDE_TYPE.NORMAL_BRANCH
+            }
+          });
+        }
+      }
+    }
+    return [...draggingLabel];
+  }
+};
+var OuputRegistry = {
+  type: FlowNodeBaseType.OUTPUT,
+  extend: FlowNodeBaseType.BLOCK,
+  meta: {
+    hidden: false,
+    isNodeEnd: true
+  }
+};
+var MultiOuputsRegistry = {
+  type: FlowNodeBaseType.MULTI_OUTPUTS,
+  extend: FlowNodeSplitType.SIMPLE_SPLIT,
+  meta: {
+    isNodeEnd: true
+  },
+  getLines: (transition, layout) => {
+    if (transition.entity.parent?.flowNodeType === FlowNodeBaseType.INLINE_BLOCKS) {
+      return BlockRegistry.getLines(transition, layout);
+    }
+    return [];
+  },
+  getLabels: (transition, layout) => [
+    ...DynamicSplitRegistry.getLabels(transition, layout),
+    ...BlockRegistry.getLabels(transition, layout)
+  ],
+  getOutputPoint(transform, layout) {
+    const isVertical = FlowLayoutDefault.isVertical(layout);
+    const lastChildOutput = transform.lastChild?.outputPoint;
+    if (isVertical) {
+      return {
+        x: lastChildOutput ? lastChildOutput.x : transform.bounds.center.x,
+        y: transform.bounds.bottom
+      };
+    }
+    return {
+      x: transform.bounds.right,
+      y: lastChildOutput ? lastChildOutput.y : transform.bounds.center.y
+    };
+  },
+  extendChildRegistries: [
+    {
+      type: FlowNodeBaseType.BLOCK_ICON,
+      meta: {
+        // isNodeEnd: true
+      }
+    }
+  ]
+};
+var MultiInputsRegistry = {
+  type: FlowNodeBaseType.MULTI_INPUTS,
+  extend: FlowNodeSplitType.SIMPLE_SPLIT,
+  extendChildRegistries: [
+    {
+      type: FlowNodeBaseType.BLOCK_ICON,
+      meta: {
+        hidden: true,
+        spacing: 0
+      },
+      getLines() {
+        return [];
+      },
+      getLabels() {
+        return [];
+      }
+    },
+    {
+      type: FlowNodeBaseType.INLINE_BLOCKS,
+      meta: {
+        inlineSpacingPre: 0
+      },
+      getLabels(transition) {
+        const isVertical = transition.entity.isVertical;
+        const currentTransform = transition.transform;
+        const spacing = getDefaultSpacing(
+          transition.entity,
+          ConstantKeys.INLINE_BLOCKS_PADDING_BOTTOM
+        );
+        if (currentTransform.collapsed || transition.entity.childrenLength === 0) {
+          return [
+            {
+              type: FlowTransitionLabelEnum.CUSTOM_LABEL,
+              renderKey: FlowRendererKey.BRANCH_ADDER,
+              offset: Point.move(
+                currentTransform.outputPoint,
+                isVertical ? { y: spacing } : { x: spacing }
+              ),
+              props: {
+                // 激活状态
+                activated: transition.entity.getData(FlowNodeRenderData).activated,
+                transform: currentTransform,
+                // 传给外部使用的 node 信息
+                node: currentTransform.originParent?.entity
+              }
+            }
+          ];
+        }
+        return [
+          {
+            type: FlowTransitionLabelEnum.CUSTOM_LABEL,
+            renderKey: FlowRendererKey.BRANCH_ADDER,
+            offset: Point.move(
+              currentTransform.outputPoint,
+              isVertical ? { y: -spacing / 2 } : { x: -spacing / 2 }
+            ),
+            props: {
+              // 激活状态
+              activated: transition.entity.getData(FlowNodeRenderData).activated,
+              transform: currentTransform,
+              // 传给外部使用的 node 信息
+              node: currentTransform.originParent?.entity
+            }
+          }
+        ];
+      }
+    }
+  ],
+  getLabels() {
+    return [];
+  }
+};
+var RENDER_SLOT_ADDER_KEY = FlowRendererKey.SLOT_ADDER;
+var RENDER_SLOT_LABEL_KEY = FlowRendererKey.SLOT_LABEL;
+var RENDER_SLOT_COLLAPSE_KEY = FlowRendererKey.SLOT_COLLAPSE;
+var SlotSpacingKey = {
+  /**
+   * = Next Node - Slot END
+   */
+  SLOT_SPACING: "SLOT_SPACING",
+  /**
+   * = Slot Start Line - Slot Icon Right
+   */
+  SLOT_START_DISTANCE: "SLOT_START_DISTANCE",
+  /**
+   * = Slot Radius
+   */
+  SLOT_RADIUS: "SLOT_RADIUS",
+  /**
+   * = Slot Port - Slot Start
+   */
+  SLOT_PORT_DISTANCE: "SLOT_PORT_DISTANCE",
+  /**
+   * = Slot Label - Slot Start
+   */
+  SLOT_LABEL_DISTANCE: "SLOT_LABEL_DISTANCE",
+  /**
+   * = Slot Block - Slot Port
+   */
+  SLOT_BLOCK_PORT_DISTANCE: "SLOT_BLOCK_PORT_DISTANCE",
+  /**
+   * Vertical Layout: Slot Block - Slot Block
+   */
+  SLOT_BLOCK_VERTICAL_SPACING: "SLOT_BLOCK_VERTICAL_SPACING"
+};
+var SLOT_START_DISTANCE = 16;
+var SLOT_PORT_DISTANCE = 100;
+var SLOT_LABEL_DISTANCE = 32;
+var SLOT_BLOCK_PORT_DISTANCE = 32.5;
+var SLOT_RADIUS = 16;
+var SLOT_SPACING = 32;
+var SLOT_BLOCK_VERTICAL_SPACING = 32.5;
+var SLOT_NODE_LAST_SPACING = 10;
+var SlotNodeType = ((SlotNodeType2) => {
+  SlotNodeType2[SlotNodeType2["Slot"] = FlowNodeBaseType.SLOT] = "Slot";
+  SlotNodeType2[SlotNodeType2["SlotBlock"] = FlowNodeBaseType.SLOT_BLOCK] = "SlotBlock";
+  SlotNodeType2["SlotInlineBlocks"] = "slotInlineBlocks";
+  SlotNodeType2["SlotBlockInlineBlocks"] = "slotBlockInlineBlocks";
+  return SlotNodeType2;
+})(SlotNodeType || {});
+
+// src/activities/slot/utils/node.ts
+var canSlotDrilldown = (Slot) => !!Slot?.lastCollapsedChild?.blocks.length;
+var insideSlot = (entity) => !!entity?.parent?.isTypeOrExtendType(SlotNodeType.SlotBlock);
+var getDisplayFirstChildTransform = (transform) => {
+  if (transform.firstChild) {
+    return getDisplayFirstChildTransform(transform.firstChild);
+  }
+  return transform;
+};
+
+// src/activities/slot/utils/transition.ts
+var getSlotChildLineStartPoint = (iconTransform) => {
+  if (!iconTransform) {
+    return { x: 0, y: 0 };
+  }
+  const startDistance = getDefaultSpacing(
+    iconTransform.entity,
+    SlotSpacingKey.SLOT_START_DISTANCE,
+    SLOT_START_DISTANCE
+  );
+  if (!iconTransform.entity.isVertical) {
+    return {
+      x: iconTransform?.bounds.center.x,
+      y: iconTransform?.bounds.bottom + startDistance
+    };
+  }
+  return {
+    x: iconTransform?.bounds.right + startDistance,
+    y: iconTransform?.bounds.center.y
+  };
+};
+var getOutputPoint = (transform) => {
+  const icon = transform.firstChild;
+  if (!icon) {
+    return { x: 0, y: 0 };
+  }
+  if (!transform.entity.isVertical) {
+    return {
+      x: transform.bounds.right,
+      y: icon.outputPoint.y
+    };
+  }
+  return {
+    x: icon.outputPoint.x,
+    y: transform.bounds.bottom
+  };
+};
+var getInputPoint = (transform) => {
+  const icon = transform.firstChild;
+  if (!icon) {
+    return { x: 0, y: 0 };
+  }
+  if (!transform.entity.isVertical) {
+    return {
+      x: transform.bounds.left,
+      y: icon.outputPoint.y
+    };
+  }
+  return icon.inputPoint;
+};
+var getTransitionToPoint = (transition) => {
+  let toPoint = transition.transform.next?.inputPoint;
+  const icon = transition.transform.firstChild;
+  const parent = transition.transform.parent;
+  if (!icon || !parent) {
+    return { x: 0, y: 0 };
+  }
+  if (!transition.transform.next) {
+    if (!transition.entity.isVertical) {
+      toPoint = {
+        x: parent.outputPoint.x,
+        y: icon.outputPoint.y
+      };
+    } else {
+      toPoint = {
+        x: icon.outputPoint.x,
+        y: parent.outputPoint.y
+      };
+    }
+  }
+  return toPoint || { x: 0, y: 0 };
+};
+var drawStraightLine = (transition) => {
+  const icon = transition.transform.firstChild;
+  const toPoint = getTransitionToPoint(transition);
+  if (!icon) {
+    return [];
+  }
+  return [
+    {
+      type: FlowTransitionLineEnum.STRAIGHT_LINE,
+      from: icon.outputPoint,
+      to: toPoint
+    },
+    {
+      type: FlowTransitionLineEnum.STRAIGHT_LINE,
+      from: icon.inputPoint,
+      to: transition.transform.inputPoint
+    }
+  ];
+};
+var drawCollapseLabel = (transition) => {
+  const icon = transition.transform;
+  return [
+    {
+      type: FlowTransitionLabelEnum.CUSTOM_LABEL,
+      renderKey: RENDER_SLOT_COLLAPSE_KEY,
+      offset: getSlotChildLineStartPoint(icon),
+      props: {
+        node: transition.entity.parent
+      }
+    }
+  ];
+};
+var drawCollapseLine = (transition) => {
+  const startDistance = getDefaultSpacing(
+    transition.transform.entity,
+    SlotSpacingKey.SLOT_START_DISTANCE,
+    SLOT_START_DISTANCE
+  );
+  return [
+    {
+      type: FlowTransitionLineEnum.STRAIGHT_LINE,
+      from: getSlotChildLineStartPoint(transition.transform),
+      to: Point.move(
+        getSlotChildLineStartPoint(transition.transform),
+        transition.entity.isVertical ? { x: -startDistance, y: 0 } : { x: 0, y: -startDistance }
+      ),
+      style: {
+        strokeDasharray: "5 5"
+      }
+    }
+  ];
+};
+var drawStraightAdder = (transition) => {
+  const toPoint = getTransitionToPoint(transition);
+  const fromPoint = transition.transform.firstChild.outputPoint;
+  const hoverProps = transition.entity.isVertical ? {
+    hoverHeight: toPoint.y - fromPoint.y,
+    hoverWidth: transition.transform.firstChild?.bounds.width
+  } : {
+    hoverHeight: transition.transform.firstChild?.bounds.height,
+    hoverWidth: toPoint.x - fromPoint.x
+  };
+  return [
+    {
+      offset: Point.getMiddlePoint(fromPoint, toPoint),
+      type: FlowTransitionLabelEnum.ADDER_LABEL,
+      props: hoverProps
+    }
+  ];
+};
+var getPortChildInput = (_child) => {
+  if (!_child) {
+    return { x: 0, y: 0 };
+  }
+  const firstChild = getDisplayFirstChildTransform(_child);
+  return { x: _child.bounds.left, y: firstChild.bounds.center.y };
+};
+var getDisplayFirstChildTop = (transform) => {
+  if (transform.firstChild) {
+    return transform.localBounds.top + getDisplayFirstChildTop(transform.firstChild);
+  }
+  return transform.localBounds.center.y;
+};
+var getPortMiddle = (_port) => {
+  if (!_port.children.length) {
+    return _port.localBounds.top;
+  }
+  const portChildInputs = [_port.firstChild, _port.lastChild].map(
+    (_portChild) => getDisplayFirstChildTop(_portChild)
+  );
+  return _port.localBounds.top + mean(portChildInputs);
+};
+var getAllPortsMiddle = (inlineBlocks) => {
+  if (!inlineBlocks.children.length) {
+    return inlineBlocks.localBounds.height / 2;
+  }
+  const portInputs = [inlineBlocks.firstChild, inlineBlocks.lastChild].map(
+    (_port) => getPortMiddle(_port)
+  );
+  return mean(portInputs);
+};
+var createSlotFromJSON = (node, json) => {
+  const { document } = node;
+  const addedNodes = [];
+  const blockIconNode = document.addNode({
+    id: `$slotIcon$${node.id}`,
+    type: FlowNodeBaseType.BLOCK_ICON,
+    originParent: node,
+    parent: node
+  });
+  const inlineBlocksNode = document.addNode({
+    id: `$slotInlineBlocks$${node.id}`,
+    type: "slotInlineBlocks" /* SlotInlineBlocks */,
+    originParent: node,
+    parent: node
+  });
+  addedNodes.push(blockIconNode);
+  addedNodes.push(inlineBlocksNode);
+  const portJSONList = json.blocks || [];
+  portJSONList.forEach((_portJSON) => {
+    const port = document.addNode({
+      type: SlotNodeType.SlotBlock,
+      ..._portJSON,
+      originParent: node,
+      parent: inlineBlocksNode
+    });
+    addedNodes.push(port);
+    (_portJSON.blocks || []).forEach((_portChild) => {
+      document.addNode(
+        {
+          type: SlotNodeType.Slot,
+          ..._portChild,
+          parent: port
+        },
+        addedNodes
+      );
+    });
+  });
+  return addedNodes;
+};
+var SlotIconRegistry = {
+  type: FlowNodeBaseType.BLOCK_ICON,
+  meta: {
+    defaultExpanded: false,
+    spacing: 0
+  },
+  getLines: (transition) => [
+    ...canSlotDrilldown(transition.entity.parent) ? drawCollapseLine(transition) : []
+  ],
+  getLabels: (transition) => [
+    ...canSlotDrilldown(transition.entity.parent) ? drawCollapseLabel(transition) : []
+  ],
+  getDelta: (transform) => {
+    if (insideSlot(transform.entity.parent)) {
+      return transform.entity.isVertical ? { x: -transform.originDeltaX, y: 0 } : { x: 0, y: -transform.originDeltaY };
+    }
+    return { x: 0, y: 0 };
+  }
+};
+var SlotInlineBlocksRegistry = {
+  type: "slotInlineBlocks" /* SlotInlineBlocks */,
+  extend: FlowNodeBaseType.BLOCK,
+  meta: {
+    spacing: 0,
+    inlineSpacingPre: 0,
+    inlineSpacingAfter: 0,
+    isInlineBlocks: (node) => !node.isVertical
+  },
+  getLines() {
+    return [];
+  },
+  getLabels() {
+    return [];
+  },
+  getChildDelta(child, layout) {
+    if (child.entity.isVertical) {
+      return { x: 0, y: 0 };
+    }
+    const preTransform = child.entity.pre?.getData(FlowNodeTransformData);
+    if (preTransform) {
+      const { localBounds: preBounds } = preTransform;
+      return {
+        x: 0,
+        y: preBounds.bottom + 30
+      };
+    }
+    return { x: 0, y: 0 };
+  },
+  /**
+   * 控制条件分支居右布局
+   */
+  getDelta(transform) {
+    if (!transform.children.length) {
+      return { x: 0, y: 0 };
+    }
+    const icon = transform.pre;
+    if (!icon) {
+      return { x: 0, y: 0 };
+    }
+    const startDistance = getDefaultSpacing(
+      transform.entity,
+      SlotSpacingKey.SLOT_START_DISTANCE,
+      SLOT_START_DISTANCE
+    );
+    const portDistance = getDefaultSpacing(
+      transform.entity,
+      SlotSpacingKey.SLOT_PORT_DISTANCE,
+      SLOT_PORT_DISTANCE
+    );
+    const portBlockDistance = getDefaultSpacing(
+      transform.entity,
+      SlotSpacingKey.SLOT_BLOCK_PORT_DISTANCE,
+      SLOT_BLOCK_PORT_DISTANCE
+    );
+    if (!transform.entity.isVertical) {
+      const noChildren = transform?.children?.every?.((_port) => !_port.children.length);
+      if (noChildren) {
+        return {
+          x: portDistance - icon.localBounds.width / 2,
+          y: icon.localBounds.bottom + startDistance
+        };
+      }
+      return {
+        x: portDistance + portBlockDistance - icon.localBounds.width / 2,
+        y: icon.localBounds.bottom + startDistance
+      };
+    }
+    const slotInlineBlockDelta = startDistance + portDistance + portBlockDistance;
+    return {
+      x: icon.localBounds.right + slotInlineBlockDelta,
+      y: -icon.localBounds.height
+    };
+  }
+};
+var SlotBlockRegistry = {
+  type: SlotNodeType.SlotBlock,
+  extend: FlowNodeBaseType.BLOCK,
+  meta: {
+    inlineSpacingAfter: 0,
+    inlineSpacingPre: 0,
+    spacing: (transform) => {
+      if (!transform.entity.isVertical && transform.size.width === 0) {
+        return 90;
+      }
+      return getDefaultSpacing(
+        transform.entity,
+        SlotSpacingKey.SLOT_BLOCK_VERTICAL_SPACING,
+        SLOT_BLOCK_VERTICAL_SPACING
+      );
+    },
+    isInlineBlocks: (node) => !node.isVertical
+  },
+  getLines(transition) {
+    const icon = transition.transform.parent?.pre;
+    const start = getSlotChildLineStartPoint(icon);
+    const portPoint = transition.transform.inputPoint;
+    const radius = getDefaultSpacing(
+      transition.transform.entity,
+      SlotSpacingKey.SLOT_RADIUS,
+      SLOT_RADIUS
+    );
+    let startPortVertices = [{ x: start.x, y: portPoint.y }];
+    if (transition.entity.isVertical) {
+      const deltaY = Math.abs(portPoint.y - start.y);
+      let deltaX = radius;
+      let isTruncated = false;
+      if (deltaY < radius * 2) {
+        isTruncated = true;
+        if (deltaY < radius) {
+          deltaX = Math.sqrt(radius ** 2 - (radius - deltaY) ** 2);
+        }
+      }
+      startPortVertices = [
+        {
+          x: start.x + deltaX,
+          y: start.y,
+          radiusX: radius,
+          radiusY: radius,
+          radiusOverflow: "truncate"
+        },
+        {
+          x: start.x + deltaX,
+          y: portPoint.y,
+          ...isTruncated ? { radiusX: 0, radiusY: 0 } : {}
+        }
+      ];
+    }
+    if (transition.transform.children.length === 1) {
+      return [
+        {
+          type: FlowTransitionLineEnum.ROUNDED_LINE,
+          from: start,
+          to: getPortChildInput(transition.transform.children[0]),
+          vertices: startPortVertices,
+          style: {
+            strokeDasharray: "5 5"
+          },
+          radius
+        }
+      ];
+    }
+    return [
+      {
+        type: FlowTransitionLineEnum.ROUNDED_LINE,
+        from: start,
+        to: portPoint,
+        vertices: startPortVertices,
+        style: {
+          strokeDasharray: "5 5"
+        },
+        radius
+      },
+      ...transition.transform.children.map((_child) => {
+        const childInput = getPortChildInput(_child);
+        return {
+          type: FlowTransitionLineEnum.ROUNDED_LINE,
+          radius,
+          from: portPoint,
+          to: childInput,
+          vertices: [{ x: portPoint.x, y: childInput.y }],
+          style: {
+            strokeDasharray: "5 5"
+          }
+        };
+      })
+    ];
+  },
+  getLabels(transition) {
+    const icon = transition.transform.parent?.pre;
+    const start = getSlotChildLineStartPoint(icon);
+    const portPoint = transition.transform.inputPoint;
+    return [
+      {
+        type: FlowTransitionLabelEnum.CUSTOM_LABEL,
+        renderKey: RENDER_SLOT_ADDER_KEY,
+        props: {
+          node: transition.entity
+        },
+        offset: portPoint
+      },
+      {
+        type: FlowTransitionLabelEnum.CUSTOM_LABEL,
+        renderKey: RENDER_SLOT_LABEL_KEY,
+        props: {
+          node: transition.entity
+        },
+        offset: {
+          x: start.x + getDefaultSpacing(
+            transition.entity,
+            SlotSpacingKey.SLOT_LABEL_DISTANCE,
+            SLOT_LABEL_DISTANCE
+          ),
+          y: portPoint.y
+        },
+        origin: [0, 0.5]
+      }
+    ];
+  },
+  getInputPoint(transform) {
+    const icon = transform.parent?.pre;
+    const start = getSlotChildLineStartPoint(icon);
+    let inputY = transform.bounds.center.y;
+    if (transform.children.length) {
+      inputY = mean([
+        getPortChildInput(transform.firstChild).y,
+        getPortChildInput(transform.lastChild).y
+      ]);
+    }
+    return {
+      x: start.x + getDefaultSpacing(transform.entity, SlotSpacingKey.SLOT_PORT_DISTANCE, SLOT_PORT_DISTANCE),
+      y: inputY
+    };
+  },
+  getChildDelta(child, layout) {
+    const hasChild = !!child.firstChild;
+    if (child.entity.isVertical) {
+      let deltaX = hasChild ? 0 : -child.originDeltaX;
+      return { x: deltaX, y: 0 };
+    }
+    let deltaY = hasChild ? 0 : -child.originDeltaY;
+    const preTransform = child.entity.pre?.getData(FlowNodeTransformData);
+    if (preTransform) {
+      const { localBounds: preBounds } = preTransform;
+      return {
+        x: 0,
+        y: preBounds.bottom + 30 + deltaY
+      };
+    }
+    return { x: 0, y: deltaY };
+  },
+  getChildLabels() {
+    return [];
+  },
+  getChildLines() {
+    return [];
+  },
+  getDelta(transform) {
+    return {
+      x: 0,
+      y: 0
+    };
+  }
+};
+
+// src/activities/slot/slot.ts
+var SlotRegistry = {
+  type: FlowNodeBaseType.SLOT,
+  extend: "block",
+  meta: {
+    // Slot 节点内部暂时不允许拖拽
+    draggable: (node) => !insideSlot(node),
+    hidden: true,
+    spacing: (node) => getDefaultSpacing(node.entity, SlotSpacingKey.SLOT_SPACING, SLOT_SPACING),
+    padding: (node) => ({
+      left: 0,
+      right: node.collapsed ? getDefaultSpacing(node.entity, SlotSpacingKey.SLOT_START_DISTANCE, SLOT_START_DISTANCE) : 0,
+      bottom: !insideSlot(node.entity) && node.isLast ? SLOT_NODE_LAST_SPACING : 0,
+      top: 0
+    }),
+    copyDisable: false,
+    defaultExpanded: false
+  },
+  /**
+   * 业务通常需要重载方法
+   */
+  onCreate: createSlotFromJSON,
+  getLines: (transition) => [
+    ...!insideSlot(transition.entity) ? drawStraightLine(transition) : []
+  ],
+  getLabels: (transition) => [
+    ...!insideSlot(transition.entity) ? drawStraightAdder(transition) : []
+  ],
+  getInputPoint,
+  getOutputPoint,
+  onAfterUpdateLocalTransform(transform) {
+    const { isVertical } = transform.entity;
+    if (!isVertical) {
+      return;
+    }
+    const icon = transform.firstChild;
+    const inlineBlocks = transform.lastChild;
+    if (!icon || !inlineBlocks) {
+      return;
+    }
+    const iconSize = icon.localBounds.height;
+    const inlineBlocksSize = inlineBlocks.localBounds.height;
+    if (transform.collapsed || !inlineBlocks) {
+      return;
+    }
+    const portsMiddle = getAllPortsMiddle(inlineBlocks);
+    icon.entity.clearMemoLocal();
+    inlineBlocks.entity.clearMemoLocal();
+    if (iconSize / 2 + portsMiddle > inlineBlocksSize || !inlineBlocks.children.length) {
+      icon.transform.update({
+        position: { x: icon.transform.position.x, y: 0 }
+      });
+      inlineBlocks.transform.update({
+        position: {
+          x: inlineBlocks.transform.position.x,
+          y: Math.max(iconSize / 2 - inlineBlocksSize / 2, 0)
+        }
+      });
+      return;
+    }
+    inlineBlocks.transform.update({
+      position: { x: inlineBlocks.transform.position.x, y: 0 }
+    });
+    icon?.transform.update({
+      position: {
+        x: icon.transform.position.x,
+        y: Math.max(portsMiddle - iconSize / 2, 0)
+        // 所有 port 的中间点
+      }
+    });
+  },
+  extendChildRegistries: [SlotIconRegistry, SlotInlineBlocksRegistry]
+};
+
+// src/flow-registers.ts
+var FlowRegisters = class {
+  /**
+   * 注册数据层
+   * @param document
+   */
+  registerDocument(document) {
+    document.registerFlowNodes(
+      RootRegistry,
+      // 根节点
+      StartRegistry,
+      // 开始节点
+      DynamicSplitRegistry,
+      // 动态分支（并行、排他）
+      StaticSplitRegistry,
+      // 静态分支（审批）
+      SimpleSplitRegistry,
+      // 简单分支 （不带 orderIcon 节点）
+      BlockRegistry,
+      // 单条 block 注册
+      InlineBlocksRegistry,
+      // 多个 block 组成的 block 列表
+      BlockIconRegistry,
+      // icon 节点，如条件分支的菱形图标
+      BlockOrderIconRegistry,
+      // 带顺序的图标节点，一般为 block 第一个分支节点
+      TryCatchRegistry,
+      // TryCatch
+      EndRegistry,
+      // 结束节点
+      LoopRegistry,
+      // 循环节点
+      EmptyRegistry,
+      // 占位节点
+      BreakRegistry,
+      // 分支断开
+      MultiOuputsRegistry,
+      MultiInputsRegistry,
+      InputRegistry,
+      OuputRegistry,
+      SlotRegistry,
+      SlotBlockRegistry
+    );
+    document.registerNodeDatas(
+      FlowNodeRenderData,
+      // 渲染节点相关数据
+      FlowNodeTransitionData,
+      // 线条绘制数据
+      FlowNodeTransformData
+      // 坐标计算数据
+    );
+  }
+  /**
+   * 注册渲染层
+   * @param renderer
+   */
+  registerRenderer(renderer) {
+    renderer.registerLayers(
+      FlowNodesTransformLayer,
+      // 节点位置渲染
+      FlowNodesContentLayer,
+      // 节点内容渲染
+      FlowLinesLayer,
+      // 线条渲染
+      FlowLabelsLayer,
+      // Label 渲染
+      PlaygroundLayer
+      // 画布基础层，提供缩放、手势等能力
+    );
+  }
+  /**
+   * 画布开始渲染 (hook)
+   */
+  onReady() {
+  }
+  /**
+   * 画布销毁 (hook)
+   */
+  onDispose() {
+  }
+};
+FlowRegisters = __decorateClass([
+  injectable()
+], FlowRegisters);
+
+// src/fixed-layout-container-module.ts
+var FixedLayoutContainerModule = new ContainerModule((bind) => {
+  bindContributions(bind, FlowRegisters, [
+    FlowDocumentContribution,
+    FlowRendererContribution,
+    PlaygroundContribution
+  ]);
+});
+
+// src/index.ts
+var FixedLayoutRegistries = {
+  BlockIconRegistry,
+  BlockOrderIconRegistry,
+  BlockRegistry,
+  DynamicSplitRegistry,
+  EmptyRegistry,
+  LoopRegistry,
+  StaticSplitRegistry,
+  TryCatchRegistry,
+  StartRegistry,
+  RootRegistry,
+  InlineBlocksRegistry,
+  EndRegistry,
+  SlotRegistry,
+  SlotBlockRegistry,
+  SlotIconRegistry,
+  SlotInlineBlocksRegistry
+};
+
+export { FixedLayoutContainerModule, FixedLayoutRegistries, SlotSpacingKey };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map