@logicflow/extension 2.2.3 → 2.2.4-alpha.1

package/lib/dynamic-group/index.js

@@ -24,6 +24,17 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
+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;
@@ -55,6 +66,7 @@ var core_1 = require("@logicflow/core");
 var lodash_es_1 = require("lodash-es");
 var node_1 = require("./node");
 var model_1 = require("./model");
+var events_1 = require("../constant/events");
 var utils_1 = require("./utils");
 __exportStar(require("./node"), exports);
 __exportStar(require("./model"), exports);
@@ -69,85 +81,209 @@ 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.sensorOutline = {};
         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 () {
+            _this.clearDragTargetHighlight();
             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.clearDragTargetHighlight();
+        };
+        this.onNodeDrop = function (_a) {
             var node = _a.data;
+            _this.clearDragTargetHighlight();
             _this.addNodeToGroup(node);
         };
+        this.onNodeMouseUp = function () {
+            _this.clearDragTargetHighlight();
+        };
+        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);
+            }
+            (0, lodash_es_1.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);
+            }
+            (0, lodash_es_1.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;
+            (0, lodash_es_1.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;
-                    (0, lodash_es_1.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 的行为保持一致
+                }
+                else {
+                    // 抛出不允许插入的事件
+                    _this.lf.emit(events_1.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 的行为保持一致
+            }
+            else {
+                var preGroup = _this.lf.getNodeModelById(preGroupId);
+                if (preGroup && (0, utils_1.isBoundsInGroup)(bounds, preGroup)) {
+                    return;
                 }
+                _this.detachNodeFromGroup(preGroupId, node.id);
+                // 抛出不允许插入的事件
+                _this.lf.emit(events_1.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) {
-                (0, lodash_es_1.forEach)(Array.from(node.children), function (childId) {
-                    _this.nodeGroupMap.delete(childId);
-                    _this.lf.deleteNode(childId);
-                });
+                var groupModel = model;
+                if (_this.cascadeDeleteChildren) {
+                    (0, lodash_es_1.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) {
@@ -233,12 +369,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;
@@ -249,13 +381,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();
@@ -287,9 +419,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;
             (0, lodash_es_1.forEach)(data.nodes, function (node) {
                 if (node.children) {
                     (0, lodash_es_1.forEach)(node.children, function (childId) {
@@ -317,6 +464,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);
+            }
+        }
+    };
     /**
      * 获取自定位置及其所属分组
      * 当分组重合时，优先返回最上层的分组
@@ -425,6 +586,12 @@ var DynamicGroup = /** @class */ (function () {
         });
         this.topGroupZIndex = max;
     };
+    DynamicGroup.prototype.clearDragTargetHighlight = function () {
+        if (this.activeGroup) {
+            this.activeGroup.setAllowAppendChild(false);
+            this.activeGroup = undefined;
+        }
+    };
     DynamicGroup.prototype.removeChildrenInGroupNodeData = function (nodeData) {
         var _a;
         var newNodeData = (0, lodash_es_1.cloneDeep)(nodeData);
@@ -507,35 +674,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 = (0, utils_1.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 (0, utils_1.isGroupBoundsContainsChildren)(groupBounds, childrenBounds);
     };
     /**
      * Group 插件的初始化方法
@@ -582,27 +736,42 @@ 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(core_1.EventType.NODE_ADD, this.onNodeAdd);
+        lf.on(core_1.EventType.NODE_DND_ADD, this.onNodeDndAdd);
+        lf.on(core_1.EventType.NODE_DROP, this.onNodeDrop);
+        lf.on(core_1.EventType.NODE_MOUSEUP, this.onNodeMouseUp);
+        lf.on(core_1.EventType.SELECTION_DROP, this.onSelectionDrop);
+        lf.on(core_1.EventType.NODE_DELETE, this.removeNodeFromGroup);
+        lf.on(core_1.EventType.EDGE_DELETE, this.onEdgeDelete);
+        lf.on(events_1.NODE_DRAG_EVENTS, this.onNodeDrag);
+        lf.on(core_1.EventType.SELECTION_DRAG, this.onSelectionDrag);
+        lf.on(core_1.EventType.NODE_CLICK, this.onNodeSelect);
+        lf.on(core_1.EventType.NODE_MOUSEMOVE, this.onNodeMove);
+        lf.on(core_1.EventType.NODE_RESIZE, this.onNodeResize);
+        lf.on(core_1.EventType.GRAPH_RENDERED, this.onGraphRendered);
+        lf.on(events_1.ExtensionEventType.GROUP_ADD_NODE, this.onGroupAddNode);
         // https://github.com/didi/LogicFlow/issues/1346
         // 重写 addElements() 方法，在 addElements() 原有基础上增加对 group 内部所有 nodes 和 edges 的复制功能
         // 使用场景：addElements api 项目内部目前只在快捷键粘贴时使用（此处解决的也应该是粘贴场景的问题）
@@ -647,16 +816,24 @@ 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(core_1.EventType.NODE_ADD, this.onNodeAdd);
+        this.lf.off(core_1.EventType.NODE_DND_ADD, this.onNodeDndAdd);
+        this.lf.off(core_1.EventType.NODE_DROP, this.onNodeDrop);
+        this.lf.off(core_1.EventType.NODE_MOUSEUP, this.onNodeMouseUp);
+        this.lf.off(core_1.EventType.SELECTION_DROP, this.onSelectionDrop);
+        this.lf.off(core_1.EventType.NODE_DELETE, this.removeNodeFromGroup);
+        this.lf.off(core_1.EventType.EDGE_DELETE, this.onEdgeDelete);
+        this.lf.off(events_1.NODE_DRAG_EVENTS, this.onNodeDrag);
+        this.lf.off(core_1.EventType.SELECTION_DRAG, this.onSelectionDrag);
+        this.lf.off(core_1.EventType.NODE_CLICK, this.onNodeSelect);
+        this.lf.off(core_1.EventType.NODE_MOUSEMOVE, this.onNodeMove);
+        this.lf.off(core_1.EventType.NODE_RESIZE, this.onNodeResize);
+        this.lf.off(core_1.EventType.GRAPH_RENDERED, this.onGraphRendered);
+        this.lf.off(events_1.ExtensionEventType.GROUP_ADD_NODE, this.onGroupAddNode);
         // 还原 lf.addElements 方法？
+        if (this.originDeleteNode) {
+            this.lf.deleteNode = this.originDeleteNode;
+        }
         // 移除 graphModel 上重写的 addNodeMoveRules 方法？
         // TODO: 讨论一下插件该具体做些什么
     };

package/lib/dynamic-group/model.d.ts

@@ -2,6 +2,12 @@ import LogicFlow, { BaseEdgeModel, GraphModel, IRectNodeProperties, RectNodeMode
 import NodeData = LogicFlow.NodeData;
 import NodeConfig = LogicFlow.NodeConfig;
 import EdgeConfig = LogicFlow.EdgeConfig;
+/** 拖拽感应外框默认样式（可通过 pluginsOptions.dynamicGroup.sensorOutline 覆盖） */
+export declare const DEFAULT_SENSOR_OUTLINE: {
+    readonly stroke: "#feb663";
+    readonly strokeWidth: 2;
+};
+export type SensorOutlineOptions = Partial<typeof DEFAULT_SENSOR_OUTLINE>;
 export type IGroupNodeProperties = {
     /**
      * 当前分组中的节点 id
@@ -43,6 +49,11 @@ export type IGroupNodeProperties = {
      * 分组节点是否自动置顶
      */
     autoToFront?: boolean;
+    /**
+     * 是否允许手动将边连到/从本分组节点。
+     * 显式设置时优先于插件选项 disallowEdgeConnectToGroup。
+     */
+    allowEdgeConnect?: boolean;
     isAllowAppendIn?: (_nodeData: any) => boolean;
 } & IRectNodeProperties;
 export declare class DynamicGroupNodeModel extends RectNodeModel<IGroupNodeProperties> {
@@ -63,6 +74,28 @@ export declare class DynamicGroupNodeModel extends RectNodeModel<IGroupNodePrope
     constructor(data: NodeConfig<IGroupNodeProperties>, graphModel: GraphModel);
     initNodeData(data: LogicFlow.NodeConfig<IGroupNodeProperties>): void;
     setAttributes(): void;
+    getTextStyle(): Record<string, unknown> & {
+        [x: string]: unknown;
+        fill?: string | undefined;
+        stroke?: string | undefined;
+        strokeWidth?: number | undefined;
+        radius?: number | undefined;
+        rx?: number | undefined;
+        ry?: number | undefined;
+        width?: number | undefined;
+        height?: number | undefined;
+        path?: string | undefined;
+        overflowMode?: "default" | "autoWrap" | "ellipsis" | undefined;
+        textWidth?: number | undefined;
+        background?: LogicFlow.CommonTheme | undefined;
+        wrapPadding?: string | undefined;
+        color?: string | undefined;
+        fontSize: number;
+        lineHeight?: number | undefined;
+        textAnchor?: "middle" | "start" | "end" | undefined;
+        dominantBaseline?: "middle" | "central" | "auto" | "text-bottom" | "alphabetic" | "ideographic" | "mathematical" | "hanging" | "text-top" | undefined;
+    };
+    setProperties(properties: Partial<IGroupNodeProperties>): void;
     getData(): NodeData;
     /**
      * 获取分组内的节点
@@ -82,10 +115,15 @@ export declare class DynamicGroupNodeModel extends RectNodeModel<IGroupNodePrope
      * @param collapse {boolean} true -> 折叠；false -> 展开
      */
     toggleCollapse(collapse?: boolean): void;
+    getTitleHtmlRect(): import("./utils").TitleForeignObjectRect;
+    /**
+     * autoResize 更新分组尺寸后同步展开态快照，避免折叠/展开回退到旧尺寸。
+     */
+    updateExpandedSize(width: number, height: number): void;
     setTextPosition(): void;
     private collapse;
     private expand;
-    createVirtualEdge(edgeConfig: EdgeConfig): void;
+    createVirtualEdge(edgeConfig: EdgeConfig, realEdgeId: string): BaseEdgeModel<LogicFlow.PropertiesType>;
     /**
      * 折叠分组的时候，需要处理分组自身的连线和分组内部子节点上的连线
      * 边的分类：
@@ -133,13 +171,28 @@ export declare class DynamicGroupNodeModel extends RectNodeModel<IGroupNodePrope
     /**
      * 重写 Group 节点的 Resize Outline
      */
+    /**
+     * 展开态手动连线是否允许连到/从分组节点本身。
+     * 未设置 allowEdgeConnect 时由插件 disallowEdgeConnectToGroup 决定；折叠虚拟边不受影响。
+     */
+    isManualEdgeConnectAllowed(): boolean;
+    getConnectedTargetRules(): import("@logicflow/core").Model.ConnectRule[];
+    getConnectedSourceRules(): import("@logicflow/core").Model.ConnectRule[];
+    /**
+     * 保留锚点供折叠态虚拟边使用；禁止手动连线时关闭 edgeAddable。
+     */
+    getDefaultAnchor(): {
+        x: number;
+        y: number;
+        id: string;
+    }[];
     getAnchorStyle(): LogicFlow.AnchorTheme;
     /**
      * 设置分组节点 drop 区域的样式
      */
     getAddableOutlineStyle(): {
-        stroke: string;
-        strokeWidth: number;
+        stroke: "#feb663";
+        strokeWidth: 2;
         strokeDasharray: string;
         fill: string;
     };