@logicflow/extension 2.2.3 → 2.2.4-alpha.0

package/es/constant/events.d.ts

@@ -0,0 +1,9 @@
+/** extension 插件自定义事件（非 @logicflow/core EventType） */
+export declare enum ExtensionEventType {
+    GROUP_ADD_NODE = "group:add-node",
+    GROUP_REMOVE_NODE = "group:remove-node",
+    GROUP_NOT_ALLOWED = "group:not-allowed"
+}
+/** 常用于 lf.on / lf.off 的组合事件名 */
+export declare const NODE_DRAG_EVENTS = "node:drag,node:dnd-drag";
+export declare const NODE_ADD_DROP_DND_EVENTS = "node:add,node:drop,node:dnd-add";

package/es/constant/events.js

@@ -0,0 +1,11 @@
+import { EventType } from '@logicflow/core';
+/** extension 插件自定义事件（非 @logicflow/core EventType） */
+export var ExtensionEventType;
+(function (ExtensionEventType) {
+    ExtensionEventType["GROUP_ADD_NODE"] = "group:add-node";
+    ExtensionEventType["GROUP_REMOVE_NODE"] = "group:remove-node";
+    ExtensionEventType["GROUP_NOT_ALLOWED"] = "group:not-allowed";
+})(ExtensionEventType || (ExtensionEventType = {}));
+/** 常用于 lf.on / lf.off 的组合事件名 */
+export var NODE_DRAG_EVENTS = "".concat(EventType.NODE_DRAG, ",").concat(EventType.NODE_DND_DRAG);
+export var NODE_ADD_DROP_DND_EVENTS = "".concat(EventType.NODE_ADD, ",").concat(EventType.NODE_DROP, ",").concat(EventType.NODE_DND_ADD);

package/es/dynamic-group/index.d.ts

@@ -1,6 +1,7 @@
 import LogicFlow, { BaseEdgeModel, BaseNodeModel, CallbackArgs, Model } from '@logicflow/core';
 import { DynamicGroupNode } from './node';
 import { DynamicGroupNodeModel } from './model';
+import { ExtensionEventType } from '../constant/events';
 import EdgeConfig = LogicFlow.EdgeConfig;
 import EdgeData = LogicFlow.EdgeData;
 import NodeData = LogicFlow.NodeData;
