@grafloria/element 0.3.20 → 0.3.21

package/src/libs/engine/src/commands/basic/AddToGroupCommand.js

@@ -1,73 +0,0 @@
-"use strict";
-// AddToGroupCommand - Adds an entity to a group (Phase 1.6c)
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AddToGroupCommand = void 0;
-const Command_1 = require("../Command");
-class AddToGroupCommand extends Command_1.Command {
-    constructor(groupId, entityId) {
-        super('Add To Group');
-        this.groupId = groupId;
-        this.entityId = entityId;
-    }
-    execute(context) {
-        const diagram = context.diagram;
-        if (!diagram) {
-            throw new Error('Diagram not found in context');
-        }
-        const group = diagram.getGroup(this.groupId);
-        if (!group) {
-            throw new Error(`Group ${this.groupId} not found`);
-        }
-        group.addMember(this.entityId);
-    }
-    undo(context) {
-        const diagram = context.diagram;
-        if (!diagram) {
-            throw new Error('Diagram not found in context');
-        }
-        const group = diagram.getGroup(this.groupId);
-        if (!group) {
-            throw new Error(`Group ${this.groupId} not found`);
-        }
-        group.removeMember(this.entityId);
-    }
-    canExecute(context) {
-        if (!context.diagram) {
-            return false;
-        }
-        // Check group exists
-        const group = context.diagram.getGroup(this.groupId);
-        if (!group) {
-            return false;
-        }
-        // Check entity exists (node, link, or nested group). Groups may be members
-        // of groups for compound-graph nesting (Wave-2).
-        const entityExists = context.diagram.nodes.has(this.entityId) ||
-            context.diagram.links.has(this.entityId) ||
-            context.diagram.groups.has(this.entityId);
-        return entityExists;
-    }
-    canUndo(context) {
-        if (!context.diagram) {
-            return false;
-        }
-        const group = context.diagram.getGroup(this.groupId);
-        return !!group && group.members.has(this.entityId);
-    }
-    serialize() {
-        return {
-            id: this.id,
-            name: this.name,
-            timestamp: this.timestamp,
-            data: {
-                groupId: this.groupId,
-                entityId: this.entityId,
-            },
-        };
-    }
-    getDescription() {
-        return `Add entity ${this.entityId} to group ${this.groupId}`;
-    }
-}
-exports.AddToGroupCommand = AddToGroupCommand;
-//# sourceMappingURL=AddToGroupCommand.js.map

package/src/libs/engine/src/commands/basic/AlignCommands.d.ts

@@ -1,42 +0,0 @@
-import { Command, CommandContext, SerializedCommand } from '../Command';
-import { NodeModel } from '../../models/NodeModel';
-export type AlignEdge = 'left' | 'right' | 'top' | 'bottom' | 'center-x' | 'center-y';
-export type DistributeAxis = 'horizontal' | 'vertical';
-interface XY {
-    x: number;
-    y: number;
-}
-/** Shared machinery: snapshot every node's start position, move to computed
- *  targets on execute, restore the snapshot on undo. */
-declare abstract class MultiNodeArrangeCommand extends Command {
-    protected readonly nodeIds: string[];
-    private readonly before;
-    protected constructor(name: string, nodeIds: string[]);
-    /** Return the target position for each node that should move (id → {x,y}). */
-    protected abstract targets(nodes: NodeModel[]): Map<string, XY>;
-    /** Minimum node count for the op to mean anything (align: 2, distribute: 3). */
-    protected minNodes(): number;
-    private liveNodes;
-    execute(context: CommandContext): void;
-    undo(context: CommandContext): void;
-    canExecute(context: CommandContext): boolean;
-    canUndo(context: CommandContext): boolean;
-    serialize(): SerializedCommand;
-}
-/** Align the selected nodes to a shared edge or centre line. */
-export declare class AlignCommand extends MultiNodeArrangeCommand {
-    private readonly edge;
-    constructor(nodeIds: string[], edge: AlignEdge);
-    protected targets(nodes: NodeModel[]): Map<string, XY>;
-    getDescription(): string;
-}
-/** Space the selected nodes with EQUAL GAPS along an axis; the two extreme
- *  nodes stay put and the interior ones are redistributed between them. */
-export declare class DistributeCommand extends MultiNodeArrangeCommand {
-    private readonly axis;
-    constructor(nodeIds: string[], axis: DistributeAxis);
-    protected minNodes(): number;
-    protected targets(nodes: NodeModel[]): Map<string, XY>;
-    getDescription(): string;
-}
-export {};

