@grafloria/element 0.3.20 → 0.3.21

package/src/libs/engine/src/interaction/GroupCollapseService.js

@@ -1,274 +0,0 @@
-"use strict";
-// GroupCollapseService — Wave-5 Card 4: real collapse / expand.
-//
-// Collapse hides a group's members, shrinks the group to a titled placeholder,
-// saves child positions, and RE-HOMES every member-incident edge to the group
-// boundary — aggregating parallel same-direction crossings between the group
-// and a given external node into ONE labelled proxy link.
-//
-// OWNERSHIP: this is a MODEL-level operation. The group is presented as an
-// ordinary node endpoint by spawning a hidden placeholder NodeModel (the
-// "group-as-node") through the public DiagramModel/NodeModel/LinkModel APIs, so
-// proxy links are ordinary node↔node links the router handles with ZERO router
-// changes. No obstacle/path geometry lives here.
-//
-// The whole operation is reversible from the snapshot stored on the group
-// (GroupModel.collapsedState), which serializes — so a collapsed diagram
-// round-trips and can still be expanded after a save/load. Commands wrap
-// collapse()/expand() to make it a single undo step.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GroupCollapseService = exports.PROXY_LINK_GROUP_KEY = exports.PROXY_NODE_GROUP_KEY = void 0;
-const NodeModel_1 = require("../models/NodeModel");
-/** Metadata key stamped on a placeholder node so it can be recognised/filtered. */
-exports.PROXY_NODE_GROUP_KEY = '__collapsedGroupId';
-/** Metadata key stamped on a re-homed proxy link. */
-exports.PROXY_LINK_GROUP_KEY = '__proxyForGroup';
-/** Default placeholder box the group shrinks to when collapsed. */
-const PLACEHOLDER_WIDTH = 180;
-const PLACEHOLDER_HEIGHT = 44;
-class GroupCollapseService {
-    constructor(diagram) {
-        this.diagram = diagram;
-    }
-    /**
-     * Collapse `group`: hide members, save layout, re-home boundary edges to an
-     * aggregated proxy, and shrink the group to a placeholder. No-op if the group
-     * is already collapsed. Members-less groups collapse "lightly" (flag only, no
-     * placeholder) so trivial groups don't spawn stray nodes.
-     */
-    collapse(group, options) {
-        if (group.isCollapsed) {
-            return;
-        }
-        const memberNodeIds = this.collectMemberNodeIds(group);
-        // Nothing to hide → keep it lightweight (old flag-only behaviour), but still
-        // record an (empty) snapshot so expand() knows this was a managed collapse.
-        if (memberNodeIds.size === 0) {
-            group.collapse();
-            this.setCollapsedState(group, {
-                proxyNodeId: '',
-                savedPositions: {},
-                hiddenNodes: [],
-                removedLinks: [],
-                proxyLinks: [],
-            });
-            return;
-        }
-        const savedGeometry = {
-            position: { x: group.position.x, y: group.position.y },
-            size: group.size ? Object.assign({}, group.size) : undefined,
-            bounds: group.bounds ? Object.assign({}, group.bounds) : undefined,
-        };
-        // 1) Save member positions (restored verbatim on expand).
-        const savedPositions = {};
-        for (const id of memberNodeIds) {
-            const node = this.diagram.getNode(id);
-            if (node) {
-                savedPositions[id] = { x: node.position.x, y: node.position.y };
-            }
-        }
-        // 2) Spawn the placeholder "group-as-node" at the group's top-left.
-        const frame = group.getOuterBounds();
-        const placeholder = new NodeModel_1.NodeModel({
-            type: 'group-collapsed',
-            position: { x: frame.x, y: frame.y },
-            size: { width: PLACEHOLDER_WIDTH, height: PLACEHOLDER_HEIGHT },
-        });
-        placeholder.setMetadata(exports.PROXY_NODE_GROUP_KEY, group.id);
-        placeholder.setMetadata('__isGroupProxy', true);
-        placeholder.setData('label', group.name);
-        this.diagram.addNode(placeholder);
-        // 3) Partition member-incident links and aggregate boundary crossings.
-        const { removedLinks, proxyLinks } = this.rehomeIncidentLinks(group, memberNodeIds, placeholder, options);
-        // 4) Hide members (they keep their absolute positions, just invisible).
-        const hiddenNodes = [];
-        for (const id of memberNodeIds) {
-            const node = this.diagram.getNode(id);
-            if (node) {
-                hiddenNodes.push({ nodeId: id, prevVisible: node.state.visible !== false });
-                node.setState({ visible: false });
-            }
-        }
-        // 5) Flag + shrink the group to the placeholder rectangle.
-        group.collapse();
-        group.setFrame({
-            x: frame.x,
-            y: frame.y,
-            width: PLACEHOLDER_WIDTH,
-            height: PLACEHOLDER_HEIGHT,
-        });
-        this.setCollapsedState(group, {
-            proxyNodeId: placeholder.id,
-            savedGeometry,
-            savedPositions,
-            hiddenNodes,
-            removedLinks,
-            proxyLinks,
-        });
-        // Derived port registries changed (removed/re-homed links).
-        this.diagram.reconcilePortConnections();
-    }
-    /**
-     * Expand `group` back to exactly its pre-collapse state using the snapshot on
-     * the group. No-op if the group is not collapsed / has no snapshot.
-     */
-    expand(group) {
-        var _a, _b, _c;
-        const state = group.collapsedState;
-        if (!state) {
-            // Collapsed via the bare flag (no managed snapshot) — just unflag.
-            if (group.isCollapsed) {
-                group.expand();
-            }
-            return;
-        }
-        // 1) Restore the boundary survivors' original endpoints + strip proxy label.
-        for (const entry of state.proxyLinks) {
-            const link = this.diagram.getLink(entry.linkId);
-            if (!link)
-                continue;
-            if (entry.end === 'source') {
-                link.setSourcePort(entry.originalPortId, entry.originalNodeId);
-            }
-            else {
-                link.setTargetPort(entry.originalPortId, entry.originalNodeId);
-            }
-            // Remove the synthetic aggregate label(s) we added.
-            for (const label of [...link.labels]) {
-                if ((_a = label.id) === null || _a === void 0 ? void 0 : _a.startsWith('proxy-agg-')) {
-                    link.removeLabel(label.id);
-                }
-            }
-            link.deleteMetadata(exports.PROXY_LINK_GROUP_KEY);
-            link.deleteMetadata('__proxyAggregateCount');
-        }
-        // 2) Re-create the links removed at collapse time (internal + aggregated).
-        for (const data of state.removedLinks) {
-            this.diagram.restoreLink(data);
-        }
-        // 3) Remove the placeholder node (its incident survivors were re-homed off it).
-        if (state.proxyNodeId) {
-            this.diagram.removeNode(state.proxyNodeId);
-        }
-        // 4) Restore member positions + visibility.
-        for (const [nodeId, pos] of Object.entries(state.savedPositions)) {
-            (_b = this.diagram.getNode(nodeId)) === null || _b === void 0 ? void 0 : _b.setPosition(pos.x, pos.y);
-        }
-        for (const { nodeId, prevVisible } of state.hiddenNodes) {
-            (_c = this.diagram.getNode(nodeId)) === null || _c === void 0 ? void 0 : _c.setState({ visible: prevVisible });
-        }
-        // 5) Restore the group's exact prior geometry.
-        if (state.savedGeometry) {
-            group.restoreGeometry(state.savedGeometry);
-        }
-        group.expand();
-        this.setCollapsedState(group, undefined);
-        this.diagram.reconcilePortConnections();
-    }
-    /**
-     * Re-home every member-incident link. Internal links (both ends inside the
-     * group) are removed (saved for restore). Boundary links are bucketed by
-     * (external node, direction); each bucket keeps ONE survivor re-pointed to the
-     * placeholder and labelled with the crossing count, and the rest are removed.
-     */
-    rehomeIncidentLinks(group, memberNodeIds, placeholder, options) {
-        var _a, _b, _c, _d, _e, _f;
-        const removedLinks = [];
-        const buckets = new Map();
-        for (const link of this.diagram.getLinks()) {
-            const srcId = (_a = link.sourceNodeId) !== null && _a !== void 0 ? _a : (_b = this.diagram.getNodeByPortId(link.sourcePortId)) === null || _b === void 0 ? void 0 : _b.id;
-            const tgtId = (_c = link.targetNodeId) !== null && _c !== void 0 ? _c : (_d = this.diagram.getNodeByPortId(link.targetPortId)) === null || _d === void 0 ? void 0 : _d.id;
-            const srcIn = !!srcId && memberNodeIds.has(srcId);
-            const tgtIn = !!tgtId && memberNodeIds.has(tgtId);
-            if (!srcIn && !tgtIn) {
-                continue; // untouched
-            }
-            if (srcIn && tgtIn) {
-                // Internal link — hidden with the group; remove and remember.
-                removedLinks.push(link.serialize());
-                this.diagram.removeLink(link.id);
-                continue;
-            }
-            // Boundary link: exactly one end is a member.
-            const direction = srcIn ? 'out' : 'in';
-            const externalNodeId = (srcIn ? tgtId : srcId);
-            const key = `${externalNodeId}|${direction}`;
-            let bucket = buckets.get(key);
-            if (!bucket) {
-                bucket = { direction, externalNodeId, links: [] };
-                buckets.set(key, bucket);
-            }
-            bucket.links.push(link);
-        }
-        // Collapse each bucket into a single labelled proxy survivor.
-        const proxyLinks = [];
-        for (const { direction, externalNodeId, links } of buckets.values()) {
-            const survivor = links[0];
-            const memberEnd = direction === 'out' ? 'source' : 'target';
-            const originalPortId = memberEnd === 'source' ? survivor.sourcePortId : survivor.targetPortId;
-            const originalNodeId = memberEnd === 'source' ? survivor.sourceNodeId : survivor.targetNodeId;
-            // Placeholder attachment: source side for outgoing, target side for incoming.
-            const placeholderPort = direction === 'out'
-                ? placeholder.getPortBySide('right')
-                : placeholder.getPortBySide('left');
-            const portId = (_e = placeholderPort === null || placeholderPort === void 0 ? void 0 : placeholderPort.id) !== null && _e !== void 0 ? _e : (_f = placeholder.getPorts()[0]) === null || _f === void 0 ? void 0 : _f.id;
-            if (memberEnd === 'source') {
-                survivor.setSourcePort(portId, placeholder.id);
-            }
-            else {
-                survivor.setTargetPort(portId, placeholder.id);
-            }
-            // Remove the aggregated-away parallels (saved for restore).
-            for (let i = 1; i < links.length; i++) {
-                removedLinks.push(links[i].serialize());
-                this.diagram.removeLink(links[i].id);
-            }
-            // Label = count (or user hook).
-            const labelText = (options === null || options === void 0 ? void 0 : options.proxyLabel)
-                ? options.proxyLabel({ group, externalNodeId, direction, count: links.length })
-                : links.length > 1
-                    ? String(links.length)
-                    : '';
-            survivor.setMetadata(exports.PROXY_LINK_GROUP_KEY, group.id);
-            survivor.setMetadata('__proxyAggregateCount', links.length);
-            if (labelText) {
-                survivor.addLabel({ id: `proxy-agg-${survivor.id}`, text: labelText, position: 0.5 });
-            }
-            proxyLinks.push({
-                linkId: survivor.id,
-                end: memberEnd,
-                originalPortId,
-                originalNodeId,
-                aggregatedCount: links.length,
-            });
-        }
-        return { removedLinks, proxyLinks };
-    }
-    /**
-     * All NODE ids contained (transitively) in `group`: direct node members plus
-     * every node inside nested member-groups.
-     */
-    collectMemberNodeIds(group) {
-        const out = new Set();
-        const walk = (g) => {
-            for (const id of g.members) {
-                if (this.diagram.getNode(id)) {
-                    out.add(id);
-                }
-                else {
-                    const child = this.diagram.getGroup(id);
-                    if (child)
-                        walk(child);
-                }
-            }
-        };
-        walk(group);
-        return out;
-    }
-    /** Set/clear the snapshot and track it so the change is captured (diff/undo). */
-    setCollapsedState(group, state) {
-        group.setCollapsedState(state);
-    }
-}
-exports.GroupCollapseService = GroupCollapseService;
-//# sourceMappingURL=GroupCollapseService.js.map

