@flowgram.ai/document 0.1.0-alpha.2 → 0.1.0-alpha.21

package/dist/index.js

@@ -27,8 +27,8 @@ var __decorateClass = (decorators, target, key, kind) => {
 var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
+var index_exports = {};
+__export(index_exports, {
   ConstantKeys: () => ConstantKeys,
   DEFAULT_FLOW_NODE_META: () => DEFAULT_FLOW_NODE_META,
   DEFAULT_SIZE: () => DEFAULT_SIZE,
@@ -71,7 +71,7 @@ __export(src_exports, {
   drawLineToNext: () => drawLineToNext,
   getDefaultSpacing: () => getDefaultSpacing
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(index_exports);
 
 // src/typings/flow.ts
 var FlowNodeBaseType = /* @__PURE__ */ ((FlowNodeBaseType2) => {
@@ -85,11 +85,19 @@ var FlowNodeBaseType = /* @__PURE__ */ ((FlowNodeBaseType2) => {
   FlowNodeBaseType2["BLOCK_ORDER_ICON"] = "blockOrderIcon";
   FlowNodeBaseType2["GROUP"] = "group";
   FlowNodeBaseType2["END"] = "end";
+  FlowNodeBaseType2["BREAK"] = "break";
   FlowNodeBaseType2["CONDITION"] = "condition";
   FlowNodeBaseType2["SUB_CANVAS"] = "subCanvas";
+  FlowNodeBaseType2["MULTI_INPUTS"] = "multiInputs";
+  FlowNodeBaseType2["MULTI_OUTPUTS"] = "multiOutputs";
+  FlowNodeBaseType2["INPUT"] = "input";
+  FlowNodeBaseType2["OUTPUT"] = "output";
+  FlowNodeBaseType2["SLOT"] = "slot";
+  FlowNodeBaseType2["SLOT_BLOCK"] = "slotBlock";
   return FlowNodeBaseType2;
 })(FlowNodeBaseType || {});
 var FlowNodeSplitType = /* @__PURE__ */ ((FlowNodeSplitType2) => {
+  FlowNodeSplitType2["SIMPLE_SPLIT"] = "simpleSplit";
   FlowNodeSplitType2["DYNAMIC_SPLIT"] = "dynamicSplit";
   FlowNodeSplitType2["STATIC_SPLIT"] = "staticSplit";
   return FlowNodeSplitType2;
@@ -145,6 +153,14 @@ var DefaultSpacingKey = {
    * 普通节点间距。垂直 / 水平
    */
   NODE_SPACING: "SPACING",
+  /**
+   * 分支节点间距
+   */
+  BRANCH_SPACING: "BRANCH_SPACING",
+  /**
+   * 圆弧线条拐角 radius
+   */
+  ROUNDED_LINE_RADIUS: "ROUNDED_LINE_RADIUS",
   /**
    * 圆弧线条 x radius
    */
@@ -171,13 +187,19 @@ var DEFAULT_SPACING = {
   NULL: 0,
   [DefaultSpacingKey.NODE_SPACING]: 32,
   // 普通节点间距。垂直 / 水平
+  [DefaultSpacingKey.BRANCH_SPACING]: 20,
+  // 分支节点间距
+  /**
+   * @deprecated use 'BRANCH_SPACING' instead
+   */
   MARGIN_RIGHT: 20,
-  // 普通节点右边间距
+  // 分支节点右边间距
   INLINE_BLOCK_PADDING_BOTTOM: 16,
   // block 底部留白
   INLINE_BLOCKS_PADDING_TOP: 30,
   // block list 上部留白间距
-  [DefaultSpacingKey.INLINE_BLOCKS_PADDING_BOTTOM]: 40,
+  // JS 浮点数有误差，1046.6 -1006.6 = 39.9999999，会导致 间距/20 < 2 导致布局计算问题，因此需要额外增加 0.1 像素
+  [DefaultSpacingKey.INLINE_BLOCKS_PADDING_BOTTOM]: 40.1,
   // block lit 下部留白间距，因为有两个拐弯，所以翻一倍
   MIN_INLINE_BLOCK_SPACING: 200,
   // 分支间最小边距 (垂直布局)
@@ -185,6 +207,8 @@ var DEFAULT_SPACING = {
   // 分支间最小边距 (水平布局)
   [DefaultSpacingKey.COLLAPSED_SPACING]: 12,
   // 复合节点距离上个节点的距离
+  [DefaultSpacingKey.ROUNDED_LINE_RADIUS]: 16,
+  // 圆弧线条拐角 radius
   [DefaultSpacingKey.ROUNDED_LINE_X_RADIUS]: 16,
   // 圆弧线条 x radius
   [DefaultSpacingKey.ROUNDED_LINE_Y_RADIUS]: 20,
@@ -212,8 +236,6 @@ var DEFAULT_FLOW_NODE_META = (nodeType, document) => {
     isStart: nodeType === "start",
     hidden,
     defaultExpanded: document.options.allNodesDefaultExpanded,
-    expandedSize: { width: 520, height: 300 },
-    // 展开后的大小
     size: DEFAULT_SIZE,
     origin: document.layout.getDefaultNodeOrigin(),
     isInlineBlocks: nodeType === "inlineBlocks" /* INLINE_BLOCKS */,
@@ -233,13 +255,37 @@ var DEFAULT_FLOW_NODE_META = (nodeType, document) => {
 };
 var FlowNodeRegistry;
 ((FlowNodeRegistry4) => {
+  function mergeChildRegistries(r1 = [], r2 = []) {
+    if (r1.length === 0 || r2.length === 0) {
+      return [...r1, ...r2];
+    }
+    const r1Filter = r1.map((r1Current) => {
+      const r2Current = r2.find((n) => n.type === r1Current.type);
+      if (r2Current) {
+        return merge(r1Current, r2Current, r1Current.type);
+      }
+      return r1Current;
+    });
+    const r2Filter = r2.filter((n) => !r1.some((r) => r.type === n.type));
+    return [...r1Filter, ...r2Filter];
+  }
+  FlowNodeRegistry4.mergeChildRegistries = mergeChildRegistries;
   function merge(registry1, registry2, finalType) {
+    const extendKeys = registry1.__extends__ ? registry1.__extends__.slice() : [];
+    if (registry1.type !== registry2.type) {
+      extendKeys.unshift(registry1.type);
+    }
     return {
       ...registry1,
       ...registry2,
+      extendChildRegistries: mergeChildRegistries(
+        registry1.extendChildRegistries,
+        registry2.extendChildRegistries
+      ),
       meta: { ...registry1.meta, ...registry2.meta },
       extend: void 0,
-      type: finalType
+      type: finalType,
+      __extends__: extendKeys
     };
   }
   FlowNodeRegistry4.merge = merge;
@@ -263,7 +309,6 @@ var OperationType = /* @__PURE__ */ ((OperationType2) => {
   OperationType2["moveChildNodes"] = "moveChildNodes";
   OperationType2["addNodes"] = "addNodes";
   OperationType2["deleteNodes"] = "deleteNodes";
-  OperationType2["changeNode"] = "changeNode";
   OperationType2["addChildNode"] = "addChildNode";
   OperationType2["deleteChildNode"] = "deleteChildNode";
   OperationType2["addNode"] = "addNode";
@@ -304,16 +349,18 @@ var _FlowNodeRenderData = class _FlowNodeRenderData extends import_core.EntityDa
       expanded: defaultExpanded || false,
       activated: false,
       hovered: false,
-      dragging: false
+      dragging: false,
+      stackIndex: 0
     };
   }
-  updateExtInfo(info) {
-    if (import_utils.Compare.isChanged(this.data.extInfo, info)) {
-      const oldInfo = this.data.extInfo;
+  updateExtInfo(info, fullUpdate) {
+    const oldInfo = this.data.extInfo;
+    const newInfo = fullUpdate ? info : { ...oldInfo, ...info };
+    if (import_utils.Compare.isChanged(oldInfo, newInfo)) {
       this.update({
-        extInfo: info
+        extInfo: newInfo
       });
-      this.onExtInfoChangeEmitter.fire({ oldInfo, newInfo: info });
+      this.onExtInfoChangeEmitter.fire({ oldInfo, newInfo });
     }
   }
   getExtInfo() {
@@ -410,6 +457,12 @@ var _FlowNodeRenderData = class _FlowNodeRenderData extends import_core.EntityDa
     }
     return this.data.activated;
   }
+  get stackIndex() {
+    return this.data.stackIndex;
+  }
+  set stackIndex(index) {
+    this.data.stackIndex = index;
+  }
   get lineActivated() {
     const { activated } = this;
     if (!activated) return false;
@@ -459,10 +512,9 @@ var _FlowNodeTransformData = class _FlowNodeTransformData extends import_core2.E
     return this.entity.id;
   }
   getDefaultData() {
-    const { size, defaultExpanded, expandedSize, hidden } = this.entity.getNodeMeta();
-    const defaultSize = defaultExpanded ? expandedSize : size;
+    const { size, hidden } = this.entity.getNodeMeta();
     return {
-      size: !hidden ? { ...defaultSize } : { width: 0, height: 0 }
+      size: !hidden ? { ...size } : { width: 0, height: 0 }
     };
   }
   /**
@@ -493,6 +545,11 @@ var _FlowNodeTransformData = class _FlowNodeTransformData extends import_core2.E
       y: position.y
     };
   }
+  set position(position) {
+    this.transform.update({
+      position
+    });
+  }
   set size(size) {
     const { width, height } = this.data.size;
     if (this.isContainer) return;
@@ -1040,37 +1097,7 @@ var FlowNodeEntity = class extends import_core4.Entity {
    * @param newId
    */
   toJSON() {
-    if (this.document.options.toNodeJSON) {
-      return this.document.options.toNodeJSON(this);
-    }
-    const nodesMap = {};
-    let startNodeJSON;
-    this.document.traverse((node) => {
-      const isSystemNode = node.id.startsWith("$");
-      if (isSystemNode) return;
-      const nodeJSONData = this.getJSONData();
-      const nodeJSON = {
-        id: node.id,
-        type: node.flowNodeType
-      };
-      if (nodeJSONData !== void 0) {
-        nodeJSON.data = nodeJSONData;
-      }
-      if (!startNodeJSON) startNodeJSON = nodeJSON;
-      let { parent } = node;
-      if (parent && parent.id.startsWith("$")) {
-        parent = parent.originParent;
-      }
-      const parentJSON = parent ? nodesMap[parent.id] : void 0;
-      if (parentJSON) {
-        if (!parentJSON.blocks) {
-          parentJSON.blocks = [];
-        }
-        parentJSON.blocks.push(nodeJSON);
-      }
-      nodesMap[node.id] = nodeJSON;
-    }, this);
-    return startNodeJSON;
+    return this.document.toNodeJSON(this);
   }
   get isVertical() {
     return this.document.layout.name === "vertical-fixed-layout" /* VERTICAL_FIXED_LAYOUT */;
@@ -1079,8 +1106,8 @@ var FlowNodeEntity = class extends import_core4.Entity {
    * 修改节点扩展信息
    * @param info
    */
-  updateExtInfo(extInfo) {
-    this.getData(FlowNodeRenderData).updateExtInfo(extInfo);
+  updateExtInfo(extInfo, fullUpdate) {
+    this.getData(FlowNodeRenderData).updateExtInfo(extInfo, fullUpdate);
   }
   /**
    * 获取节点扩展信息
@@ -1109,6 +1136,19 @@ var FlowNodeEntity = class extends import_core4.Entity {
   get bounds() {
     return this.transform.bounds;
   }
+  /**
+   * Check node extend type
+   */
+  isExtend(parentType) {
+    return this.document.isExtend(this.flowNodeType, parentType);
+  }
+  /**
+   * Check node type
+   * @param parentType
+   */
+  isTypeOrExtendType(parentType) {
+    return this.document.isTypeOrExtendType(this.flowNodeType, parentType);
+  }
 };
 FlowNodeEntity.type = "FlowNodeEntity";
 ((FlowNodeEntity2) => {
@@ -1202,7 +1242,7 @@ var FlowDocumentTransformerEntity = class extends import_core5.ConfigEntity {
 FlowDocumentTransformerEntity.type = "FlowDocumentTransformerEntity";
 
 // src/entities/flow-renderer-state-entity.ts
-var import_lodash = require("lodash");
+var import_lodash_es = require("lodash-es");
 var import_core6 = require("@flowgram.ai/core");
 var FlowRendererStateEntity = class extends import_core6.ConfigEntity {
   getDefaultConfig() {
@@ -1219,6 +1259,22 @@ var FlowRendererStateEntity = class extends import_core6.ConfigEntity {
       nodeHoveredId: node?.id
     });
   }
+  get dragging() {
+    return this.config.dragging;
+  }
+  setDragging(dragging) {
+    this.updateConfig({
+      dragging
+    });
+  }
+  get isBranch() {
+    return this.config.isBranch;
+  }
+  setIsBranch(isBranch) {
+    this.updateConfig({
+      isBranch
+    });
+  }
   getDragLabelSide() {
     return this.config.dragLabelSide;
   }
@@ -1257,13 +1313,13 @@ var FlowRendererStateEntity = class extends import_core6.ConfigEntity {
     });
   }
   onNodeHoveredChange(fn, debounceTime = 100) {
-    return this.onConfigChanged((0, import_lodash.debounce)(() => fn(this.getNodeHovered()), debounceTime));
+    return this.onConfigChanged((0, import_lodash_es.debounce)(() => fn(this.getNodeHovered()), debounceTime));
   }
 };
 FlowRendererStateEntity.type = "FlowRendererStateEntity";
 
 // src/flow-document.ts
-var import_lodash2 = require("lodash");
+var import_lodash_es2 = require("lodash-es");
 var import_inversify2 = require("inversify");
 var import_utils7 = require("@flowgram.ai/utils");
 var import_core7 = require("@flowgram.ai/core");
@@ -1441,13 +1497,15 @@ var FlowVirtualTree = class _FlowVirtualTree {
   get size() {
     return this.map.size;
   }
-  toString() {
+  toString(showType) {
     const ret = [];
     this.traverse((node, depth) => {
       if (depth === 0) {
         ret.push(node.id);
       } else {
-        ret.push(`|${new Array(depth).fill("--").join("")} ${node.id}`);
+        ret.push(
+          `|${new Array(depth).fill("--").join("")} ${showType ? `${node.flowNodeType}(${node.id})` : node.id}`
+        );
       }
     });
     return `${ret.join("\n")}`;
@@ -1653,7 +1711,12 @@ var ConstantKeys = {
   /***
    * 线条、label 激活后的颜色
    */
-  BASE_ACTIVATED_COLOR: "BASE_ACTIVATED_COLOR"
+  BASE_ACTIVATED_COLOR: "BASE_ACTIVATED_COLOR",
+  /**
+   * Branch bottom margin
+   * 分支下边距
+   */
+  INLINE_BLOCKS_PADDING_TOP: "INLINE_BLOCKS_PADDING_TOP"
 };
 
 // src/flow-document-contribution.ts
@@ -1708,6 +1771,13 @@ var FlowDocument = class {
     this.onNodeCreate = this.onNodeCreateEmitter.event;
     this.onNodeDispose = this.onNodeDisposeEmitter.event;
     this.onLayoutChange = this.onLayoutChangeEmitter.event;
+    this._disposed = false;
+  }
+  /**
+   *
+   */
+  get disposed() {
+    return this._disposed;
   }
   init() {
     if (!this.options) this.options = FlowDocumentOptionsDefault;
@@ -1733,6 +1803,7 @@ var FlowDocument = class {
    * @param fireRender 是否要触发渲染，默认 true
    */
   fromJSON(json, fireRender = true) {
+    if (this._disposed) return;
     this.originTree.clear();
     this.renderTree.clear();
     this.entityManager.changeEntityLocked = true;
@@ -1801,7 +1872,7 @@ var FlowDocument = class {
    * @param data
    * @param addedNodes
    */
-  addNode(data, addedNodes, ignoreCreateEvent) {
+  addNode(data, addedNodes) {
     const { id, type = "block", originParent, parent, meta, hidden, index } = data;
     let node = this.getNode(id);
     let isNew = false;
@@ -1819,13 +1890,14 @@ var FlowDocument = class {
         originParent,
         meta
       });
+      this.options.preNodeCreate?.(node);
       const datas = dataRegistries ? this.nodeDataRegistries.concat(...dataRegistries) : this.nodeDataRegistries;
       node.addInitializeData(datas);
       node.onDispose(() => this.onNodeDisposeEmitter.fire({ node }));
-      if (this.options.fromNodeJSON) {
-        this.options.fromNodeJSON(node, data);
-      }
+      this.options.fromNodeJSON?.(node, data, true);
       isNew = true;
+    } else {
+      this.options.fromNodeJSON?.(node, data, false);
     }
     node.initData({
       originParent,
@@ -1837,7 +1909,6 @@ var FlowDocument = class {
     if (node.isStart) {
       this.root.addChild(node);
     }
-    this.onNodeUpdateEmitter.fire({ node, data });
     addedNodes?.push(node);
     if (register.onCreate) {
       const extendNodes = register.onCreate(node, data);
@@ -1851,11 +1922,14 @@ var FlowDocument = class {
         this.addBlocksAsChildren(node, data.blocks, addedNodes);
       }
     }
-    if (isNew && !ignoreCreateEvent) {
+    if (isNew) {
       this.onNodeCreateEmitter.fire({
         node,
-        data
+        data,
+        json: data
       });
+    } else {
+      this.onNodeUpdateEmitter.fire({ node, data, json: data });
     }
     return node;
   }
@@ -1891,18 +1965,16 @@ var FlowDocument = class {
       parent: node
     });
     addedNodes.push(blockIconNode);
-    if (blocks.length > 0) {
-      const inlineBlocksNode = this.addNode({
-        id: `$inlineBlocks$${node.id}`,
-        type: "inlineBlocks" /* INLINE_BLOCKS */,
-        originParent: node,
-        parent: node
-      });
-      addedNodes.push(inlineBlocksNode);
-      blocks.forEach((blockData) => {
-        this.addBlock(node, blockData, addedNodes);
-      });
-    }
+    const inlineBlocksNode = this.addNode({
+      id: `$inlineBlocks$${node.id}`,
+      type: "inlineBlocks" /* INLINE_BLOCKS */,
+      originParent: node,
+      parent: node
+    });
+    addedNodes.push(inlineBlocksNode);
+    blocks.forEach((blockData) => {
+      this.addBlock(node, blockData, addedNodes);
+    });
     return addedNodes;
   }
   /**
@@ -1920,7 +1992,7 @@ var FlowDocument = class {
     }
     parent = parent || this.getNode(`$inlineBlocks$${node.id}`);
     const block = this.addNode({
-      ...(0, import_lodash2.omit)(blockData, "blocks"),
+      ...(0, import_lodash_es2.omit)(blockData, "blocks"),
       type: blockData.type || "block" /* BLOCK */,
       originParent: node,
       parent,
@@ -1967,14 +2039,39 @@ var FlowDocument = class {
         meta: {
           ...preRegistry?.meta,
           ...newRegistry?.meta
-        }
+        },
+        extendChildRegistries: FlowNodeRegistry.mergeChildRegistries(
+          preRegistry?.extendChildRegistries,
+          newRegistry?.extendChildRegistries
+        )
       });
     });
   }
+  /**
+   * Check node extend
+   * @param currentType
+   * @param extendType
+   */
+  isExtend(currentType, extendType) {
+    return (this.getNodeRegistry(currentType).__extends__ || []).includes(extendType);
+  }
+  /**
+   * Check node type
+   * @param currentType
+   * @param extendType
+   */
+  isTypeOrExtendType(currentType, extendType) {
+    return currentType === extendType || this.isExtend(currentType, extendType);
+  }
   /**
    * 导出数据，可以重载
    */
   toJSON() {
+    if (this.disposed) {
+      throw new Error(
+        "The FlowDocument has been disposed and it is no longer possible to call toJSON."
+      );
+    }
     return {
       nodes: this.root.toJSON().blocks
     };
@@ -1994,6 +2091,7 @@ var FlowDocument = class {
     const customDefaultRegistry = this.options.getNodeDefaultRegistry?.(type);
     let register = this.registers.get(type) || { type };
     const extendRegisters = [];
+    const extendKey = register.extend;
     if (register.extend && this.registers.has(register.extend)) {
       register = FlowNodeRegistry.merge(
         this.getNodeRegistry(register.extend),
@@ -2024,6 +2122,9 @@ var FlowDocument = class {
         ...register.meta
       }
     };
+    if (extendKey) {
+      res.extend = extendKey;
+    }
     this.nodeRegistryCache.set(typeKey, res);
     return res;
   }
@@ -2074,8 +2175,8 @@ var FlowDocument = class {
   getAllNodes() {
     return this.entityManager.getEntities(FlowNodeEntity);
   }
-  toString() {
-    return this.originTree.toString();
+  toString(showType) {
+    return this.originTree.toString(showType);
   }
   /**
    * 返回需要渲染的数据
@@ -2088,6 +2189,39 @@ var FlowDocument = class {
     });
     return result;
   }
+  toNodeJSON(node) {
+    if (this.options.toNodeJSON) {
+      return this.options.toNodeJSON(node);
+    }
+    const nodesMap = {};
+    let startNodeJSON;
+    this.traverse((node2) => {
+      const isSystemNode = node2.id.startsWith("$");
+      if (isSystemNode) return;
+      const nodeJSONData = node2.getJSONData();
+      const nodeJSON = {
+        id: node2.id,
+        type: node2.flowNodeType
+      };
+      if (nodeJSONData !== void 0) {
+        nodeJSON.data = nodeJSONData;
+      }
+      if (!startNodeJSON) startNodeJSON = nodeJSON;
+      let { parent } = node2;
+      if (parent && parent.id.startsWith("$")) {
+        parent = parent.originParent;
+      }
+      const parentJSON = parent ? nodesMap[parent.id] : void 0;
+      if (parentJSON) {
+        if (!parentJSON.blocks) {
+          parentJSON.blocks = [];
+        }
+        parentJSON.blocks.push(nodeJSON);
+      }
+      nodesMap[node2.id] = nodeJSON;
+    }, node);
+    return startNodeJSON;
+  }
   /**
    * 移动节点
    * @param param0
@@ -2170,6 +2304,7 @@ var FlowDocument = class {
     );
   }
   dispose() {
+    if (this._disposed) return;
     this.registers.clear();
     this.nodeRegistryCache.clear();
     this.originTree.dispose();
@@ -2178,6 +2313,7 @@ var FlowDocument = class {
     this.onNodeCreateEmitter.dispose();
     this.onNodeDisposeEmitter.dispose();
     this.onLayoutChangeEmitter.dispose();
+    this._disposed = true;
   }
 };
 __decorateClass([
@@ -2205,113 +2341,427 @@ FlowDocument = __decorateClass([
 var import_inversify8 = require("inversify");
 
 // src/services/flow-drag-service.ts
-var import_inversify5 = require("inversify");
-var import_core10 = require("@flowgram.ai/core");
-var import_utils9 = require("@flowgram.ai/utils");
-
-// src/services/flow-operation-base-service.ts
 var import_inversify3 = require("inversify");
 var import_utils8 = require("@flowgram.ai/utils");
 var import_core8 = require("@flowgram.ai/core");
-var FlowOperationBaseServiceImpl = class {
-  constructor() {
-    this.onNodeAddEmitter = new import_utils8.Emitter();
-    this.onNodeAdd = this.onNodeAddEmitter.event;
-    this.toDispose = new import_utils8.DisposableCollection();
+
+// src/services/flow-group-service/flow-group-controller.ts
+var FlowGroupController = class _FlowGroupController {
+  constructor(groupNode) {
+    this.groupNode = groupNode;
   }
-  init() {
-    this.toDispose.push(this.onNodeAddEmitter);
+  get nodes() {
+    return this.groupNode.collapsedChildren || [];
   }
-  addNode(nodeJSON, config = {}) {
-    const { parent, index, hidden } = config;
-    let parentEntity;
-    if (parent) {
-      parentEntity = this.toNodeEntity(parent);
+  get collapsed() {
+    const groupTransformData = this.groupNode.getData(FlowNodeTransformData);
+    return groupTransformData.collapsed;
+  }
+  collapse() {
+    this.collapsed = true;
+  }
+  expand() {
+    this.collapsed = false;
+  }
+  /** 获取分组外围的最大边框 */
+  get bounds() {
+    const groupNodeBounds = this.groupNode.getData(FlowNodeTransformData).bounds;
+    return groupNodeBounds;
+  }
+  /** 是否是开始节点 */
+  isStartNode(node) {
+    if (!node) {
+      return false;
     }
-    let register;
-    if (parentEntity) {
-      register = parentEntity.getNodeRegistry();
+    const nodes = this.nodes;
+    if (!nodes[0]) {
+      return false;
     }
-    const addJSON = {
-      ...nodeJSON,
-      type: nodeJSON.type || "block" /* BLOCK */
-    };
-    const addNodeData = {
-      ...addJSON,
-      parent: parentEntity,
-      index,
-      hidden
-    };
-    let added;
-    if (parentEntity && register?.addChild) {
-      added = register.addChild(parentEntity, addJSON, {
-        index,
-        hidden
-      });
-    } else {
-      added = this.document.addNode(addNodeData);
+    return node.id === nodes[0].id;
+  }
+  /** 是否是结束节点 */
+  isEndNode(node) {
+    if (!node) {
+      return false;
     }
-    this.onNodeAddEmitter.fire({
-      node: added,
-      data: addNodeData
-    });
-    return added;
+    const nodes = this.nodes;
+    if (!nodes[nodes.length - 1]) {
+      return false;
+    }
+    return node.id === nodes[nodes.length - 1].id;
   }
-  addFromNode(fromNode, nodeJSON) {
-    return this.document.addFromNode(fromNode, nodeJSON);
+  set note(note) {
+    this.groupNode.getNodeMeta().note = note;
   }
-  deleteNode(node) {
-    this.document.removeNode(node);
+  get note() {
+    return this.groupNode.getNodeMeta().note || "";
   }
-  deleteNodes(nodes) {
-    (nodes || []).forEach((node) => {
-      this.deleteNode(node);
-    });
+  set noteHeight(height) {
+    this.groupNode.getNodeMeta().noteHeight = height;
   }
-  addBlock(target, blockJSON, config = {}) {
-    const { parent, index } = config;
-    return this.document.addBlock(target, blockJSON, void 0, parent, index);
+  get noteHeight() {
+    return this.groupNode.getNodeMeta().noteHeight || 0;
   }
-  moveNode(node, config = {}) {
-    const { parent: newParent, index } = config;
-    const entity = this.toNodeEntity(node);
-    const parent = entity?.parent;
-    if (!parent) {
-      return;
+  get positionConfig() {
+    return this.groupNode.getNodeMeta().positionConfig;
+  }
+  set collapsed(collapsed) {
+    const groupTransformData = this.groupNode.getData(FlowNodeTransformData);
+    groupTransformData.collapsed = collapsed;
+    groupTransformData.localDirty = true;
+    if (groupTransformData.parent) groupTransformData.parent.localDirty = true;
+    if (groupTransformData.parent?.firstChild)
+      groupTransformData.parent.firstChild.localDirty = true;
+  }
+  set hovered(hovered) {
+    const groupRenderData = this.groupNode.getData(FlowNodeRenderData);
+    if (hovered) {
+      groupRenderData.toggleMouseEnter();
+    } else {
+      groupRenderData.toggleMouseLeave();
     }
-    const newParentEntity = newParent ? this.toNodeEntity(newParent) : parent;
-    if (!newParentEntity) {
-      console.warn("no new parent found", newParent);
+    if (groupRenderData.hovered === hovered) {
       return;
     }
-    let toIndex = typeof index === "undefined" ? parent.children.length : index;
-    return this.doMoveNode(entity, newParentEntity, toIndex);
+    groupRenderData.hovered = hovered;
   }
-  /**
-   * 拖拽节点
-   * @param param0
-   * @returns
-   */
-  dragNodes({ dropNode, nodes }) {
-    if (nodes.length === 0) {
+  get hovered() {
+    const groupRenderData = this.groupNode.getData(FlowNodeRenderData);
+    return groupRenderData.hovered;
+  }
+  static create(groupNode) {
+    if (!groupNode) {
       return;
     }
-    const startNode = nodes[0];
-    const fromParent = startNode.parent;
-    const toParent = dropNode.parent;
-    if (!fromParent || !toParent) {
+    if (!FlowGroupUtils.isGroupNode(groupNode)) {
       return;
     }
-    const fromIndex = fromParent.children.findIndex((child) => child === startNode);
-    const dropIndex = toParent.children.findIndex((child) => child === dropNode);
-    let toIndex = dropIndex + 1;
-    if (fromParent === toParent && fromIndex < dropIndex) {
-      toIndex = toIndex - nodes.length;
-    }
-    const value = {
-      nodeIds: nodes.map((node) => node.id),
-      fromParentId: fromParent.id,
-      toParentId: toParent.id,
+    return new _FlowGroupController(groupNode);
+  }
+};
+
+// src/services/flow-group-service/flow-group-utils.ts
+var FlowGroupUtils;
+((FlowGroupUtils2) => {
+  const findNodeParents = (node) => {
+    const parents = [];
+    let parent = node.parent;
+    while (parent) {
+      parents.push(parent);
+      parent = parent.parent;
+    }
+    return parents;
+  };
+  const isNodeInGroup = (node) => {
+    if (node?.parent?.flowNodeType === "group" /* GROUP */) {
+      return true;
+    }
+    return false;
+  };
+  FlowGroupUtils2.validate = (nodes) => {
+    if (!nodes || !Array.isArray(nodes) || nodes.length === 0) {
+      return false;
+    }
+    const isGroupRelatedNode = nodes.some((node) => (0, FlowGroupUtils2.isGroupNode)(node));
+    if (isGroupRelatedNode) return false;
+    const hasGroup = nodes.some((node) => node && isNodeInGroup(node));
+    if (hasGroup) return false;
+    const parent = nodes[0].parent;
+    const isSameParent = nodes.every((node) => node.parent === parent);
+    if (!isSameParent) return false;
+    const indexes = nodes.map((node) => node.index).sort((a, b) => a - b);
+    const isIndexContinuous = indexes.every((index, i, arr) => {
+      if (i === 0) {
+        return true;
+      }
+      return index === arr[i - 1] + 1;
+    });
+    if (!isIndexContinuous) return false;
+    const parents = findNodeParents(nodes[0]);
+    const parentsInGroup = parents.some((parent2) => isNodeInGroup(parent2));
+    if (parentsInGroup) return false;
+    return true;
+  };
+  FlowGroupUtils2.getNodeGroupController = (node) => {
+    if (!node) {
+      return;
+    }
+    if (!isNodeInGroup(node)) {
+      return;
+    }
+    const groupNode = node?.parent;
+    return FlowGroupController.create(groupNode);
+  };
+  FlowGroupUtils2.getNodeRecursionGroupController = (node) => {
+    if (!node) {
+      return;
+    }
+    const group = (0, FlowGroupUtils2.getNodeGroupController)(node);
+    if (group) {
+      return group;
+    }
+    if (node.parent) {
+      return (0, FlowGroupUtils2.getNodeRecursionGroupController)(node.parent);
+    }
+    return;
+  };
+  FlowGroupUtils2.isGroupNode = (group) => group.flowNodeType === "group" /* GROUP */;
+})(FlowGroupUtils || (FlowGroupUtils = {}));
+
+// src/services/flow-drag-service.ts
+var FlowDragService = class {
+  constructor() {
+    this.onDropEmitter = new import_utils8.Emitter();
+    this.onDrop = this.onDropEmitter.event;
+  }
+  get renderState() {
+    return this.document.renderState;
+  }
+  // 拖拽所有节点中的首个节点
+  get dragStartNode() {
+    return this.renderState.getDragStartEntity();
+  }
+  // 拖拽的所有节点
+  get dragNodes() {
+    return this.renderState.getDragEntities();
+  }
+  // 放置的区域
+  get dropNodeId() {
+    return this.renderState.getNodeDroppingId();
+  }
+  // 是否在拖拽分支
+  get isDragBranch() {
+    return this.renderState.isBranch || this.dragStartNode?.isInlineBlock;
+  }
+  // 拖拽的所有节点及其自节点
+  get nodeDragIdsWithChildren() {
+    return this.renderState.config.nodeDragIdsWithChildren || [];
+  }
+  get dragging() {
+    return !!this.renderState.dragging;
+  }
+  get labelSide() {
+    return this.renderState.config.dragLabelSide;
+  }
+  /**
+   * 放置到目标分支
+   */
+  dropBranch() {
+    this.dropNode();
+  }
+  /**
+   * 移动并且创建节点
+   * Move and create node
+   */
+  async dropCreateNode(json, onCreateNode) {
+    const dropEntity = this.document.getNode(this.dropNodeId);
+    if (!dropEntity) {
+      return;
+    }
+    if (json) {
+      const dragNodes = await onCreateNode?.(json, dropEntity);
+      this.onDropEmitter.fire({
+        dropNode: dropEntity,
+        dragNodes: dragNodes ? [dragNodes] : [],
+        dragJSON: json
+      });
+    }
+  }
+  /**
+   * 移动到目标节点
+   */
+  dropNode() {
+    const dropEntity = this.document.getNode(this.dropNodeId);
+    if (!dropEntity) {
+      return;
+    }
+    const sortNodes = [];
+    let curr = this.dragStartNode;
+    while (curr && this.dragNodes.includes(curr)) {
+      sortNodes.push(curr);
+      curr = curr.next;
+    }
+    this.operationService.dragNodes({
+      dropNode: dropEntity,
+      nodes: sortNodes
+    });
+    if (sortNodes.length > 0) {
+      this.onDropEmitter.fire({
+        dropNode: dropEntity,
+        dragNodes: sortNodes
+      });
+    }
+  }
+  /**
+   * 拖拽是否可以释放在该节点后面
+   */
+  isDroppableNode(node) {
+    if (!this.dragging || this.isDragBranch) {
+      return false;
+    }
+    if (this.nodeDragIdsWithChildren.includes(node.id) || node.next && this.nodeDragIdsWithChildren.includes(node.next.id)) {
+      return false;
+    }
+    if (node.isInlineBlocks || node.isInlineBlock) {
+      return false;
+    }
+    const hasGroupNode = this.dragNodes.some(
+      (node2) => node2.flowNodeType === "group" /* GROUP */
+    );
+    if (hasGroupNode) {
+      const group = FlowGroupUtils.getNodeRecursionGroupController(node);
+      if (group) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * 拖拽分支是否可以释放在该分支
+   * @param node 拖拽的分支节点
+   * @param side 分支的前面还是后面
+   */
+  isDroppableBranch(node, side = "normal_branch" /* NORMAL_BRANCH */) {
+    if (this.renderState.isBranch) {
+      return true;
+    }
+    if (this.isDragBranch) {
+      if (
+        // 拖拽到分支
+        !node.isInlineBlock || // 只能在同一分支条件下
+        node.parent !== this.dragStartNode.parent || // 自己不能拖拽给自己
+        node === this.dragStartNode
+      ) {
+        return false;
+      }
+      if (side === "normal_branch" /* NORMAL_BRANCH */ && node.next !== this.dragStartNode) {
+        return true;
+      }
+      if (side === "pre_branch" /* PRE_BRANCH */ && node.pre !== this.dragStartNode) {
+        return true;
+      }
+    }
+    return false;
+  }
+};
+__decorateClass([
+  (0, import_inversify3.inject)(FlowDocument)
+], FlowDragService.prototype, "document", 2);
+__decorateClass([
+  (0, import_inversify3.inject)(FlowOperationBaseService)
+], FlowDragService.prototype, "operationService", 2);
+__decorateClass([
+  (0, import_inversify3.inject)(import_core8.EntityManager)
+], FlowDragService.prototype, "entityManager", 2);
+FlowDragService = __decorateClass([
+  (0, import_inversify3.injectable)()
+], FlowDragService);
+
+// src/services/flow-operation-base-service.ts
+var import_inversify4 = require("inversify");
+var import_utils9 = require("@flowgram.ai/utils");
+var import_core9 = require("@flowgram.ai/core");
+var FlowOperationBaseServiceImpl = class {
+  constructor() {
+    this.onNodeAddEmitter = new import_utils9.Emitter();
+    this.onNodeAdd = this.onNodeAddEmitter.event;
+    this.toDispose = new import_utils9.DisposableCollection();
+    this.onNodeMoveEmitter = new import_utils9.Emitter();
+    this.onNodeMove = this.onNodeMoveEmitter.event;
+  }
+  init() {
+    this.toDispose.pushAll([this.onNodeAddEmitter, this.onNodeMoveEmitter]);
+  }
+  addNode(nodeJSON, config = {}) {
+    const { parent, index, hidden } = config;
+    let parentEntity;
+    if (parent) {
+      parentEntity = this.toNodeEntity(parent);
+    }
+    let register;
+    if (parentEntity) {
+      register = parentEntity.getNodeRegistry();
+    }
+    const addJSON = {
+      ...nodeJSON,
+      type: nodeJSON.type || "block" /* BLOCK */
+    };
+    const addNodeData = {
+      ...addJSON,
+      parent: parentEntity,
+      index,
+      hidden
+    };
+    let added;
+    if (parentEntity && register?.addChild) {
+      added = register.addChild(parentEntity, addJSON, {
+        index,
+        hidden
+      });
+    } else {
+      added = this.document.addNode(addNodeData);
+    }
+    this.onNodeAddEmitter.fire({
+      node: added,
+      data: addNodeData
+    });
+    return added;
+  }
+  addFromNode(fromNode, nodeJSON) {
+    return this.document.addFromNode(fromNode, nodeJSON);
+  }
+  deleteNode(node) {
+    this.document.removeNode(node);
+  }
+  deleteNodes(nodes) {
+    (nodes || []).forEach((node) => {
+      this.deleteNode(node);
+    });
+  }
+  addBlock(target, blockJSON, config = {}) {
+    const { parent, index } = config;
+    return this.document.addBlock(target, blockJSON, void 0, parent, index);
+  }
+  moveNode(node, config = {}) {
+    const { parent: newParent, index } = config;
+    const entity = this.toNodeEntity(node);
+    const parent = entity?.parent;
+    if (!parent) {
+      return;
+    }
+    const newParentEntity = newParent ? this.toNodeEntity(newParent) : parent;
+    if (!newParentEntity) {
+      console.warn("no new parent found", newParent);
+      return;
+    }
+    let toIndex = typeof index === "undefined" ? newParentEntity.collapsedChildren.length : index;
+    return this.doMoveNode(entity, newParentEntity, toIndex);
+  }
+  /**
+   * 拖拽节点
+   * @param param0
+   * @returns
+   */
+  dragNodes({ dropNode, nodes }) {
+    if (nodes.length === 0) {
+      return;
+    }
+    const startNode = nodes[0];
+    const fromParent = startNode.parent;
+    const toParent = dropNode.parent;
+    if (!fromParent || !toParent) {
+      return;
+    }
+    const fromIndex = fromParent.children.findIndex((child) => child === startNode);
+    const dropIndex = toParent.children.findIndex((child) => child === dropNode);
+    let toIndex = dropIndex + 1;
+    if (fromParent === toParent && fromIndex < dropIndex) {
+      toIndex = toIndex - nodes.length;
+    }
+    const value = {
+      nodeIds: nodes.map((node) => node.id),
+      fromParentId: fromParent.id,
+      toParentId: toParent.id,
       fromIndex,
       toIndex
     };
@@ -2426,420 +2876,140 @@ var FlowOperationBaseServiceImpl = class {
     return typeof node === "string" ? node : node.id;
   }
   toNodeEntity(node) {
-    return typeof node === "string" ? this.document.getNode(node) : node;
-  }
-  getNodeIndex(node) {
-    const entity = this.toNodeEntity(node);
-    const parent = entity?.parent;
-    if (!parent) {
-      return -1;
-    }
-    return parent.children.findIndex((child) => child === entity);
-  }
-  doMoveNode(node, newParent, index) {
-    return this.document.moveChildNodes({
-      nodeIds: [this.toId(node)],
-      toParentId: this.toId(newParent),
-      toIndex: index
-    });
-  }
-};
-__decorateClass([
-  (0, import_inversify3.inject)(import_core8.EntityManager)
-], FlowOperationBaseServiceImpl.prototype, "entityManager", 2);
-__decorateClass([
-  (0, import_inversify3.inject)(FlowDocument)
-], FlowOperationBaseServiceImpl.prototype, "document", 2);
-__decorateClass([
-  (0, import_inversify3.postConstruct)()
-], FlowOperationBaseServiceImpl.prototype, "init", 1);
-FlowOperationBaseServiceImpl = __decorateClass([
-  (0, import_inversify3.injectable)()
-], FlowOperationBaseServiceImpl);
-
-// src/services/flow-group-service.ts
-var import_nanoid = require("nanoid");
-var import_inversify4 = require("inversify");
-var import_core9 = require("@flowgram.ai/core");
-var FlowGroupService = class {
-  /** 创建分组节点 */
-  createGroup(nodes) {
-    if (!nodes || !Array.isArray(nodes) || nodes.length === 0) {
-      return;
-    }
-    if (!FlowGroupController.validate(nodes)) {
-      return;
-    }
-    const sortedNodes = nodes.sort((a, b) => a.index - b.index);
-    const fromNode = sortedNodes[0];
-    const groupId = `group_${(0, import_nanoid.nanoid)(5)}`;
-    this.operationService.apply({
-      type: "createGroup" /* createGroup */,
-      value: {
-        targetId: fromNode.id,
-        groupId,
-        nodeIds: nodes.map((node) => node.id)
-      }
-    });
-    const groupNode = this.entityManager.getEntityById(groupId);
-    if (!groupNode) {
-      return;
-    }
-    const group = this.groupController(groupNode);
-    if (!group) {
-      return;
-    }
-    group.expand();
-    return groupNode;
-  }
-  /** 删除分组 */
-  deleteGroup(groupNode) {
-    const json = groupNode.toJSON();
-    if (!groupNode.pre || !json) {
-      return;
-    }
-    this.operationService.apply({
-      type: "deleteNodes" /* deleteNodes */,
-      value: {
-        fromId: groupNode.pre.id,
-        nodes: [json]
-      }
-    });
-  }
-  /** 取消分组 */
-  ungroup(groupNode) {
-    const group = this.groupController(groupNode);
-    if (!group) {
-      return;
-    }
-    const nodes = group.nodes;
-    if (!groupNode.pre) {
-      return;
-    }
-    group.collapse();
-    this.operationService.apply({
-      type: "ungroup" /* ungroup */,
-      value: {
-        groupId: groupNode.id,
-        targetId: groupNode.pre.id,
-        nodeIds: nodes.map((node) => node.id)
-      }
-    });
-  }
-  /** 返回所有分组节点 */
-  getAllGroups() {
-    const allNodes = this.entityManager.getEntities(FlowNodeEntity);
-    const groupNodes = allNodes.filter((node) => node.flowNodeType === "group" /* GROUP */);
-    return groupNodes.map((node) => this.groupController(node)).filter(Boolean);
-  }
-  /** 获取分组控制器*/
-  groupController(group) {
-    return FlowGroupController.create(group);
-  }
-  static validate(nodes) {
-    return FlowGroupController.validate(nodes);
-  }
-};
-__decorateClass([
-  (0, import_inversify4.inject)(import_core9.EntityManager)
-], FlowGroupService.prototype, "entityManager", 2);
-__decorateClass([
-  (0, import_inversify4.inject)(FlowOperationBaseService)
-], FlowGroupService.prototype, "operationService", 2);
-FlowGroupService = __decorateClass([
-  (0, import_inversify4.injectable)()
-], FlowGroupService);
-var FlowGroupController = class _FlowGroupController {
-  constructor(groupNode) {
-    this.groupNode = groupNode;
-  }
-  get nodes() {
-    return this.groupNode.collapsedChildren || [];
-  }
-  get collapsed() {
-    const groupTransformData = this.groupNode.getData(FlowNodeTransformData);
-    return groupTransformData.collapsed;
-  }
-  collapse() {
-    this.collapsed = true;
-  }
-  expand() {
-    this.collapsed = false;
-  }
-  /** 获取分组外围的最大边框 */
-  get bounds() {
-    const groupNodeBounds = this.groupNode.getData(FlowNodeTransformData).bounds;
-    return groupNodeBounds;
-  }
-  /** 是否是开始节点 */
-  isStartNode(node) {
-    if (!node) {
-      return false;
-    }
-    const nodes = this.nodes;
-    if (!nodes[0]) {
-      return false;
-    }
-    return node.id === nodes[0].id;
-  }
-  /** 是否是结束节点 */
-  isEndNode(node) {
-    if (!node) {
-      return false;
-    }
-    const nodes = this.nodes;
-    if (!nodes[nodes.length - 1]) {
-      return false;
-    }
-    return node.id === nodes[nodes.length - 1].id;
-  }
-  set note(note) {
-    this.groupNode.getNodeMeta().note = note;
-  }
-  get note() {
-    return this.groupNode.getNodeMeta().note || "";
-  }
-  set noteHeight(height) {
-    this.groupNode.getNodeMeta().noteHeight = height;
-  }
-  get noteHeight() {
-    return this.groupNode.getNodeMeta().noteHeight || 0;
-  }
-  get positionConfig() {
-    return this.groupNode.getNodeMeta().positionConfig;
-  }
-  set collapsed(collapsed) {
-    const groupTransformData = this.groupNode.getData(FlowNodeTransformData);
-    groupTransformData.collapsed = collapsed;
-    groupTransformData.localDirty = true;
-    if (groupTransformData.parent) groupTransformData.parent.localDirty = true;
-    if (groupTransformData.parent?.firstChild)
-      groupTransformData.parent.firstChild.localDirty = true;
+    return typeof node === "string" ? this.document.getNode(node) : node;
   }
-  set hovered(hovered) {
-    const groupRenderData = this.groupNode.getData(FlowNodeRenderData);
-    if (hovered) {
-      groupRenderData.toggleMouseEnter();
-    } else {
-      groupRenderData.toggleMouseLeave();
-    }
-    if (groupRenderData.hovered === hovered) {
-      return;
+  getNodeIndex(node) {
+    const entity = this.toNodeEntity(node);
+    const parent = entity?.parent;
+    if (!parent) {
+      return -1;
     }
-    groupRenderData.hovered = hovered;
+    return parent.children.findIndex((child) => child === entity);
   }
-  get hovered() {
-    const groupRenderData = this.groupNode.getData(FlowNodeRenderData);
-    return groupRenderData.hovered;
+  doMoveNode(node, newParent, index) {
+    if (!node.parent) {
+      throw new Error("root node cannot move");
+    }
+    const event = {
+      node,
+      fromParent: node.parent,
+      toParent: newParent,
+      fromIndex: this.getNodeIndex(node),
+      toIndex: index
+    };
+    this.document.moveChildNodes({
+      nodeIds: [this.toId(node)],
+      toParentId: this.toId(newParent),
+      toIndex: index
+    });
+    this.onNodeMoveEmitter.fire(event);
   }
-  static create(groupNode) {
-    if (!groupNode) {
+};
+__decorateClass([
+  (0, import_inversify4.inject)(import_core9.EntityManager)
+], FlowOperationBaseServiceImpl.prototype, "entityManager", 2);
+__decorateClass([
+  (0, import_inversify4.inject)(FlowDocument)
+], FlowOperationBaseServiceImpl.prototype, "document", 2);
+__decorateClass([
+  (0, import_inversify4.postConstruct)()
+], FlowOperationBaseServiceImpl.prototype, "init", 1);
+FlowOperationBaseServiceImpl = __decorateClass([
+  (0, import_inversify4.injectable)()
+], FlowOperationBaseServiceImpl);
+
+// src/services/flow-group-service/flow-group-service.ts
+var import_nanoid = require("nanoid");
+var import_inversify5 = require("inversify");
+var import_core10 = require("@flowgram.ai/core");
+var FlowGroupService = class {
+  /** 创建分组节点 */
+  createGroup(nodes) {
+    if (!nodes || !Array.isArray(nodes) || nodes.length === 0) {
       return;
     }
-    if (!_FlowGroupController.isGroupNode(groupNode)) {
+    if (!FlowGroupUtils.validate(nodes)) {
       return;
     }
-    return new _FlowGroupController(groupNode);
-  }
-  /** 判断节点能否组成分组 */
-  static validate(nodes) {
-    if (!nodes || !Array.isArray(nodes) || nodes.length === 0) {
-      return false;
-    }
-    const isGroupRelatedNode = nodes.some((node) => _FlowGroupController.isGroupNode(node));
-    if (isGroupRelatedNode) return false;
-    const hasGroup = nodes.some((node) => node && this.isNodeInGroup(node));
-    if (hasGroup) return false;
-    const parent = nodes[0].parent;
-    const isSameParent = nodes.every((node) => node.parent === parent);
-    if (!isSameParent) return false;
-    const indexes = nodes.map((node) => node.index).sort((a, b) => a - b);
-    const isIndexContinuous = indexes.every((index, i, arr) => {
-      if (i === 0) {
-        return true;
+    const sortedNodes = nodes.sort((a, b) => a.index - b.index);
+    const fromNode = sortedNodes[0];
+    const groupId = `group_${(0, import_nanoid.nanoid)(5)}`;
+    this.operationService.apply({
+      type: "createGroup" /* createGroup */,
+      value: {
+        targetId: fromNode.id,
+        groupId,
+        nodeIds: nodes.map((node) => node.id)
       }
-      return index === arr[i - 1] + 1;
     });
-    if (!isIndexContinuous) return false;
-    const parents = this.findNodeParents(nodes[0]);
-    const parentsInGroup = parents.some((parent2) => this.isNodeInGroup(parent2));
-    if (parentsInGroup) return false;
-    return true;
-  }
-  /** 获取节点分组控制 */
-  static getNodeGroupController(node) {
-    if (!node) {
+    const groupNode = this.entityManager.getEntityById(groupId);
+    if (!groupNode) {
       return;
     }
-    if (!this.isNodeInGroup(node)) {
+    const group = this.groupController(groupNode);
+    if (!group) {
       return;
     }
-    const groupNode = node?.parent;
-    return _FlowGroupController.create(groupNode);
+    group.expand();
+    return groupNode;
   }
-  /** 向上递归查找分组递归控制 */
-  static getNodeRecursionGroupController(node) {
-    if (!node) {
+  /** 删除分组 */
+  deleteGroup(groupNode) {
+    const json = groupNode.toJSON();
+    if (!groupNode.pre || !json) {
       return;
     }
-    const group = this.getNodeGroupController(node);
-    if (group) {
-      return group;
-    }
-    if (node.parent) {
-      return this.getNodeRecursionGroupController(node.parent);
-    }
-    return;
-  }
-  /** 是否分组节点 */
-  static isGroupNode(group) {
-    return group.flowNodeType === "group" /* GROUP */;
-  }
-  /** 找到节点所有上级 */
-  static findNodeParents(node) {
-    const parents = [];
-    let parent = node.parent;
-    while (parent) {
-      parents.push(parent);
-      parent = parent.parent;
-    }
-    return parents;
-  }
-  /** 节点是否处于分组中 */
-  static isNodeInGroup(node) {
-    if (node?.parent?.flowNodeType === "group" /* GROUP */) {
-      return true;
-    }
-    return false;
-  }
-};
-
-// src/services/flow-drag-service.ts
-var FlowDragService = class {
-  constructor() {
-    this.onDropEmitter = new import_utils9.Emitter();
-    this.onDrop = this.onDropEmitter.event;
-  }
-  get renderState() {
-    return this.document.renderState;
-  }
-  // 拖拽所有节点中的首个节点
-  get dragStartNode() {
-    return this.renderState.getDragStartEntity();
-  }
-  // 拖拽的所有节点
-  get dragNodes() {
-    return this.renderState.getDragEntities();
-  }
-  // 放置的区域
-  get dropNodeId() {
-    return this.renderState.getNodeDroppingId();
-  }
-  // 是否在拖拽分支
-  get isDragBranch() {
-    return this.dragStartNode?.isInlineBlock;
-  }
-  // 拖拽的所有节点及其自节点
-  get nodeDragIdsWithChildren() {
-    return this.renderState.config.nodeDragIdsWithChildren || [];
-  }
-  get dragging() {
-    const renderData = this.dragStartNode?.getData(FlowNodeRenderData);
-    return !!renderData?.dragging;
-  }
-  get labelSide() {
-    return this.renderState.config.dragLabelSide;
-  }
-  /**
-   * 放置到目标分支
-   */
-  dropBranch() {
-    this.dropNode();
+    this.operationService.apply({
+      type: "deleteNodes" /* deleteNodes */,
+      value: {
+        fromId: groupNode.pre.id,
+        nodes: [json]
+      }
+    });
   }
-  /**
-   * 移动到目标节点
-   */
-  dropNode() {
-    const dropEntity = this.document.getNode(this.dropNodeId);
-    if (!dropEntity) {
+  /** 取消分组 */
+  ungroup(groupNode) {
+    const group = this.groupController(groupNode);
+    if (!group) {
       return;
     }
-    const sortNodes = [];
-    let curr = this.dragStartNode;
-    while (curr && this.dragNodes.includes(curr)) {
-      sortNodes.push(curr);
-      curr = curr.next;
+    const nodes = group.nodes;
+    if (!groupNode.pre) {
+      return;
     }
-    this.operationService.dragNodes({
-      dropNode: dropEntity,
-      nodes: sortNodes
+    group.collapse();
+    this.operationService.apply({
+      type: "ungroup" /* ungroup */,
+      value: {
+        groupId: groupNode.id,
+        targetId: groupNode.pre.id,
+        nodeIds: nodes.map((node) => node.id)
+      }
     });
-    if (sortNodes.length > 0) {
-      this.onDropEmitter.fire({
-        dropNode: dropEntity,
-        dragNodes: sortNodes
-      });
-    }
   }
-  /**
-   * 拖拽是否可以释放在该节点后面
-   */
-  isDroppableNode(node) {
-    if (!this.dragging || this.isDragBranch) {
-      return false;
-    }
-    if (this.nodeDragIdsWithChildren.includes(node.id) || node.next && this.nodeDragIdsWithChildren.includes(node.next.id)) {
-      return false;
-    }
-    if (node.isInlineBlocks || node.isInlineBlock) {
-      return false;
-    }
-    const hasGroupNode = this.dragNodes.some((node2) => node2.flowNodeType === "group" /* GROUP */);
-    if (hasGroupNode) {
-      const group = FlowGroupController.getNodeRecursionGroupController(node);
-      if (group) {
-        return false;
-      }
-    }
-    return true;
+  /** 返回所有分组节点 */
+  getAllGroups() {
+    const allNodes = this.entityManager.getEntities(FlowNodeEntity);
+    const groupNodes = allNodes.filter((node) => node.flowNodeType === "group" /* GROUP */);
+    return groupNodes.map((node) => this.groupController(node)).filter(Boolean);
   }
-  /**
-   * 拖拽分支是否可以释放在该分支
-   * @param node 拖拽的分支节点
-   * @param side 分支的前面还是后面
-   */
-  isDroppableBranch(node, side = "normal_branch" /* NORMAL_BRANCH */) {
-    if (this.isDragBranch) {
-      if (
-        // 拖拽到分支
-        !node.isInlineBlock || // 只能在同一分支条件下
-        node.parent !== this.dragStartNode.parent || // 自己不能拖拽给自己
-        node === this.dragStartNode
-      ) {
-        return false;
-      }
-      if (side === "normal_branch" /* NORMAL_BRANCH */ && node.next !== this.dragStartNode) {
-        return true;
-      }
-      if (side === "pre_branch" /* PRE_BRANCH */ && node.pre !== this.dragStartNode) {
-        return true;
-      }
-    }
-    return false;
+  /** 获取分组控制器*/
+  groupController(group) {
+    return FlowGroupController.create(group);
+  }
+  static validate(nodes) {
+    return FlowGroupUtils.validate(nodes);
   }
 };
 __decorateClass([
-  (0, import_inversify5.inject)(FlowDocument)
-], FlowDragService.prototype, "document", 2);
+  (0, import_inversify5.inject)(import_core10.EntityManager)
+], FlowGroupService.prototype, "entityManager", 2);
 __decorateClass([
   (0, import_inversify5.inject)(FlowOperationBaseService)
-], FlowDragService.prototype, "operationService", 2);
-__decorateClass([
-  (0, import_inversify5.inject)(import_core10.EntityManager)
-], FlowDragService.prototype, "entityManager", 2);
-FlowDragService = __decorateClass([
+], FlowGroupService.prototype, "operationService", 2);
+FlowGroupService = __decorateClass([
   (0, import_inversify5.injectable)()
-], FlowDragService);
+], FlowGroupService);
 
 // src/layout/vertical-fixed-layout.ts
 var import_inversify6 = require("inversify");