package/src/libs/engine/src/commands/basic/AlignCommands.js

@@ -1,138 +0,0 @@
-"use strict";
-// Align & Distribute — Visio/Figma-style multi-node arrangement, as ONE undoable
-// step each. Pure bounding-box geometry (the engine is the lower layer and can't
-// reach the renderer's live-drag SnapController — and it shouldn't: this is a
-// discrete operation, not a per-frame snap).
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DistributeCommand = exports.AlignCommand = void 0;
-const Command_1 = require("../Command");
-/** Shared machinery: snapshot every node's start position, move to computed
- *  targets on execute, restore the snapshot on undo. */
-class MultiNodeArrangeCommand extends Command_1.Command {
-    constructor(name, nodeIds) {
-        super(name);
-        this.nodeIds = nodeIds;
-        this.before = new Map();
-    }
-    /** Minimum node count for the op to mean anything (align: 2, distribute: 3). */
-    minNodes() { return 2; }
-    liveNodes(context) {
-        const diagram = context.diagram;
-        if (!diagram)
-            throw new Error('Diagram not found in context');
-        return this.nodeIds
-            .map((id) => diagram.getNode(id))
-            .filter((n) => !!n && !n.state.locked);
-    }
-    execute(context) {
-        const nodes = this.liveNodes(context);
-        if (this.before.size === 0) {
-            for (const n of nodes)
-                this.before.set(n.id, { x: n.position.x, y: n.position.y });
-        }
-        const targets = this.targets(nodes);
-        for (const n of nodes) {
-            const t = targets.get(n.id);
-            if (t)
-                n.setPosition(t.x, t.y);
-        }
-    }
-    undo(context) {
-        const diagram = context.diagram;
-        if (!diagram)
-            throw new Error('Diagram not found in context');
-        for (const [id, p] of this.before) {
-            const n = diagram.getNode(id);
-            if (n)
-                n.setPosition(p.x, p.y);
-        }
-    }
-    canExecute(context) {
-        return !!context.diagram && this.nodeIds.length >= this.minNodes();
-    }
-    canUndo(context) {
-        return !!context.diagram && this.before.size > 0;
-    }
-    serialize() {
-        return { id: this.id, name: this.name, timestamp: this.timestamp, data: { nodeIds: this.nodeIds } };
-    }
-}
-/** Align the selected nodes to a shared edge or centre line. */
-class AlignCommand extends MultiNodeArrangeCommand {
-    constructor(nodeIds, edge) {
-        super(`Align ${edge}`, nodeIds);
-        this.edge = edge;
-    }
-    targets(nodes) {
-        const map = new Map();
-        if (nodes.length < 2)
-            return map;
-        const b = nodes.map((n) => ({
-            id: n.id, x: n.position.x, y: n.position.y, w: n.size.width, h: n.size.height,
-        }));
-        const minL = Math.min(...b.map((n) => n.x));
-        const maxR = Math.max(...b.map((n) => n.x + n.w));
-        const minT = Math.min(...b.map((n) => n.y));
-        const maxB = Math.max(...b.map((n) => n.y + n.h));
-        for (const n of b) {
-            switch (this.edge) {
-                case 'left':
-                    map.set(n.id, { x: minL, y: n.y });
-                    break;
-                case 'right':
-                    map.set(n.id, { x: maxR - n.w, y: n.y });
-                    break;
-                case 'top':
-                    map.set(n.id, { x: n.x, y: minT });
-                    break;
-                case 'bottom':
-                    map.set(n.id, { x: n.x, y: maxB - n.h });
-                    break;
-                case 'center-x':
-                    map.set(n.id, { x: (minL + maxR) / 2 - n.w / 2, y: n.y });
-                    break;
-                case 'center-y':
-                    map.set(n.id, { x: n.x, y: (minT + maxB) / 2 - n.h / 2 });
-                    break;
-            }
-        }
-        return map;
-    }
-    getDescription() { return `Align ${this.edge} (${this.nodeIds.length} nodes)`; }
-}
-exports.AlignCommand = AlignCommand;
-/** Space the selected nodes with EQUAL GAPS along an axis; the two extreme
- *  nodes stay put and the interior ones are redistributed between them. */
-class DistributeCommand extends MultiNodeArrangeCommand {
-    constructor(nodeIds, axis) {
-        super(`Distribute ${axis}`, nodeIds);
-        this.axis = axis;
-    }
-    minNodes() { return 3; }
-    targets(nodes) {
-        const map = new Map();
-        if (nodes.length < 3)
-            return map;
-        const horiz = this.axis === 'horizontal';
-        const b = nodes.map((n) => ({
-            id: n.id, x: n.position.x, y: n.position.y,
-            pos: horiz ? n.position.x : n.position.y,
-            size: horiz ? n.size.width : n.size.height,
-        })).sort((p, q) => p.pos - q.pos);
-        const first = b[0];
-        const last = b[b.length - 1];
-        const span = (last.pos + last.size) - first.pos; // outer edge to outer edge
-        const totalSize = b.reduce((s, n) => s + n.size, 0);
-        const gap = (span - totalSize) / (b.length - 1); // equal gap between neighbours
-        let cursor = first.pos + first.size + gap; // first & last are anchors
-        for (let i = 1; i < b.length - 1; i++) {
-            const n = b[i];
-            map.set(n.id, horiz ? { x: cursor, y: n.y } : { x: n.x, y: cursor });
-            cursor += n.size + gap;
-        }
-        return map;
-    }
-    getDescription() { return `Distribute ${this.axis} (${this.nodeIds.length} nodes)`; }
-}
-exports.DistributeCommand = DistributeCommand;
-//# sourceMappingURL=AlignCommands.js.map

