@flowgram.ai/document 0.1.0-alpha.7 → 0.1.0-alpha.9

package/dist/index.js

@@ -85,11 +85,17 @@ 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";
   return FlowNodeBaseType2;
 })(FlowNodeBaseType || {});
 var FlowNodeSplitType = /* @__PURE__ */ ((FlowNodeSplitType2) => {
+  FlowNodeSplitType2["SIMPLE_SPLIT"] = "simpleSplit";
   FlowNodeSplitType2["DYNAMIC_SPLIT"] = "dynamicSplit";
   FlowNodeSplitType2["STATIC_SPLIT"] = "staticSplit";
   return FlowNodeSplitType2;
@@ -233,13 +239,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;
@@ -1448,13 +1478,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")}`;
@@ -1720,6 +1752,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;
@@ -1745,6 +1784,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;
@@ -1813,7 +1853,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;
@@ -1834,10 +1874,10 @@ var FlowDocument = class {
       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,
@@ -1849,7 +1889,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);
@@ -1863,11 +1902,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;
   }
@@ -1903,18 +1945,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;
   }
   /**
@@ -1979,10 +2019,22 @@ var FlowDocument = class {
         meta: {
           ...preRegistry?.meta,
           ...newRegistry?.meta
-        }
+        },
+        extendChildRegistries: FlowNodeRegistry.mergeChildRegistries(
+          preRegistry?.extendChildRegistries,
+          newRegistry?.extendChildRegistries
+        )
       });
     });
   }
+  /**
+   * Check node extend
+   * @param currentType
+   * @param parentType
+   */
+  isExtend(currentType, parentType) {
+    return (this.getNodeRegistry(currentType).__extends__ || []).includes(parentType);
+  }
   /**
    * 导出数据，可以重载
    */
@@ -2006,6 +2058,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),
@@ -2036,6 +2089,9 @@ var FlowDocument = class {
         ...register.meta
       }
     };
+    if (extendKey) {
+      res.extend = extendKey;
+    }
     this.nodeRegistryCache.set(typeKey, res);
     return res;
   }