package/src/libs/engine/src/interaction/GroupMembershipService.d.ts

@@ -1,107 +0,0 @@
-import type { Point } from '../types/geometry.types';
-import type { DiagramModel } from '../models/DiagramModel';
-import type { GroupModel } from '../models/GroupModel';
-import { Command } from '../commands/Command';
-/**
- * Minimal command dispatcher contract (satisfied by CommandManager). Injecting
- * this keeps membership changes on the shared undo stack.
- */
-export interface CommandDispatcher {
-    execute(command: Command): Promise<void> | void;
-}
-export interface GroupMembershipServiceOptions {
-    diagram: DiagramModel;
-    /**
-     * Dispatcher for undoable membership changes (typically a CommandManager).
-     * When omitted, commands are executed directly against the diagram (still
-     * correct, but not tracked for undo/redo).
-     */
-    dispatcher?: CommandDispatcher;
-    /** Grid cell size for the group spatial index (default 100). */
-    cellSize?: number;
-}
-/** Options for a single hit-test. */
-export interface HitTestOptions {
-    /** Group ids to skip (e.g. the group being dragged + its descendants). */
-    excludeGroupIds?: Set<string>;
-}
-/** Outcome of a node drag-end reparent attempt. */
-export interface DropResult {
-    nodeId: string;
-    /** Group the node left (if it was a member of one). */
-    fromGroupId?: string;
-    /** Group the node joined (undefined when dropped outside all groups). */
-    toGroupId?: string;
-    /** Commands dispatched, in order (empty when nothing changed). */
-    commands: Command[];
-    /** Whether membership actually changed. */
-    changed: boolean;
-    /** A target group was under the cursor but rejected the node. */
-    rejected: boolean;
-}
-export declare class GroupMembershipService {
-    private readonly diagram;
-    private readonly dispatcher?;
-    private readonly index;
-    private hoveredGroupId?;
-    constructor(options: GroupMembershipServiceOptions);
-    /**
-     * Rebuild the spatial index from the diagram's current groups. Group counts
-     * are small relative to nodes, so a full refresh per interaction is cheap and
-     * always reflects freshly-dragged geometry.
-     */
-    refresh(): void;
-    /**
-     * Hit-test a point against group rectangles using the spatial index and
-     * return the innermost matching group (deepest nesting, then smallest area),
-     * so a nested child wins over its parent. Returns undefined when the point is
-     * outside every group.
-     */
-    hitTestGroup(point: Point, options?: HitTestOptions): GroupModel | undefined;
-    /**
-     * Return the first group that currently contains `entityId` as a direct
-     * member, or undefined. (Membership check over the small group set — this is
-     * not the spatial hit-test.)
-     */
-    getContainingGroup(entityId: string): GroupModel | undefined;
-    /**
-     * Highlight the group under the cursor during a drag and clear any previously
-     * hovered group. Returns the hovered group (or undefined). Drives the group's
-     * 'hover:changed' emitter so a renderer can outline the drop target.
-     */
-    updateHover(point: Point, options?: HitTestOptions): GroupModel | undefined;
-    /** Clear any active hover highlight (call on drag-end / cancel). */
-    clearHover(): void;
-    /**
-     * Handle a node drag-end at `point`: re-parent the node into the group under
-     * the cursor, or unembed it when dropped outside every group. No-op when the
-     * node is already in the target group. Rejected (no change) when the target
-     * group's validation/cycle rules veto the node.
-     */
-    handleNodeDragEnd(nodeId: string, point: Point): Promise<DropResult>;
-    /**
-     * Coordinate translation seam for reparenting. In the engine's ABSOLUTE model
-     * a node keeps its world position across a reparent (it stays where it was
-     * dropped), so this is the identity for `node.position`. Group bounds are
-     * derived from absolute member positions and are recomputed by the caller.
-     * Isolated here so a future relative-coordinate model has one place to change.
-     */
-    private translateOnReparent;
-    private dispatch;
-    /**
-     * Resolve a group's screen rectangle for spatial indexing / hit-testing.
-     *
-     * The PAINTED frame (explicit position + size) must win over the derived
-     * member `bounds`, exactly as GroupModel.getOuterBounds() orders them. This
-     * method used to prefer `bounds` — which handleNodeDragEnd overwrites with
-     * the tight member bbox after every membership change — so once anything was
-     * dragged in or out, the drop target silently shrank from the frame the user
-     * SEES to an invisible box around the remaining members, and drops in the
-     * frame's empty margin stopped adopting (visio audit, empirically
-     * reproduced: drag-out worked, the next drag-in near the frame edge did
-     * nothing).
-     */
-    private groupRect;
-    private rectContains;
-    private rectArea;
-}