package/src/libs/engine/src/commands/basic/CollapseGroupCommand.d.ts

@@ -1,14 +0,0 @@
-import { Command, CommandContext, SerializedCommand } from '../Command';
-import { CollapseOptions } from '../../interaction/GroupCollapseService';
-export declare class CollapseGroupCommand extends Command {
-    private groupId;
-    private options?;
-    private wasExpanded?;
-    constructor(groupId: string, options?: CollapseOptions | undefined);
-    execute(context: CommandContext): void;
-    undo(context: CommandContext): void;
-    canExecute(context: CommandContext): boolean;
-    canUndo(context: CommandContext): boolean;
-    serialize(): SerializedCommand;
-    getDescription(): string;
-}

package/src/libs/engine/src/commands/basic/CollapseGroupCommand.js

@@ -1,70 +0,0 @@
-"use strict";
-// CollapseGroupCommand - Collapses an expanded group (Phase 1.6c)
-//
-// Wave-5 Card 4: this now performs a REAL collapse (hide members, save layout,
-// re-home boundary edges to aggregated proxy links, shrink to a placeholder)
-// via GroupCollapseService — all inside one command so it is a single undo step.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CollapseGroupCommand = void 0;
-const Command_1 = require("../Command");
-const GroupCollapseService_1 = require("../../interaction/GroupCollapseService");
-class CollapseGroupCommand extends Command_1.Command {
-    constructor(groupId, options) {
-        super('Collapse Group');
-        this.groupId = groupId;
-        this.options = options;
-    }
-    execute(context) {
-        const diagram = context.diagram;
-        if (!diagram) {
-            throw new Error('Diagram not found in context');
-        }
-        const group = diagram.getGroup(this.groupId);
-        if (!group) {
-            throw new Error(`Group ${this.groupId} not found`);
-        }
-        // Store previous state for undo
-        this.wasExpanded = !group.isCollapsed;
-        new GroupCollapseService_1.GroupCollapseService(diagram).collapse(group, this.options);
-    }
-    undo(context) {
-        const diagram = context.diagram;
-        if (!diagram) {
-            throw new Error('Diagram not found in context');
-        }
-        const group = diagram.getGroup(this.groupId);
-        if (!group) {
-            throw new Error(`Group ${this.groupId} not found`);
-        }
-        // Restore previous state — expand reverses the collapse exactly.
-        if (this.wasExpanded) {
-            new GroupCollapseService_1.GroupCollapseService(diagram).expand(group);
-        }
-    }
-    canExecute(context) {
-        if (!context.diagram) {
-            return false;
-        }
-        const group = context.diagram.getGroup(this.groupId);
-        return !!group;
-    }
-    canUndo(context) {
-        return this.canExecute(context) && this.wasExpanded !== undefined;
-    }
-    serialize() {
-        return {
-            id: this.id,
-            name: this.name,
-            timestamp: this.timestamp,
-            data: {
-                groupId: this.groupId,
-                wasExpanded: this.wasExpanded,
-            },
-        };
-    }
-    getDescription() {
-        return `Collapse group ${this.groupId}`;
-    }
-}
-exports.CollapseGroupCommand = CollapseGroupCommand;
-//# sourceMappingURL=CollapseGroupCommand.js.map