@@ -16,15 +17,40 @@ export declare const dynamicGroup: {
 export declare class DynamicGroup {
     static pluginName: string;
     private lf;
+    /**
+     * 为 true 时禁止手动将边连到/从 dynamic-group 节点本身。
+     * 默认 false，与历史行为一致；折叠虚拟边不受影响。
+     */
+    disallowEdgeConnectToGroup: boolean;
+    /**
+     * 删除 dynamic-group 时是否级联删除其成员。
+     * 默认 true，与 v1.1 以来行为一致；为 false 时仅删除分组，成员保留并解除归属。
+     */
+    cascadeDeleteChildren: boolean;
     topGroupZIndex: number;
     activeGroup?: DynamicGroupNodeModel;
     nodeGroupMap: Map<string, string>;
+    /** 折叠态虚拟边 id → 所属分组与真实边 id */
+    collapsedVirtualEdges: Map<string, {
+        groupId: string;
+        realEdgeId: string;
+    }>;
+    /** 折叠隐藏的真实边 id → 分组 id */
+    collapsedRealEdgeToGroup: Map<string, string>;
+    private originDeleteNode?;
     constructor({ lf, options }: LogicFlow.IExtensionProps);
     /**
      * 获取节点所属的分组
      * @param nodeId
      */
     getGroupByNodeId(nodeId: string): BaseNodeModel<LogicFlow.PropertiesType> | undefined;
+    registerCollapsedVirtualEdge(virtualId: string, groupId: string, realEdgeId: string): void;
+    unregisterCollapsedVirtualEdge(virtualId: string): void;
+    /**
+     * 折叠态删边：删虚拟边时连带删对应真实边，防止展开后「边复活」（#2395）。
+     * Gateway 双分支等场景下，每条虚拟边只映射一条真实边。
+     */
+    onEdgeDelete: ({ data: edge }: CallbackArgs<'edge:delete'>) => void;
     /**
      * 获取自定位置及其所属分组
      * 当分组重合时，优先返回最上层的分组
@@ -49,9 +75,16 @@ export declare class DynamicGroup {
      */
     calibrateTopGroupZIndex(nodes: NodeData[]): void;
     onSelectionDrop: () => void;
-    onNodeAddOrDrop: ({ data: node }: CallbackArgs<'node:add'>) => void;
+    onNodeAdd: ({ data: node }: CallbackArgs<'node:add'>) => void;
+    onNodeDndAdd: ({ data: node }: CallbackArgs<'node:dnd-add'>) => void;
+    onNodeDrop: ({ data: node }: CallbackArgs<'node:drop'>) => void;
+    detachNodeFromGroup: (groupId: string, nodeId: string) => void;
+    releaseGroupMembers: (groupModel: DynamicGroupNodeModel) => void;
+    removeChildFromOtherGroups: (childId: string, ownerGroupId: string) => void;
+    setNodeGroup: (groupId: string, childId: string) => void;
+    syncGroupChildren: (node: LogicFlow.NodeData) => void;
     addNodeToGroup: (node: LogicFlow.NodeData) => void;
-    onGroupAddNode: ({ data: groupData, childId, }: CallbackArgs<'group:add-node'>) => void;
+    onGroupAddNode: ({ data: groupData, childId, }: CallbackArgs<ExtensionEventType.GROUP_ADD_NODE>) => void;
     removeNodeFromGroup: ({ data: node, model, }: CallbackArgs<'node:delete'>) => void;
     onSelectionDrag: () => void;
     onNodeDrag: ({ data: node }: CallbackArgs<'node:drag'>) => void;
@@ -66,7 +99,8 @@ export declare class DynamicGroup {
      * @param isSelected
      */
     onNodeSelect: ({ data: node, isMultiple, isSelected, }: Omit<CallbackArgs<'node:click'>, 'e' | 'position'>) => void;
-    onNodeMove: ({ deltaX, deltaY, data, }: Omit<CallbackArgs<'node:mousemove'>, 'e' | 'position'>) => void;
+    onNodeMove: ({ data, }: Omit<CallbackArgs<'node:mousemove'>, 'e' | 'position'>) => void;
+    onNodeResize: ({ model, }: Omit<CallbackArgs<'node:resize'>, 'e' | 'position'>) => void;
     onGraphRendered: ({ data }: CallbackArgs<'graph:rendered'>) => void;
     removeChildrenInGroupNodeData<T extends LogicFlow.NodeData | LogicFlow.NodeConfig>(nodeData: T): T;
     /**
@@ -113,6 +147,10 @@ export declare namespace DynamicGroup {
     };
     type DynamicGroupOptions = Partial<{
         isCollapsed: boolean;
+        /** 为 true 时禁止手动将边连到/从分组节点；默认 false */
+        disallowEdgeConnectToGroup: boolean;
+        /** 删除分组时是否级联删除成员；默认 true */
+        cascadeDeleteChildren: boolean;
     }>;
 }
 export default DynamicGroup;

package/es/dynamic-group/index.js

@@ -9,6 +9,17 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 var __read = (this && this.__read) || function (o, n) {
     var m = typeof Symbol === "function" && o[Symbol.iterator];
     if (!m) return o;
@@ -38,7 +49,8 @@ import { EventType, transformNodeData, transformEdgeData, } from '@logicflow/cor
 import { assign, cloneDeep, filter, forEach, has, map, sortBy } from 'lodash-es';
 import { DynamicGroupNode } from './node';
 import { DynamicGroupNodeModel } from './model';
-import { isAllowMoveTo, isBoundsInGroup } from './utils';
+import { ExtensionEventType, NODE_DRAG_EVENTS } from '../constant/events';
+import { isAllowMoveTo, isBoundsInGroup, getChildrenBounds, isGroupBoundsContainsChildren, } from './utils';
 export * from './node';
 export * from './model';
 export var dynamicGroup = {
@@ -52,85 +64,204 @@ var DynamicGroup = /** @class */ (function () {
     function DynamicGroup(_a) {
         var lf = _a.lf, options = _a.options;
         var _this = this;
+        /**
+         * 为 true 时禁止手动将边连到/从 dynamic-group 节点本身。
+         * 默认 false，与历史行为一致；折叠虚拟边不受影响。
+         */
+        this.disallowEdgeConnectToGroup = false;
+        /**
+         * 删除 dynamic-group 时是否级联删除其成员。
+         * 默认 true，与 v1.1 以来行为一致；为 false 时仅删除分组，成员保留并解除归属。
+         */
+        this.cascadeDeleteChildren = true;
         this.topGroupZIndex = DEFAULT_BOTTOM_Z_INDEX;
         // 存储节点与 group 的映射关系
         this.nodeGroupMap = new Map();
+        /** 折叠态虚拟边 id → 所属分组与真实边 id */
+        this.collapsedVirtualEdges = new Map();
+        /** 折叠隐藏的真实边 id → 分组 id */
+        this.collapsedRealEdgeToGroup = new Map();
+        /**
+         * 折叠态删边：删虚拟边时连带删对应真实边，防止展开后「边复活」（#2395）。
+         * Gateway 双分支等场景下，每条虚拟边只映射一条真实边。
+         */
+        this.onEdgeDelete = function (_a) {
+            var e_1, _b;
+            var edge = _a.data;
+            var virtualMapping = _this.collapsedVirtualEdges.get(edge.id);
+            if (virtualMapping) {
+                _this.collapsedVirtualEdges.delete(edge.id);
+                _this.collapsedRealEdgeToGroup.delete(virtualMapping.realEdgeId);
+                // 仅删除本条映射的真实边，不影响同组其它分支
+                if (_this.lf.getEdgeModelById(virtualMapping.realEdgeId)) {
+                    _this.lf.deleteEdge(virtualMapping.realEdgeId);
+                }
+                return;
+            }
+            // 真实边被其它路径删除时，同步清理登记与分组内快照
+            var groupId = _this.collapsedRealEdgeToGroup.get(edge.id);
+            if (groupId) {
+                _this.collapsedRealEdgeToGroup.delete(edge.id);
+            }
+            try {
+                for (var _c = __values(_this.collapsedVirtualEdges.entries()), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var _e = __read(_d.value, 2), virtualId = _e[0], info = _e[1];
+                    if (info.realEdgeId === edge.id) {
+                        _this.collapsedVirtualEdges.delete(virtualId);
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        };
         this.onSelectionDrop = function () {
             var selectedNodes = _this.lf.graphModel.getSelectElements().nodes;
             selectedNodes.forEach(function (node) {
                 _this.addNodeToGroup(node);
             });
         };
-        this.onNodeAddOrDrop = function (_a) {
+        this.onNodeAdd = function (_a) {
+            var node = _a.data;
+            _this.syncGroupChildren(node);
+        };
+        this.onNodeDndAdd = function (_a) {
             var node = _a.data;
+            _this.syncGroupChildren(node);
             _this.addNodeToGroup(node);
         };
+        this.onNodeDrop = function (_a) {
+            var node = _a.data;
+            _this.addNodeToGroup(node);
+        };
+        this.detachNodeFromGroup = function (groupId, nodeId) {
+            var group = _this.lf.getNodeModelById(groupId);
+            if (!group)
+                return;
+            group.removeChild(nodeId);
+            _this.nodeGroupMap.delete(nodeId);
+            group.setAllowAppendChild(false);
+        };
+        this.releaseGroupMembers = function (groupModel) {
+            if (groupModel.isCollapsed) {
+                // 复用展开路径恢复真实边与成员可见性，避免删虚拟边时误删真实边
+                groupModel.toggleCollapse(false);
+            }
+            forEach(Array.from(groupModel.children), function (childId) {
+                _this.detachNodeFromGroup(groupModel.id, childId);
+            });
+        };
+        this.removeChildFromOtherGroups = function (childId, ownerGroupId) {
+            var preGroupId = _this.nodeGroupMap.get(childId);
+            if (preGroupId && preGroupId !== ownerGroupId) {
+                var preGroup = _this.lf.getNodeModelById(preGroupId);
+                preGroup === null || preGroup === void 0 ? void 0 : preGroup.removeChild(childId);
+            }
+            forEach(_this.lf.graphModel.nodes, function (node) {
+                var _a;
+                if (!node.isGroup || node.id === ownerGroupId)
+                    return;
+                var group = node;
+                if ((_a = group.children) === null || _a === void 0 ? void 0 : _a.has(childId)) {
+                    group.removeChild(childId);
+                }
+            });
+        };
+        this.setNodeGroup = function (groupId, childId) {
+            _this.removeChildFromOtherGroups(childId, groupId);
+            _this.nodeGroupMap.set(childId, groupId);
+        };
+        this.syncGroupChildren = function (node) {
+            var nodeModel = _this.lf.getNodeModelById(node.id);
+            if (!(nodeModel === null || nodeModel === void 0 ? void 0 : nodeModel.isGroup))
+                return;
+            var group = nodeModel;
+            forEach(Array.from(group.children), function (childId) {
+                _this.setNodeGroup(node.id, childId);
+            });
+            // 新增 group 时进行 this.topGroupZIndex 的校准更新
+            _this.calibrateTopGroupZIndex([node]);
+            _this.onNodeSelect({
+                data: node,
+                isSelected: false,
+                isMultiple: false,
+            });
+        };
         this.addNodeToGroup = function (node) {
+            var nodeModel = _this.lf.getNodeModelById(node.id);
+            var bounds = nodeModel === null || nodeModel === void 0 ? void 0 : nodeModel.getBounds();
+            if (!nodeModel || !bounds)
+                return;
             // 1. 如果该节点之前已经在 group 中了，则将其从之前的 group 移除
             var preGroupId = _this.nodeGroupMap.get(node.id);
-            if (preGroupId) {
-                var group = _this.lf.getNodeModelById(preGroupId);
-                group.removeChild(node.id);
-                _this.nodeGroupMap.delete(node.id);
-                group.setAllowAppendChild(false);
-            }
             // 2. 然后再判断这个节点是否在某个 group 范围内，如果是，则将其添加到对应的 group 中
-            var nodeModel = _this.lf.getNodeModelById(node.id);
-            var bounds = nodeModel === null || nodeModel === void 0 ? void 0 : nodeModel.getBounds();
-            if (nodeModel && bounds) {
-                // TODO: 确认下面的注释内容
-                // https://github.com/didi/LogicFlow/issues/1261
-                // 当使用 SelectionSelect 框选后触发 lf.addNode(Group)
-                // 会触发 appendNodeToGroup() 的执行
-                // 由于 this.getGroup() 会判断 node.id !== nodeData.id
-                // 因此当 addNode 是 Group 类型时，this.getGroup() 会一直返回空
-                // 导致了下面这段代码无法执行，也就是无法将当前添加的 Group 添加到 this.nodeGroupMap 中
-                // 这导致了折叠分组时触发的 foldEdge() 无法正确通过 getNodeGroup() 拿到正确的 groupId
-                // 从而导致折叠分组时一直都会创建一个虚拟边
-                // 而初始化分组时由于正确设置了nodeGroupMap的数据，因此不会产生虚拟边的错误情况
-                if (nodeModel.isGroup) {
-                    var group_1 = nodeModel;
-                    forEach(Array.from(group_1.children), function (childId) {
-                        _this.nodeGroupMap.set(childId, node.id);
-                    });
-                    // 新增 node 时进行 this.topGroupZIndex 的校准更新
-                    _this.calibrateTopGroupZIndex([node]);
-                    _this.onNodeSelect({
-                        data: node,
-                        isSelected: false,
-                        isMultiple: false,
+            // TODO: 找到这个范围内的 groupModel, 并加 node 添加到该 group
+            var targetGroup = _this.getGroupByBounds(bounds, node);
+            // 同组内移动，成员关系不变（#2412）
+            if (preGroupId && (targetGroup === null || targetGroup === void 0 ? void 0 : targetGroup.id) === preGroupId) {
+                return;
+            }
+            if (!targetGroup) {
+                if (preGroupId) {
+                    _this.detachNodeFromGroup(preGroupId, node.id);
+                }
+                return;
+            }
+            if (!preGroupId) {
+                if (targetGroup.isAllowAppendIn(node)) {
+                    targetGroup.addChild(node.id);
+                    // 建立节点与 group 的映射关系放在了 group.addChild 触发的事件中，与直接调用 addChild 的行为保持一致
+                    targetGroup.setAllowAppendChild(false);
+                }
+                else {
+                    // 抛出不允许插入的事件
+                    _this.lf.emit(ExtensionEventType.GROUP_NOT_ALLOWED, {
+                        group: targetGroup.getData(),
+                        node: node,
                     });
                 }
-                // TODO: 找到这个范围内的 groupModel, 并加 node 添加到该 group
-                var group = _this.getGroupByBounds(bounds, node);
-                if (group) {
-                    var isAllowAppendIn = group.isAllowAppendIn(node);
-                    if (isAllowAppendIn) {
-                        group.addChild(node.id);
-                        // 建立节点与 group 的映射关系放在了 group.addChild 触发的事件中，与直接调用 addChild 的行为保持一致
-                        group.setAllowAppendChild(false);
-                    }
-                    else {
-                        // 抛出不允许插入的事件
-                        _this.lf.emit('group:not-allowed', {
-                            group: group.getData(),
-                            node: node,
-                        });
-                    }
+                return;
+            }
+            if (targetGroup.isAllowAppendIn(node)) {
+                _this.detachNodeFromGroup(preGroupId, node.id);
+                targetGroup.addChild(node.id);
+                // 建立节点与 group 的映射关系放在了 group.addChild 触发的事件中，与直接调用 addChild 的行为保持一致
+                targetGroup.setAllowAppendChild(false);
+            }
+            else {
+                var preGroup = _this.lf.getNodeModelById(preGroupId);
+                if (preGroup && isBoundsInGroup(bounds, preGroup)) {
+                    return;
                 }
+                _this.detachNodeFromGroup(preGroupId, node.id);
+                // 抛出不允许插入的事件
+                _this.lf.emit(ExtensionEventType.GROUP_NOT_ALLOWED, {
+                    group: targetGroup.getData(),
+                    node: node,
+                });
             }
         };
         this.onGroupAddNode = function (_a) {
             var groupData = _a.data, childId = _a.childId;
-            _this.nodeGroupMap.set(childId, groupData.id);
+            _this.setNodeGroup(groupData.id, childId);
         };
         this.removeNodeFromGroup = function (_a) {
             var node = _a.data, model = _a.model;
             if (model.isGroup && node.children) {
-                forEach(Array.from(node.children), function (childId) {
-                    _this.nodeGroupMap.delete(childId);
-                    _this.lf.deleteNode(childId);
-                });
+                var groupModel = model;
+                if (_this.cascadeDeleteChildren) {
+                    forEach(Array.from(groupModel.children), function (childId) {
+                        _this.nodeGroupMap.delete(childId);
+                        _this.lf.deleteNode(childId);
+                    });
+                }
+                else {
+                    _this.releaseGroupMembers(groupModel);
+                }
             }
             var groupId = _this.nodeGroupMap.get(node.id);
             if (groupId) {
@@ -216,12 +347,8 @@ var DynamicGroup = /** @class */ (function () {
             }
         };
         this.onNodeMove = function (_a) {
-            var deltaX = _a.deltaX, deltaY = _a.deltaY, data = _a.data;
-            var id = data.id, x = data.x, y = data.y, properties = data.properties;
-            if (!properties) {
-                return;
-            }
-            var width = properties.width, height = properties.height;
+            var data = _a.data;
+            var id = data.id;
             var groupId = _this.nodeGroupMap.get(id);
             if (!groupId) {
                 return;
@@ -232,13 +359,13 @@ var DynamicGroup = /** @class */ (function () {
             }
             // 当父节点isRestrict=true & autoResize=true
             // 子节点在父节点中移动时，父节点会自动调整大小
-            // step1: 计算出当前child的bounds
-            var newX = x + deltaX / 2;
-            var newY = y + deltaY / 2;
-            var minX = newX - width / 2;
-            var minY = newY - height / 2;
-            var maxX = newX + width / 2;
-            var maxY = newY + height / 2;
+            var childModel = _this.lf.getNodeModelById(id);
+            if (!childModel) {
+                return;
+            }
+            // node:mousemove 的 data 在 onDragging 之前采集，坐标滞后；
+            // 此时子节点 model 已更新，直接读取 getBounds()。
+            var _b = childModel.getBounds(), minX = _b.minX, minY = _b.minY, maxX = _b.maxX, maxY = _b.maxY;
             // step2：比较当前child.bounds与parent.bounds的差异，比如child.minX<parent.minX，那么parent.minX=child.minX
             var hasChange = false;
             var groupBounds = groupModel.getBounds();
@@ -270,9 +397,24 @@ var DynamicGroup = /** @class */ (function () {
             groupModel.moveTo(newGroupX, newGroupY);
             groupModel.width = newGroupWidth;
             groupModel.height = newGroupHeight;
+            groupModel.updateExpandedSize(newGroupWidth, newGroupHeight);
+            groupModel.setTextPosition();
+        };
+        this.onNodeResize = function (_a) {
+            var model = _a.model;
+            if ((model === null || model === void 0 ? void 0 : model.isGroup) && !model.isCollapsed) {
+                ;
+                model.setTextPosition();
+            }
         };
         this.onGraphRendered = function (_a) {
             var data = _a.data;
+            // lf.render / graphDataToModel 不会逐节点触发 node:delete，需在整图重建时重置插件侧状态
+            _this.nodeGroupMap.clear();
+            _this.collapsedVirtualEdges.clear();
+            _this.collapsedRealEdgeToGroup.clear();
+            _this.activeGroup = undefined;
+            _this.topGroupZIndex = DEFAULT_BOTTOM_Z_INDEX;
             forEach(data.nodes, function (node) {
                 if (node.children) {
                     forEach(node.children, function (childId) {
@@ -300,6 +442,20 @@ var DynamicGroup = /** @class */ (function () {
             return this.lf.getNodeModelById(groupId);
         }
     };
+    DynamicGroup.prototype.registerCollapsedVirtualEdge = function (virtualId, groupId, realEdgeId) {
+        // 双向索引：删虚拟边时能找到真实边；删真实边时能清理虚拟边登记
+        this.collapsedVirtualEdges.set(virtualId, { groupId: groupId, realEdgeId: realEdgeId });
+        this.collapsedRealEdgeToGroup.set(realEdgeId, groupId);
+    };
+    DynamicGroup.prototype.unregisterCollapsedVirtualEdge = function (virtualId) {
+        var info = this.collapsedVirtualEdges.get(virtualId);
+        if (info) {
+            this.collapsedVirtualEdges.delete(virtualId);
+            if (this.collapsedRealEdgeToGroup.get(info.realEdgeId) === info.groupId) {
+                this.collapsedRealEdgeToGroup.delete(info.realEdgeId);
+            }
+        }
+    };
     /**
      * 获取自定位置及其所属分组
      * 当分组重合时，优先返回最上层的分组
@@ -490,35 +646,22 @@ var DynamicGroup = /** @class */ (function () {
      * @param newHeight
      */
     DynamicGroup.prototype.checkGroupBoundsWithChildren = function (groupModel, deltaX, deltaY, newWidth, newHeight) {
-        if (groupModel.children) {
-            var children = groupModel.children, x = groupModel.x, y = groupModel.y;
-            // 根据deltaX和deltaY计算出当前model的bounds
-            var newX = x + deltaX / 2;
-            var newY = y + deltaY / 2;
-            var groupMinX = newX - newWidth / 2;
-            var groupMinY = newY - newHeight / 2;
-            var groupMaxX = newX + newWidth / 2;
-            var groupMaxY = newY + newHeight / 2;
-            var childrenArray = Array.from(children);
-            for (var i = 0; i < childrenArray.length; i++) {
-                var childId = childrenArray[i];
-                var child = this.lf.getNodeModelById(childId);
-                if (!child) {
-                    continue;
-                }
-                var childBounds = child.getBounds();
-                var minX = childBounds.minX, minY = childBounds.minY, maxX = childBounds.maxX, maxY = childBounds.maxY;
-                // parent:resize后的bounds不能小于child:bounds，否则阻止其resize
-                var canResize = groupMinX <= minX &&
-                    groupMinY <= minY &&
-                    groupMaxX >= maxX &&
-                    groupMaxY >= maxY;
-                if (!canResize) {
-                    return false;
-                }
-            }
+        var _this = this;
+        var childrenBounds = getChildrenBounds(groupModel, function (id) {
+            return _this.lf.getNodeModelById(id);
+        });
+        if (!childrenBounds) {
+            return true;
         }
-        return true;
+        var newX = groupModel.x + deltaX / 2;
+        var newY = groupModel.y + deltaY / 2;
+        var groupBounds = {
+            minX: newX - newWidth / 2,
+            minY: newY - newHeight / 2,
+            maxX: newX + newWidth / 2,
+            maxY: newY + newHeight / 2,
+        };
+        return isGroupBoundsContainsChildren(groupBounds, childrenBounds);
     };
     /**
      * Group 插件的初始化方法
@@ -565,27 +708,41 @@ var DynamicGroup = /** @class */ (function () {
             }
             return true;
         });
-        // https://github.com/didi/LogicFlow/issues/1442
-        // https://github.com/didi/LogicFlow/issues/937
         // 添加分组节点resize规则
-        // isRestrict限制模式下，当前model resize时不能小于children的占地面积
-        // 并且在isRestrict限制模式下，transformWidthContainer即使设置为true，也无效
+        // 所有分组默认不可缩小到直接子节点占地面积以下
         graphModel.addNodeResizeRules(function (model, deltaX, deltaY, width, height) {
-            if (model.isGroup && model.isRestrict) {
+            if (model.isGroup) {
                 return _this.checkGroupBoundsWithChildren(model, deltaX, deltaY, width, height);
             }
             return true;
         });
         graphModel.dynamicGroup = this;
-        lf.on('node:add,node:drop,node:dnd-add', this.onNodeAddOrDrop);
-        lf.on('selection:drop', this.onSelectionDrop);
-        lf.on('node:delete', this.removeNodeFromGroup);
-        lf.on('node:drag,node:dnd-drag', this.onNodeDrag);
-        lf.on('selection:drag', this.onSelectionDrag);
-        lf.on('node:click', this.onNodeSelect);
-        lf.on('node:mousemove', this.onNodeMove);
-        lf.on('graph:rendered', this.onGraphRendered);
-        lf.on('group:add-node', this.onGroupAddNode);
+        // cascadeDeleteChildren=false 时须在 core 删除「指向分组的边」之前释放成员，
+        // 否则折叠虚拟边被删会连带删掉真实边（graphModel.deleteNode 先删边再 emit node:delete）
+        this.originDeleteNode = lf.deleteNode.bind(lf);
+        lf.deleteNode = function (nodeId) {
+            var nodeModel = lf.getNodeModelById(nodeId);
+            if (!_this.cascadeDeleteChildren && (nodeModel === null || nodeModel === void 0 ? void 0 : nodeModel.isGroup)) {
+                var groupModel = nodeModel;
+                if (groupModel.children.size > 0) {
+                    _this.releaseGroupMembers(groupModel);
+                }
+            }
+            return _this.originDeleteNode(nodeId);
+        };
+        lf.on(EventType.NODE_ADD, this.onNodeAdd);
+        lf.on(EventType.NODE_DND_ADD, this.onNodeDndAdd);
+        lf.on(EventType.NODE_DROP, this.onNodeDrop);
+        lf.on(EventType.SELECTION_DROP, this.onSelectionDrop);
+        lf.on(EventType.NODE_DELETE, this.removeNodeFromGroup);
+        lf.on(EventType.EDGE_DELETE, this.onEdgeDelete);
+        lf.on(NODE_DRAG_EVENTS, this.onNodeDrag);
+        lf.on(EventType.SELECTION_DRAG, this.onSelectionDrag);
+        lf.on(EventType.NODE_CLICK, this.onNodeSelect);
+        lf.on(EventType.NODE_MOUSEMOVE, this.onNodeMove);
+        lf.on(EventType.NODE_RESIZE, this.onNodeResize);
+        lf.on(EventType.GRAPH_RENDERED, this.onGraphRendered);
+        lf.on(ExtensionEventType.GROUP_ADD_NODE, this.onGroupAddNode);
         // https://github.com/didi/LogicFlow/issues/1346
         // 重写 addElements() 方法，在 addElements() 原有基础上增加对 group 内部所有 nodes 和 edges 的复制功能
         // 使用场景：addElements api 项目内部目前只在快捷键粘贴时使用（此处解决的也应该是粘贴场景的问题）
@@ -630,16 +787,23 @@ var DynamicGroup = /** @class */ (function () {
     DynamicGroup.prototype.render = function () { };
     DynamicGroup.prototype.destroy = function () {
         // 销毁监听的事件，并移除渲染的 dom 内容
-        this.lf.off('node:add,node:drop,node:dnd-add', this.onNodeAddOrDrop);
-        this.lf.off('selection:drop', this.onSelectionDrop);
-        this.lf.off('node:delete', this.removeNodeFromGroup);
-        this.lf.off('node:drag,node:dnd-drag', this.onNodeDrag);
-        this.lf.off('selection:drag', this.onSelectionDrag);
-        this.lf.off('node:click', this.onNodeSelect);
-        this.lf.off('node:mousemove', this.onNodeMove);
-        this.lf.off('graph:rendered', this.onGraphRendered);
-        this.lf.off('group:add-node', this.onGroupAddNode);
+        this.lf.off(EventType.NODE_ADD, this.onNodeAdd);
+        this.lf.off(EventType.NODE_DND_ADD, this.onNodeDndAdd);
+        this.lf.off(EventType.NODE_DROP, this.onNodeDrop);
+        this.lf.off(EventType.SELECTION_DROP, this.onSelectionDrop);
+        this.lf.off(EventType.NODE_DELETE, this.removeNodeFromGroup);
+        this.lf.off(EventType.EDGE_DELETE, this.onEdgeDelete);
+        this.lf.off(NODE_DRAG_EVENTS, this.onNodeDrag);
+        this.lf.off(EventType.SELECTION_DRAG, this.onSelectionDrag);
+        this.lf.off(EventType.NODE_CLICK, this.onNodeSelect);
+        this.lf.off(EventType.NODE_MOUSEMOVE, this.onNodeMove);
+        this.lf.off(EventType.NODE_RESIZE, this.onNodeResize);
+        this.lf.off(EventType.GRAPH_RENDERED, this.onGraphRendered);
+        this.lf.off(ExtensionEventType.GROUP_ADD_NODE, this.onGroupAddNode);
         // 还原 lf.addElements 方法？
+        if (this.originDeleteNode) {
+            this.lf.deleteNode = this.originDeleteNode;
+        }
         // 移除 graphModel 上重写的 addNodeMoveRules 方法？
         // TODO: 讨论一下插件该具体做些什么
     };