package/src/libs/engine/src/interaction/GroupMembershipService.js

@@ -1,245 +0,0 @@
-"use strict";
-// GroupMembershipService - interactive drag-in / drag-out group membership (Wave-2)
-//
-// Engine-side service the canvas can call on node drag-end. It hit-tests the
-// pointer against group bounds using the shared SpatialIndex (never a linear
-// scan) and re-parents the dragged node into the group under the cursor,
-// unembedding it when dropped outside every group. Membership changes are
-// dispatched as AddToGroupCommand / RemoveFromGroupCommand so undo works, and
-// a per-group `memberValidation` predicate can veto a drop.
-//
-// Coordinate model: the whole engine stores ABSOLUTE coordinates (Wave-2
-// containment decision). Re-parenting therefore leaves a node's stored position
-// untouched — it stays exactly where the user dropped it — and we only recompute
-// the affected groups' derived bounds. `translateOnReparent` is the single seam
-// where a relative-coordinate model would translate; here it is the identity.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GroupMembershipService = void 0;
-const tslib_1 = require("tslib");
-const SpatialIndex_1 = require("../performance/SpatialIndex");
-const AddToGroupCommand_1 = require("../commands/basic/AddToGroupCommand");
-const RemoveFromGroupCommand_1 = require("../commands/basic/RemoveFromGroupCommand");
-class GroupMembershipService {
-    constructor(options) {
-        var _a;
-        this.diagram = options.diagram;
-        this.dispatcher = options.dispatcher;
-        this.index = new SpatialIndex_1.SpatialIndex({
-            cellSize: (_a = options.cellSize) !== null && _a !== void 0 ? _a : 100,
-            getBounds: (group) => this.groupRect(group),
-        });
-    }
-    /**
-     * Rebuild the spatial index from the diagram's current groups. Group counts
-     * are small relative to nodes, so a full refresh per interaction is cheap and
-     * always reflects freshly-dragged geometry.
-     */
-    refresh() {
-        this.index.clear();
-        for (const group of this.diagram.getGroups()) {
-            // Ensure a usable rectangle exists before indexing.
-            if (!group.bounds && !group.size && group.members.size > 0) {
-                group.calculateBounds(this.diagram);
-            }
-            const rect = this.groupRect(group);
-            if (rect.width > 0 || rect.height > 0) {
-                this.index.add(group);
-            }
-        }
-    }
-    /**
-     * Hit-test a point against group rectangles using the spatial index and
-     * return the innermost matching group (deepest nesting, then smallest area),
-     * so a nested child wins over its parent. Returns undefined when the point is
-     * outside every group.
-     */
-    hitTestGroup(point, options) {
-        this.refresh();
-        // Query a degenerate 1x1 region at the point; SpatialIndex returns every
-        // group whose cell overlaps, then we confirm true containment.
-        const candidates = this.index.queryRegion({ x: point.x, y: point.y, width: 0, height: 0 }, {
-            filter: (group) => {
-                var _a;
-                return !((_a = options === null || options === void 0 ? void 0 : options.excludeGroupIds) === null || _a === void 0 ? void 0 : _a.has(group.id)) &&
-                    this.rectContains(this.groupRect(group), point);
-            },
-        });
-        if (candidates.length === 0) {
-            return undefined;
-        }
-        // Innermost wins: sort by depth desc, then area asc.
-        candidates.sort((a, b) => {
-            const depthDiff = this.diagram.getDepth(b.id) - this.diagram.getDepth(a.id);
-            if (depthDiff !== 0) {
-                return depthDiff;
-            }
-            return this.rectArea(this.groupRect(a)) - this.rectArea(this.groupRect(b));
-        });
-        return candidates[0];
-    }
-    /**
-     * Return the first group that currently contains `entityId` as a direct
-     * member, or undefined. (Membership check over the small group set — this is
-     * not the spatial hit-test.)
-     */
-    getContainingGroup(entityId) {
-        for (const group of this.diagram.getGroups()) {
-            if (group.members.has(entityId)) {
-                return group;
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Highlight the group under the cursor during a drag and clear any previously
-     * hovered group. Returns the hovered group (or undefined). Drives the group's
-     * 'hover:changed' emitter so a renderer can outline the drop target.
-     */
-    updateHover(point, options) {
-        var _a;
-        const target = this.hitTestGroup(point, options);
-        if ((target === null || target === void 0 ? void 0 : target.id) === this.hoveredGroupId) {
-            return target;
-        }
-        // Clear previous highlight.
-        if (this.hoveredGroupId) {
-            (_a = this.diagram.getGroup(this.hoveredGroupId)) === null || _a === void 0 ? void 0 : _a.setHovered(false);
-        }
-        this.hoveredGroupId = target === null || target === void 0 ? void 0 : target.id;
-        target === null || target === void 0 ? void 0 : target.setHovered(true);
-        return target;
-    }
-    /** Clear any active hover highlight (call on drag-end / cancel). */
-    clearHover() {
-        var _a;
-        if (this.hoveredGroupId) {
-            (_a = this.diagram.getGroup(this.hoveredGroupId)) === null || _a === void 0 ? void 0 : _a.setHovered(false);
-            this.hoveredGroupId = undefined;
-        }
-    }
-    /**
-     * Handle a node drag-end at `point`: re-parent the node into the group under
-     * the cursor, or unembed it when dropped outside every group. No-op when the
-     * node is already in the target group. Rejected (no change) when the target
-     * group's validation/cycle rules veto the node.
-     */
-    handleNodeDragEnd(nodeId, point) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            const result = {
-                nodeId,
-                commands: [],
-                changed: false,
-                rejected: false,
-            };
-            const node = this.diagram.getNode(nodeId);
-            if (!node) {
-                this.clearHover();
-                return result;
-            }
-            const currentGroup = this.getContainingGroup(nodeId);
-            const target = this.hitTestGroup(point);
-            result.fromGroupId = currentGroup === null || currentGroup === void 0 ? void 0 : currentGroup.id;
-            result.toGroupId = target === null || target === void 0 ? void 0 : target.id;
-            // Dropped back into the same group (or stayed ungrouped): nothing to do.
-            if (((_a = target === null || target === void 0 ? void 0 : target.id) !== null && _a !== void 0 ? _a : undefined) === ((_b = currentGroup === null || currentGroup === void 0 ? void 0 : currentGroup.id) !== null && _b !== void 0 ? _b : undefined)) {
-                this.clearHover();
-                return result;
-            }
-            // Validate the destination before mutating anything.
-            if (target && !target.canAddMember(nodeId, this.diagram)) {
-                result.rejected = true;
-                this.clearHover();
-                return result;
-            }
-            // Leave the current group first so undo replays cleanly.
-            if (currentGroup) {
-                const remove = new RemoveFromGroupCommand_1.RemoveFromGroupCommand(currentGroup.id, nodeId);
-                yield this.dispatch(remove);
-                result.commands.push(remove);
-            }
-            // Join the target group (if any), translating coordinates on reparent.
-            if (target) {
-                this.translateOnReparent(node, currentGroup, target);
-                const add = new AddToGroupCommand_1.AddToGroupCommand(target.id, nodeId);
-                yield this.dispatch(add);
-                result.commands.push(add);
-                target.calculateBounds(this.diagram);
-            }
-            // Refresh the source group's derived bounds now that it lost a member.
-            if (currentGroup) {
-                currentGroup.calculateBounds(this.diagram);
-            }
-            result.changed = result.commands.length > 0;
-            this.clearHover();
-            return result;
-        });
-    }
-    /**
-     * Coordinate translation seam for reparenting. In the engine's ABSOLUTE model
-     * a node keeps its world position across a reparent (it stays where it was
-     * dropped), so this is the identity for `node.position`. Group bounds are
-     * derived from absolute member positions and are recomputed by the caller.
-     * Isolated here so a future relative-coordinate model has one place to change.
-     */
-    translateOnReparent(_node, _fromGroup, _toGroup) {
-        // Absolute storage: no position change on reparent (documented decision).
-    }
-    dispatch(command) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            if (this.dispatcher) {
-                yield this.dispatcher.execute(command);
-            }
-            else {
-                // Fallback: execute directly (not undoable) against a minimal context.
-                yield command.execute({ diagram: this.diagram, eventBus: undefined });
-            }
-        });
-    }
-    /**
-     * Resolve a group's screen rectangle for spatial indexing / hit-testing.
-     *
-     * The PAINTED frame (explicit position + size) must win over the derived
-     * member `bounds`, exactly as GroupModel.getOuterBounds() orders them. This
-     * method used to prefer `bounds` — which handleNodeDragEnd overwrites with
-     * the tight member bbox after every membership change — so once anything was
-     * dragged in or out, the drop target silently shrank from the frame the user
-     * SEES to an invisible box around the remaining members, and drops in the
-     * frame's empty margin stopped adopting (visio audit, empirically
-     * reproduced: drag-out worked, the next drag-in near the frame edge did
-     * nothing).
-     */
-    groupRect(group) {
-        if (typeof group.getOuterBounds === 'function') {
-            return group.getOuterBounds();
-        }
-        if (group.size) {
-            return {
-                x: group.position.x,
-                y: group.position.y,
-                width: group.size.width,
-                height: group.size.height,
-            };
-        }
-        if (group.bounds) {
-            return {
-                x: group.bounds.x,
-                y: group.bounds.y,
-                width: group.bounds.width,
-                height: group.bounds.height,
-            };
-        }
-        return { x: group.position.x, y: group.position.y, width: 0, height: 0 };
-    }
-    rectContains(rect, point) {
-        return (point.x >= rect.x &&
-            point.x <= rect.x + rect.width &&
-            point.y >= rect.y &&
-            point.y <= rect.y + rect.height);
-    }
-    rectArea(rect) {
-        return rect.width * rect.height;
-    }
-}
-exports.GroupMembershipService = GroupMembershipService;
-//# sourceMappingURL=GroupMembershipService.js.map