package/src/libs/engine/src/commands/basic/CopyCommand.d.ts

@@ -1,29 +0,0 @@
-import { Command, CommandContext, SerializedCommand } from '../Command';
-import type { ClipboardManager } from '../../clipboard/ClipboardManager';
-/**
- * CopyCommand copies selected entities to clipboard
- *
- * Features:
- * - Copies selected nodes
- * - Includes links between selected nodes
- * - Optionally includes groups containing selected nodes
- * - Non-destructive (doesn't modify diagram)
- */
-export declare class CopyCommand extends Command {
-    private clipboard;
-    private options;
-    private copiedNodeIds;
-    private copiedLinkIds;
-    private copiedGroupIds;
-    constructor(clipboard: ClipboardManager, options?: {
-        includeGroups?: boolean;
-        includeLinks?: boolean;
-    });
-    execute(context: CommandContext): void;
-    undo(context: CommandContext): void;
-    canExecute(context: CommandContext): boolean;
-    canUndo(context: CommandContext): boolean;
-    isUndoable(): boolean;
-    serialize(): SerializedCommand;
-    getDescription(): string;
-}

package/src/libs/engine/src/commands/basic/CopyCommand.js

@@ -1,131 +0,0 @@
-"use strict";
-// CopyCommand - Copy selected entities to clipboard (Phase 1.8)
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CopyCommand = void 0;
-const Command_1 = require("../Command");
-const resolveLinkNodeIds_1 = require("./resolveLinkNodeIds");
-/**
- * CopyCommand copies selected entities to clipboard
- *
- * Features:
- * - Copies selected nodes
- * - Includes links between selected nodes
- * - Optionally includes groups containing selected nodes
- * - Non-destructive (doesn't modify diagram)
- */
-class CopyCommand extends Command_1.Command {
-    constructor(clipboard, options = {}) {
-        super('Copy');
-        this.clipboard = clipboard;
-        this.options = options;
-        this.copiedNodeIds = [];
-        this.copiedLinkIds = [];
-        this.copiedGroupIds = [];
-    }
-    execute(context) {
-        var _a;
-        const diagram = context.diagram;
-        if (!diagram) {
-            throw new Error('Diagram not found in context');
-        }
-        // Get selected nodes — from the DIAGRAM, the same source Delete and
-        // select-all use. The store's 'selectedNodes' set is only written by
-        // SelectionManager API calls; a MOUSE click selects through
-        // diagram.selectNode() and never touches it, so reading the store made
-        // ⌘C throw "No nodes selected" for anything a visitor clicked (live
-        // audit: copy-paste dead end-to-end while the API-driven demo assert
-        // stayed green — the click-vs-API seam). The store set is kept as a
-        // fallback for headless callers that only used the SelectionManager.
-        const diagramSelection = diagram.getSelectedNodes().map((n) => n.id);
-        const storeSelection = (_a = context.store) === null || _a === void 0 ? void 0 : _a.get('selectedNodes');
-        const selectedNodeIds = diagramSelection.length > 0 ? diagramSelection : Array.from(storeSelection !== null && storeSelection !== void 0 ? storeSelection : []);
-        if (selectedNodeIds.length === 0) {
-            throw new Error('No nodes selected');
-        }
-        this.copiedNodeIds = selectedNodeIds;
-        // Get nodes
-        const nodes = this.copiedNodeIds
-            .map(id => diagram.getNode(id))
-            .filter(n => n !== undefined);
-        // Get links between selected nodes (if enabled)
-        const links = [];
-        if (this.options.includeLinks !== false) {
-            const nodeIdSet = new Set(this.copiedNodeIds);
-            const allLinks = diagram.getLinks();
-            for (const link of allLinks) {
-                // Include link if both source and target nodes are selected.
-                // Endpoints are PORT ids (nanoids), so the owning nodes must be resolved
-                // through the port index — see resolveLinkNodeIds().
-                const { sourceNodeId, targetNodeId } = (0, resolveLinkNodeIds_1.resolveLinkNodeIds)(diagram, link);
-                if (sourceNodeId && targetNodeId &&
-                    nodeIdSet.has(sourceNodeId) &&
-                    nodeIdSet.has(targetNodeId)) {
-                    links.push(link);
-                    this.copiedLinkIds.push(link.id);
-                }
-            }
-        }
-        // Get groups (if enabled)
-        const groups = [];
-        if (this.options.includeGroups) {
-            const allGroups = diagram.getGroups();
-            const nodeIdSet = new Set(this.copiedNodeIds);
-            for (const group of allGroups) {
-                // Include group if any of its members are selected
-                const hasSelectedMember = Array.from(group.members).some(memberId => nodeIdSet.has(memberId));
-                if (hasSelectedMember) {
-                    groups.push(group);
-                    this.copiedGroupIds.push(group.id);
-                }
-            }
-        }
-        // Copy to clipboard
-        this.clipboard.copy({
-            nodes,
-            links,
-            groups,
-            sourceDiagramId: diagram.id,
-        });
-    }
-    undo(context) {
-        // Copy is non-destructive, no undo needed
-        // But we could restore previous clipboard state if needed
-    }
-    canExecute(context) {
-        var _a;
-        if (!context.diagram)
-            return false;
-        if (context.diagram.getSelectedNodes().length > 0)
-            return true;
-        const selectedNodes = (_a = context.store) === null || _a === void 0 ? void 0 : _a.get('selectedNodes');
-        return selectedNodes !== undefined && selectedNodes.size > 0;
-    }
-    canUndo(context) {
-        // Copy doesn't modify diagram, no undo needed
-        return false;
-    }
-    isUndoable() {
-        // Non-mutating: must never enter the undo stack. When it did, undo() threw
-        // "Cannot undo command: Copy" and stranded the whole history behind it.
-        return false;
-    }
-    serialize() {
-        return {
-            id: this.id,
-            name: this.name,
-            timestamp: this.timestamp,
-            data: {
-                copiedNodeIds: this.copiedNodeIds,
-                copiedLinkIds: this.copiedLinkIds,
-                copiedGroupIds: this.copiedGroupIds,
-                options: this.options,
-            },
-        };
-    }
-    getDescription() {
-        const count = this.copiedNodeIds.length;
-        return `Copy ${count} node${count !== 1 ? 's' : ''}`;
-    }
-}
-exports.CopyCommand = CopyCommand;
-//# sourceMappingURL=CopyCommand.js.map

