@flowgram.ai/document 0.1.24 → 0.1.26

package/dist/esm/index.js

@@ -2158,20 +2158,312 @@ FlowDocument = __decorateClass([
 import { ContainerModule } from "inversify";
 
 // src/services/flow-drag-service.ts
-import { inject as inject5, injectable as injectable5 } from "inversify";
-import { EntityManager as EntityManager4 } from "@flowgram.ai/core";
-import { Emitter as Emitter7 } from "@flowgram.ai/utils";
+import { inject as inject3, injectable as injectable3 } from "inversify";
+import { Emitter as Emitter6 } from "@flowgram.ai/utils";
+import { EntityManager as EntityManager2 } from "@flowgram.ai/core";
+
+// src/services/flow-group-service/flow-group-controller.ts
+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 (!FlowGroupUtils.isGroupNode(groupNode)) {
+      return;
+    }
+    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 Emitter6();
+    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 = 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([
+  inject3(FlowDocument)
+], FlowDragService.prototype, "document", 2);
+__decorateClass([
+  inject3(FlowOperationBaseService)
+], FlowDragService.prototype, "operationService", 2);
+__decorateClass([
+  inject3(EntityManager2)
+], FlowDragService.prototype, "entityManager", 2);
+FlowDragService = __decorateClass([
+  injectable3()
+], FlowDragService);
 
 // src/services/flow-operation-base-service.ts
-import { inject as inject3, injectable as injectable3, postConstruct as postConstruct2 } from "inversify";
-import { DisposableCollection, Emitter as Emitter6 } from "@flowgram.ai/utils";
-import { EntityManager as EntityManager2 } from "@flowgram.ai/core";
+import { inject as inject4, injectable as injectable4, postConstruct as postConstruct2 } from "inversify";
+import { DisposableCollection, Emitter as Emitter7 } from "@flowgram.ai/utils";
+import { EntityManager as EntityManager3 } from "@flowgram.ai/core";
 var FlowOperationBaseServiceImpl = class {
   constructor() {
-    this.onNodeAddEmitter = new Emitter6();
+    this.onNodeAddEmitter = new Emitter7();
     this.onNodeAdd = this.onNodeAddEmitter.event;
     this.toDispose = new DisposableCollection();
-    this.onNodeMoveEmitter = new Emitter6();
+    this.onNodeMoveEmitter = new Emitter7();
     this.onNodeMove = this.onNodeMoveEmitter.event;
   }
   init() {
@@ -2387,425 +2679,134 @@ var FlowOperationBaseServiceImpl = class {
     const entity = this.toNodeEntity(node);
     const parent = entity?.parent;
     if (!parent) {
-      return -1;
-    }
-    return parent.children.findIndex((child) => child === entity);
-  }
-  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);
-  }
-};
-__decorateClass([
-  inject3(EntityManager2)
-], FlowOperationBaseServiceImpl.prototype, "entityManager", 2);
-__decorateClass([
-  inject3(FlowDocument)
-], FlowOperationBaseServiceImpl.prototype, "document", 2);
-__decorateClass([
-  postConstruct2()
-], FlowOperationBaseServiceImpl.prototype, "init", 1);
-FlowOperationBaseServiceImpl = __decorateClass([
-  injectable3()
-], FlowOperationBaseServiceImpl);
-
-// src/services/flow-group-service.ts
-import { nanoid } from "nanoid";
-import { inject as inject4, injectable as injectable4 } from "inversify";
-import { EntityManager as EntityManager3 } from "@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_${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([
-  inject4(EntityManager3)
-], FlowGroupService.prototype, "entityManager", 2);
-__decorateClass([
-  inject4(FlowOperationBaseService)
-], FlowGroupService.prototype, "operationService", 2);
-FlowGroupService = __decorateClass([
-  injectable4()
-], 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;
+      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([
+  inject4(EntityManager3)
+], FlowOperationBaseServiceImpl.prototype, "entityManager", 2);
+__decorateClass([
+  inject4(FlowDocument)
+], FlowOperationBaseServiceImpl.prototype, "document", 2);
+__decorateClass([
+  postConstruct2()
+], FlowOperationBaseServiceImpl.prototype, "init", 1);
+FlowOperationBaseServiceImpl = __decorateClass([
+  injectable4()
+], FlowOperationBaseServiceImpl);
+
+// src/services/flow-group-service/flow-group-service.ts
+import { nanoid } from "nanoid";
+import { inject as inject5, injectable as injectable5 } from "inversify";
+import { EntityManager as EntityManager4 } from "@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_${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 Emitter7();
-    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([
-  inject5(FlowDocument)
-], FlowDragService.prototype, "document", 2);
+  inject5(EntityManager4)
+], FlowGroupService.prototype, "entityManager", 2);
 __decorateClass([
   inject5(FlowOperationBaseService)
-], FlowDragService.prototype, "operationService", 2);
-__decorateClass([
-  inject5(EntityManager4)
-], FlowDragService.prototype, "entityManager", 2);
-FlowDragService = __decorateClass([
+], FlowGroupService.prototype, "operationService", 2);
+FlowGroupService = __decorateClass([
   injectable5()
-], FlowDragService);
+], FlowGroupService);
 
 // src/layout/vertical-fixed-layout.ts
 import { injectable as injectable6, inject as inject6, multiInject as multiInject2, optional as optional3 } from "inversify";