package/src/libs/engine/src/interaction/SemanticMembershipService.d.ts

@@ -1,28 +0,0 @@
-import type { DiagramModel } from '../models/DiagramModel';
-import type { GroupModel, MembershipRule } from '../models/GroupModel';
-import type { NodeModel } from '../models/NodeModel';
-/** Evaluate a declarative rule against a node's `data`. Pure + serializable. */
-export declare function matchesRule(rule: MembershipRule, node: NodeModel): boolean;
-export declare class SemanticMembershipService {
-    private readonly diagram;
-    private readonly managed;
-    private readonly diagramDisposers;
-    private evaluating;
-    constructor(diagram: DiagramModel);
-    /**
-     * Start managing `group`'s auto-membership from its serialized
-     * `membershipRule`. Runs an initial sweep and then keeps in sync reactively.
-     * No-op if the group has no rule. Returns a disposer that stops managing it.
-     */
-    register(group: GroupModel): () => void;
-    /** Stop managing every group and detach all model listeners. */
-    dispose(): void;
-    /** Re-evaluate a single node against every managed rule-group. */
-    evaluateNode(node: NodeModel): void;
-    /** Re-evaluate every node against one group's rule. */
-    evaluateGroup(group: GroupModel): void;
-    private applyMembership;
-    private autoGroups;
-    private tagAuto;
-    private ensureSubscribed;
-}