package/src/libs/engine/src/commands/basic/CutCommand.d.ts

@@ -1,49 +0,0 @@
-import { CommandContext } from '../Command';
-import { MacroCommand } from '../composite/MacroCommand';
-import type { ClipboardManager } from '../../clipboard/ClipboardManager';
-export interface CutCommandOptions {
-    /** Include groups containing selected nodes in the clipboard payload (default: false) */
-    includeGroups?: boolean;
-    /** Include links between copied nodes in the clipboard payload (default: true) */
-    includeLinks?: boolean;
-    /** Delete child nodes recursively (default: true) */
-    deleteChildren?: boolean;
-    /** Delete links connected to the deleted nodes (default: true) */
-    deleteLinks?: boolean;
-}
-/**
- * CutCommand = {@link CopyCommand} + {@link DeleteSelectionCommand}, executed as
- * ONE undoable step (a {@link MacroCommand}): the selection lands on the
- * clipboard and is removed from the diagram, and a single undo brings it back.
- *
- * Two inherited behaviours had to be overridden — both are load-bearing:
- *
- *  1. `canUndo`. {@link MacroCommand.canUndo} is the AND of its steps, and
- *     {@link CopyCommand.canUndo} returns FALSE by design (a copy mutates
- *     nothing, so it has nothing to undo). The inherited implementation would
- *     therefore report a Cut as un-undoable and `CommandManager.undo()` would
- *     throw `Cannot undo command: Cut`. A cut is undoable exactly when its
- *     delete half is.
- *
- *  2. `redo`. The default redo re-runs `execute()`, which re-runs the COPY step
- *     — and copy reads the CURRENT selection. `undo()` restores the entities but
- *     NOT the selection, so that copy would throw `No nodes selected`. The
- *     clipboard already holds this cut's payload, so a redo is precisely
- *     "delete those same entities again", which the delete half can replay from
- *     its own recorded data.
- */
-export declare class CutCommand extends MacroCommand {
-    private readonly copyCommand;
-    private readonly deleteCommand;
-    constructor(clipboard: ClipboardManager, options?: CutCommandOptions);
-    /**
-     * A cut needs something to copy: CopyCommand has no link-only payload, so a
-     * selection of links alone cannot be cut (it can still be deleted).
-     */
-    canExecute(context: CommandContext): boolean;
-    /** See class docs (1): copy is non-undoable by design; the delete half decides. */
-    canUndo(context: CommandContext): boolean;
-    /** See class docs (2): replay the delete from its recorded data, never the copy. */
-    redo(context: CommandContext): Promise<void>;
-    getDescription(): string;
-}