@@ -2086,8 +2142,8 @@ var FlowDocument = class {
   getAllNodes() {
     return this.entityManager.getEntities(FlowNodeEntity);
   }
-  toString() {
-    return this.originTree.toString();
+  toString(showType) {
+    return this.originTree.toString(showType);
   }
   /**
    * 返回需要渲染的数据
@@ -2182,6 +2238,7 @@ var FlowDocument = class {
     );
   }
   dispose() {
+    if (this._disposed) return;
     this.registers.clear();
     this.nodeRegistryCache.clear();
     this.originTree.dispose();
@@ -2190,6 +2247,7 @@ var FlowDocument = class {
     this.onNodeCreateEmitter.dispose();
     this.onNodeDisposeEmitter.dispose();
     this.onLayoutChangeEmitter.dispose();
+    this._disposed = true;
   }
 };
 __decorateClass([
@@ -2217,135 +2275,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();
-    this.onNodeMoveEmitter = new import_utils8.Emitter();
-    this.onNodeMove = this.onNodeMoveEmitter.event;
+
+// src/services/flow-group-service/flow-group-controller.ts
+var FlowGroupController = class _FlowGroupController {
+  constructor(groupNode) {
+    this.groupNode = groupNode;
   }
-  init() {
-    this.toDispose.pushAll([this.onNodeAddEmitter, this.onNodeMoveEmitter]);
+  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" ? newParentEntity.collapsedChildren.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;
+    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;
     }
-    const value = {
-      nodeIds: nodes.map((node) => node.id),
-      fromParentId: fromParent.id,
-      toParentId: toParent.id,
-      fromIndex,
-      toIndex
-    };
-    return this.apply({
-      type: "moveChildNodes" /* moveChildNodes */,
-      value
+    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;
   }
-  /**
-   * 执行操作
-   * @param operation 可序列化的操作
-   * @returns 操作返回
-   */
-  apply(operation) {
-    const document = this.document;
-    switch (operation.type) {
-      case "addFromNode" /* addFromNode */:
-        return document.addFromNode(operation.value.fromId, operation.value.data);
-      case "deleteFromNode" /* deleteFromNode */:
-        return document.getNode(operation.value?.data?.id)?.dispose();
+  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();
+  }
+  /**
+   * 移动到目标节点
+   */
+  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.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
+    };
+    return this.apply({
+      type: "moveChildNodes" /* moveChildNodes */,
+      value
+    });
+  }
+  /**
+   * 执行操作
+   * @param operation 可序列化的操作
+   * @returns 操作返回
+   */
+  apply(operation) {
+    const document = this.document;
+    switch (operation.type) {
+      case "addFromNode" /* addFromNode */:
+        return document.addFromNode(operation.value.fromId, operation.value.data);
+      case "deleteFromNode" /* deleteFromNode */:
+        return document.getNode(operation.value?.data?.id)?.dispose();
       case "addBlock" /* addBlock */: {
         let parent;
         if (operation.value.parentId) {
@@ -2470,29 +2820,29 @@ var FlowOperationBaseServiceImpl = class {
   }
 };
 __decorateClass([
-  (0, import_inversify3.inject)(import_core8.EntityManager)
+  (0, import_inversify4.inject)(import_core9.EntityManager)
 ], FlowOperationBaseServiceImpl.prototype, "entityManager", 2);
 __decorateClass([
-  (0, import_inversify3.inject)(FlowDocument)
+  (0, import_inversify4.inject)(FlowDocument)
 ], FlowOperationBaseServiceImpl.prototype, "document", 2);
 __decorateClass([
-  (0, import_inversify3.postConstruct)()
+  (0, import_inversify4.postConstruct)()
 ], FlowOperationBaseServiceImpl.prototype, "init", 1);
 FlowOperationBaseServiceImpl = __decorateClass([
-  (0, import_inversify3.injectable)()
+  (0, import_inversify4.injectable)()
 ], FlowOperationBaseServiceImpl);
 
-// src/services/flow-group-service.ts
+// src/services/flow-group-service/flow-group-service.ts
 var import_nanoid = require("nanoid");
-var import_inversify4 = require("inversify");
-var import_core9 = require("@flowgram.ai/core");
+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.validate(nodes)) {
+    if (!FlowGroupUtils.validate(nodes)) {
       return;
     }
     const sortedNodes = nodes.sort((a, b) => a.index - b.index);
@@ -2562,309 +2912,18 @@ var FlowGroupService = class {
     return FlowGroupController.create(group);
   }
   static validate(nodes) {
-    return FlowGroupController.validate(nodes);
+    return FlowGroupUtils.validate(nodes);
   }
 };
 __decorateClass([
-  (0, import_inversify4.inject)(import_core9.EntityManager)
+  (0, import_inversify5.inject)(import_core10.EntityManager)
 ], FlowGroupService.prototype, "entityManager", 2);
 __decorateClass([
-  (0, import_inversify4.inject)(FlowOperationBaseService)
+  (0, import_inversify5.inject)(FlowOperationBaseService)
 ], FlowGroupService.prototype, "operationService", 2);
 FlowGroupService = __decorateClass([
-  (0, import_inversify4.injectable)()
+  (0, import_inversify5.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;
-  }
-  set hovered(hovered) {
-    const groupRenderData = this.groupNode.getData(FlowNodeRenderData);
-    if (hovered) {
-      groupRenderData.toggleMouseEnter();
-    } else {
-      groupRenderData.toggleMouseLeave();
-    }
-    if (groupRenderData.hovered === hovered) {
-      return;
-    }
-    groupRenderData.hovered = hovered;
-  }
-  get hovered() {
-    const groupRenderData = this.groupNode.getData(FlowNodeRenderData);
-    return groupRenderData.hovered;
-  }
-  static create(groupNode) {
-    if (!groupNode) {
-      return;
-    }
-    if (!_FlowGroupController.isGroupNode(groupNode)) {
-      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;
-      }
-      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) {
-      return;
-    }
-    if (!this.isNodeInGroup(node)) {
-      return;
-    }
-    const groupNode = node?.parent;
-    return _FlowGroupController.create(groupNode);
-  }
-  /** 向上递归查找分组递归控制 */
-  static getNodeRecursionGroupController(node) {
-    if (!node) {
-      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();
-  }
-  /**
-   * 移动到目标节点
-   */
-  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 = FlowGroupController.getNodeRecursionGroupController(node);
-      if (group) {
-        return false;
-      }
-    }
-    return true;
-  }
-  /**
-   * 拖拽分支是否可以释放在该分支
-   * @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;
-  }
-};
-__decorateClass([
-  (0, import_inversify5.inject)(FlowDocument)
-], FlowDragService.prototype, "document", 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([
-  (0, import_inversify5.injectable)()
-], FlowDragService);
 
 // src/layout/vertical-fixed-layout.ts
 var import_inversify6 = require("inversify");