package/src/libs/engine/src/commands/basic/CutCommand.js

@@ -1,68 +0,0 @@
-"use strict";
-// CutCommand - Copy the selection to the clipboard, then delete it (wave3/interaction)
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CutCommand = void 0;
-const tslib_1 = require("tslib");
-const MacroCommand_1 = require("../composite/MacroCommand");
-const CopyCommand_1 = require("./CopyCommand");
-const DeleteSelectionCommand_1 = require("./DeleteSelectionCommand");
-/**
- * CutCommand = {@link CopyCommand} + {@link DeleteSelectionCommand}, executed as
- * ONE undoable step (a {@link MacroCommand}): the selection lands on the
- * clipboard and is removed from the diagram, and a single undo brings it back.
- *
- * Two inherited behaviours had to be overridden — both are load-bearing:
- *
- *  1. `canUndo`. {@link MacroCommand.canUndo} is the AND of its steps, and
- *     {@link CopyCommand.canUndo} returns FALSE by design (a copy mutates
- *     nothing, so it has nothing to undo). The inherited implementation would
- *     therefore report a Cut as un-undoable and `CommandManager.undo()` would
- *     throw `Cannot undo command: Cut`. A cut is undoable exactly when its
- *     delete half is.
- *
- *  2. `redo`. The default redo re-runs `execute()`, which re-runs the COPY step
- *     — and copy reads the CURRENT selection. `undo()` restores the entities but
- *     NOT the selection, so that copy would throw `No nodes selected`. The
- *     clipboard already holds this cut's payload, so a redo is precisely
- *     "delete those same entities again", which the delete half can replay from
- *     its own recorded data.
- */
-class CutCommand extends MacroCommand_1.MacroCommand {
-    constructor(clipboard, options = {}) {
-        super('Cut');
-        this.copyCommand = new CopyCommand_1.CopyCommand(clipboard, {
-            includeGroups: options.includeGroups,
-            includeLinks: options.includeLinks,
-        });
-        this.deleteCommand = new DeleteSelectionCommand_1.DeleteSelectionCommand({
-            deleteChildren: options.deleteChildren,
-            deleteLinks: options.deleteLinks,
-        });
-        // Order matters: copy the payload BEFORE the delete tears the entities out
-        // of the diagram (CopyCommand serializes live models, not ids).
-        this.addStep(this.copyCommand);
-        this.addStep(this.deleteCommand);
-    }
-    /**
-     * A cut needs something to copy: CopyCommand has no link-only payload, so a
-     * selection of links alone cannot be cut (it can still be deleted).
-     */
-    canExecute(context) {
-        return super.canExecute(context);
-    }
-    /** See class docs (1): copy is non-undoable by design; the delete half decides. */
-    canUndo(context) {
-        return this.deleteCommand.canUndo(context);
-    }
-    /** See class docs (2): replay the delete from its recorded data, never the copy. */
-    redo(context) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            yield this.deleteCommand.redo(context);
-        });
-    }
-    getDescription() {
-        return this.deleteCommand.getDescription().replace(/^Delete/, 'Cut');
-    }
-}
-exports.CutCommand = CutCommand;
-//# sourceMappingURL=CutCommand.js.map

package/src/libs/engine/src/commands/basic/DeleteSelectionCommand.d.ts

@@ -1,58 +0,0 @@
-import { Command, CommandContext, SerializedCommand } from '../Command';
-/**
- * DeleteSelectionCommand deletes selected entities from diagram
- *
- * Features:
- * - Deletes selected nodes, links, and groups
- * - Recursively deletes child nodes
- * - Removes links connected to deleted nodes
- * - Removes nodes from groups they belong to
- * - Stores all deleted data for undo
- * - Supports undo/redo
- */
-export declare class DeleteSelectionCommand extends Command {
-    private options;
-    private deletedNodes;
-    private deletedLinks;
-    private deletedGroups;
-    private affectedGroups;
-    constructor(options?: {
-        deleteChildren?: boolean;
-        /**
-         * Proactively delete connected links in a first pass (default: true).
-         *
-         * Since wave 10, `DiagramModel.removeNode()` CASCADES the node's links —
-         * a link to nowhere is not a link — so `false` cannot keep a deleted
-         * node's links alive; they are removed either way. What `false` controls
-         * is only the removal ORDER (cascade instead of an explicit pre-pass).
-         * Every cascaded link is still recorded, so undo restores the diagram
-         * whole under both settings.
-         */
-        deleteLinks?: boolean;
-    });
-    execute(context: CommandContext): void;
-    undo(context: CommandContext): void;
-    /**
-     * Redo re-applies the RECORDED deletion instead of re-running execute().
-     *
-     * The default `Command.redo()` calls `execute()`, which reads the LIVE
-     * selection — but `undo()` restores the entities WITHOUT restoring the
-     * selection, so a redo would find an empty selection and throw
-     * `No entities selected`. Redo therefore removes exactly the entities this
-     * command removed the first time. The recorded arrays are left intact, so the
-     * command can be undone again afterwards (undo/redo/undo/redo all work).
-     */
-    redo(context: CommandContext): void;
-    canExecute(context: CommandContext): boolean;
-    canUndo(context: CommandContext): boolean;
-    serialize(): SerializedCommand;
-    getDescription(): string;
-    /**
-     * Recursively collect node IDs to delete (including children if enabled)
-     */
-    private collectNodeIdsToDelete;
-    /**
-     * Get hierarchy depth of a node (root = 0)
-     */
-    private getNodeDepth;
-}