@grafloria/element 0.3.20 → 0.3.22

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

@@ -1,46 +0,0 @@
-import { Command, CommandContext, SerializedCommand } from '../Command';
-import { Point } from '../../types';
-/** A group frame's restorable geometry (matches GroupModel.restoreGeometry). */
-export interface GroupFrameSnapshot {
-    position: {
-        x: number;
-        y: number;
-    };
-    size?: {
-        width: number;
-        height: number;
-        depth: number;
-    };
-    bounds?: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    };
-}
-/** One member node's absolute move. */
-export interface GroupNodeMove {
-    nodeId: string;
-    from: Point;
-    to: Point;
-}
-/** One (nested) group frame's move. */
-export interface GroupFrameMove {
-    groupId: string;
-    from: GroupFrameSnapshot;
-    to: GroupFrameSnapshot;
-}
-export declare class MoveGroupCommand extends Command {
-    private readonly nodeMoves;
-    private readonly frameMoves;
-    constructor(nodeMoves: GroupNodeMove[], frameMoves: GroupFrameMove[]);
-    execute(context: CommandContext): void;
-    undo(context: CommandContext): void;
-    private apply;
-    canExecute(context: CommandContext): boolean;
-    canUndo(context: CommandContext): boolean;
-    /** True when the gesture actually moved something (drop == press is a no-op). */
-    isNoop(): boolean;
-    serialize(): SerializedCommand;
-    getDescription(): string;
-}

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

@@ -1,77 +0,0 @@
-"use strict";
-// MoveGroupCommand — move a group (subflow container) AND its contents as ONE
-// undoable step (wave12/connect-ergonomics, gap 1: "move parent → children follow").
-//
-// The engine stores ABSOLUTE coordinates (the Wave-2 containment decision), so a
-// group's member nodes do NOT track the group frame automatically — moving the
-// container has to translate every member's world position explicitly. This
-// command carries the whole subflow: the group frame(s) and every member node
-// (recursively through nested groups), captured as an absolute FROM→TO snapshot.
-//
-// Why a snapshot and not a delta: the live drag translates everything for visual
-// feedback BEFORE the gesture ends, so a delta-based execute() would double-apply
-// on commit. Storing absolute from/to makes execute() idempotent — it sets the
-// already-current `to`, records one history entry, and undo restores `from`.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MoveGroupCommand = void 0;
-const Command_1 = require("../Command");
-class MoveGroupCommand extends Command_1.Command {
-    constructor(nodeMoves, frameMoves) {
-        super('Move Group');
-        this.nodeMoves = nodeMoves;
-        this.frameMoves = frameMoves;
-    }
-    execute(context) {
-        this.apply(context, 'to');
-    }
-    undo(context) {
-        this.apply(context, 'from');
-    }
-    apply(context, key) {
-        const diagram = context.diagram;
-        if (!diagram) {
-            throw new Error('Diagram not found in context');
-        }
-        for (const move of this.nodeMoves) {
-            const node = diagram.getNode(move.nodeId);
-            if (!node)
-                continue;
-            const p = move[key];
-            node.setPosition(p.x, p.y, p.z);
-        }
-        for (const move of this.frameMoves) {
-            const group = diagram.getGroup(move.groupId);
-            if (!group)
-                continue;
-            const snap = move[key];
-            group.restoreGeometry({
-                position: Object.assign({}, snap.position),
-                size: snap.size ? Object.assign({}, snap.size) : undefined,
-                bounds: snap.bounds ? Object.assign({}, snap.bounds) : undefined,
-            });
-        }
-    }
-    canExecute(context) {
-        return !!context.diagram;
-    }
-    canUndo(context) {
-        return !!context.diagram;
-    }
-    /** True when the gesture actually moved something (drop == press is a no-op). */
-    isNoop() {
-        return this.nodeMoves.length === 0 && this.frameMoves.length === 0;
-    }
-    serialize() {
-        return {
-            id: this.id,
-            name: this.name,
-            timestamp: this.timestamp,
-            data: { nodeMoves: this.nodeMoves, frameMoves: this.frameMoves },
-        };
-    }
-    getDescription() {
-        return `Move group (${this.nodeMoves.length} nodes, ${this.frameMoves.length} frames)`;
-    }
-}
-exports.MoveGroupCommand = MoveGroupCommand;
-//# sourceMappingURL=MoveGroupCommand.js.map

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

@@ -1,30 +0,0 @@
-import { Command, CommandContext, SerializedCommand } from '../Command';
-import { Point } from '../../types';
-export interface MoveNodeCommandOptions {
-    /**
-     * Whether CommandManager may MERGE this move into the previous one for the
-     * same node (default: true, preserving the historic behaviour).
-     *
-     * Merging exists for callers that stream many small moves (e.g. one command
-     * per pointer-move). A caller that already commits ONE command per completed
-     * gesture must opt OUT: otherwise two separate drags of the same node landing
-     * inside CommandManager's merge window (500ms) collapse into a single undo
-     * step, and one Ctrl+Z would rewind BOTH gestures.
-     */
-    mergeable?: boolean;
-}
-export declare class MoveNodeCommand extends Command {
-    private nodeId;
-    private oldPosition?;
-    private newPosition;
-    private readonly mergeable;
-    constructor(nodeId: string, newPosition: Point, oldPosition?: Point, options?: MoveNodeCommandOptions);
-    execute(context: CommandContext): void;
-    undo(context: CommandContext): void;
-    canExecute(context: CommandContext): boolean;
-    canUndo(context: CommandContext): boolean;
-    canMergeWith(other: Command): boolean;
-    mergeWith(other: Command): Command;
-    serialize(): SerializedCommand;
-    getDescription(): string;
-}

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

@@ -1,87 +0,0 @@
-"use strict";
-// MoveNodeCommand - Moves a node to a new position
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MoveNodeCommand = void 0;
-const Command_1 = require("../Command");
-class MoveNodeCommand extends Command_1.Command {
-    constructor(nodeId, newPosition, oldPosition, options = {}) {
-        super('Move Node');
-        this.nodeId = nodeId;
-        this.newPosition = Object.assign({}, newPosition);
-        if (oldPosition) {
-            this.oldPosition = Object.assign({}, oldPosition);
-        }
-        this.mergeable = options.mergeable !== false;
-    }
-    execute(context) {
-        const diagram = context.diagram;
-        if (!diagram) {
-            throw new Error('Diagram not found in context');
-        }
-        const node = diagram.getNode(this.nodeId);
-        if (!node) {
-            throw new Error(`Node ${this.nodeId} not found`);
-        }
-        // Save old position for undo
-        if (!this.oldPosition) {
-            this.oldPosition = Object.assign({}, node.position);
-        }
-        // Move node
-        node.setPosition(this.newPosition.x, this.newPosition.y, this.newPosition.z);
-    }
-    undo(context) {
-        const diagram = context.diagram;
-        if (!diagram || !this.oldPosition) {
-            throw new Error('Cannot undo: missing diagram or old position');
-        }
-        const node = diagram.getNode(this.nodeId);
-        if (!node) {
-            throw new Error(`Node ${this.nodeId} not found`);
-        }
-        // Restore old position
-        node.setPosition(this.oldPosition.x, this.oldPosition.y, this.oldPosition.z);
-    }
-    canExecute(context) {
-        return context.diagram && context.diagram.nodes.has(this.nodeId);
-    }
-    canUndo(context) {
-        return context.diagram && !!this.oldPosition;
-    }
-    canMergeWith(other) {
-        if (!(other instanceof MoveNodeCommand)) {
-            return false;
-        }
-        // A gesture-committed move opts out of merging (see MoveNodeCommandOptions):
-        // one gesture must stay one undo step.
-        if (!this.mergeable || !other.mergeable) {
-            return false;
-        }
-        // Can merge if same node
-        return this.nodeId === other.nodeId;
-    }
-    mergeWith(other) {
-        if (!(other instanceof MoveNodeCommand)) {
-            throw new Error('Cannot merge with different command type');
-        }
-        // Create new command with updated position
-        return new MoveNodeCommand(this.nodeId, other.newPosition, this.oldPosition, // Keep original start position
-        { mergeable: this.mergeable });
-    }
-    serialize() {
-        return {
-            id: this.id,
-            name: this.name,
-            timestamp: this.timestamp,
-            data: {
-                nodeId: this.nodeId,
-                oldPosition: this.oldPosition,
-                newPosition: this.newPosition,
-            },
-        };
-    }
-    getDescription() {
-        return `Move node to (${Math.round(this.newPosition.x)}, ${Math.round(this.newPosition.y)})`;
-    }
-}
-exports.MoveNodeCommand = MoveNodeCommand;
-//# sourceMappingURL=MoveNodeCommand.js.map

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

@@ -1,39 +0,0 @@
-import { Command, CommandContext, SerializedCommand } from '../Command';
-import type { NodeModel } from '../../models/NodeModel';
-/** Shared plumbing: snapshot the old z-index, restore it verbatim on undo. */
-declare abstract class NodeZOrderCommand extends Command {
-    protected nodeId: string;
-    protected oldZIndex?: number;
-    protected captured: boolean;
-    constructor(nodeId: string, name: string);
-    protected resolve(context: CommandContext): NodeModel;
-    execute(context: CommandContext): void;
-    protected abstract applyTo(node: NodeModel, context: CommandContext): void;
-    undo(context: CommandContext): void;
-    canExecute(context: CommandContext): boolean;
-    canUndo(context: CommandContext): boolean;
-}
-/** Set a node's stacking index to an explicit value. */
-export declare class SetNodeZIndexCommand extends NodeZOrderCommand {
-    private zIndex;
-    constructor(nodeId: string, zIndex: number);
-    protected applyTo(node: NodeModel): void;
-    canMergeWith(other: Command): boolean;
-    serialize(): SerializedCommand;
-    getDescription(): string;
-}
-/** Lift a node above every other node in the diagram. */
-export declare class BringNodeToFrontCommand extends NodeZOrderCommand {
-    constructor(nodeId: string);
-    protected applyTo(node: NodeModel, context: CommandContext): void;
-    serialize(): SerializedCommand;
-    getDescription(): string;
-}
-/** Drop a node behind every other node in the diagram. */
-export declare class SendNodeToBackCommand extends NodeZOrderCommand {
-    constructor(nodeId: string);
-    protected applyTo(node: NodeModel, context: CommandContext): void;
-    serialize(): SerializedCommand;
-    getDescription(): string;
-}
-export {};

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

@@ -1,120 +0,0 @@
-"use strict";
-// NodeZOrderCommands - undoable stacking-order edits for nodes (C)
-//
-// `GroupModel` has had `zIndex` + `bringToFront`/`sendToBack` since Wave-5, but
-// there was no node equivalent and no command at all: restacking a node meant
-// writing `style.zIndex` directly, which is invisible to undo and to the diff /
-// collab layers. These are the document-write surface for `NodeModel.zIndex`.
-//
-// All three undo to the node's PREVIOUS z-index — including back to `undefined`
-// ("never stated one"), which is a distinct state from `0` and must be restored as
-// such or an undo would quietly promote every node above the legacy `style.zIndex`
-// stack it used to defer to.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SendNodeToBackCommand = exports.BringNodeToFrontCommand = exports.SetNodeZIndexCommand = void 0;
-const Command_1 = require("../Command");
-/** Shared plumbing: snapshot the old z-index, restore it verbatim on undo. */
-class NodeZOrderCommand extends Command_1.Command {
-    constructor(nodeId, name) {
-        super(name);
-        this.nodeId = nodeId;
-        this.captured = false;
-    }
-    resolve(context) {
-        const diagram = context.diagram;
-        if (!diagram) {
-            throw new Error('Diagram not found in context');
-        }
-        const node = diagram.getNode(this.nodeId);
-        if (!node) {
-            throw new Error(`Node ${this.nodeId} not found`);
-        }
-        return node;
-    }
-    execute(context) {
-        const node = this.resolve(context);
-        if (!this.captured) {
-            this.oldZIndex = node.zIndex;
-            this.captured = true;
-        }
-        this.applyTo(node, context);
-    }
-    undo(context) {
-        this.resolve(context).setZIndex(this.oldZIndex);
-    }
-    canExecute(context) {
-        var _a, _b;
-        return ((_b = (_a = context.diagram) === null || _a === void 0 ? void 0 : _a.getNode) === null || _b === void 0 ? void 0 : _b.call(_a, this.nodeId)) !== undefined;
-    }
-    canUndo(context) {
-        return this.canExecute(context);
-    }
-}
-/** Set a node's stacking index to an explicit value. */
-class SetNodeZIndexCommand extends NodeZOrderCommand {
-    constructor(nodeId, zIndex) {
-        super(nodeId, 'Set Node Z-Index');
-        this.zIndex = zIndex;
-    }
-    applyTo(node) {
-        node.setZIndex(this.zIndex);
-    }
-    canMergeWith(other) {
-        return other instanceof SetNodeZIndexCommand && other.nodeId === this.nodeId;
-    }
-    serialize() {
-        return {
-            id: this.id,
-            name: this.name,
-            timestamp: this.timestamp,
-            data: { nodeId: this.nodeId, zIndex: this.zIndex, oldZIndex: this.oldZIndex },
-        };
-    }
-    getDescription() {
-        return `Set z-index of node ${this.nodeId} to ${this.zIndex}`;
-    }
-}
-exports.SetNodeZIndexCommand = SetNodeZIndexCommand;
-/** Lift a node above every other node in the diagram. */
-class BringNodeToFrontCommand extends NodeZOrderCommand {
-    constructor(nodeId) {
-        super(nodeId, 'Bring Node To Front');
-    }
-    applyTo(node, context) {
-        node.bringToFront(context.diagram);
-    }
-    serialize() {
-        return {
-            id: this.id,
-            name: this.name,
-            timestamp: this.timestamp,
-            data: { nodeId: this.nodeId, oldZIndex: this.oldZIndex },
-        };
-    }
-    getDescription() {
-        return `Bring node ${this.nodeId} to front`;
-    }
-}
-exports.BringNodeToFrontCommand = BringNodeToFrontCommand;
-/** Drop a node behind every other node in the diagram. */
-class SendNodeToBackCommand extends NodeZOrderCommand {
-    constructor(nodeId) {
-        super(nodeId, 'Send Node To Back');
-    }
-    applyTo(node, context) {
-        node.sendToBack(context.diagram);
-    }
-    serialize() {
-        return {
-            id: this.id,
-            name: this.name,
-            timestamp: this.timestamp,
-            data: { nodeId: this.nodeId, oldZIndex: this.oldZIndex },
-        };
-    }
-    getDescription() {
-        return `Send node ${this.nodeId} to back`;
-    }
-}
-exports.SendNodeToBackCommand = SendNodeToBackCommand;
-//# sourceMappingURL=NodeZOrderCommands.js.map

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

@@ -1,33 +0,0 @@
-import { Command, CommandContext, SerializedCommand } from '../Command';
-import type { ClipboardManager } from '../../clipboard/ClipboardManager';
-import type { Point } from '../../types';
-/**
- * PasteCommand pastes entities from clipboard into diagram
- *
- * Features:
- * - Generates new IDs for pasted entities
- * - Remaps relationships (links, groups, hierarchy)
- * - Applies position offset
- * - Preserves all properties (transforms, layout configs, etc.)
- * - Supports undo/redo
- */
-export declare class PasteCommand extends Command {
-    private clipboard;
-    private options;
-    private pastedNodeIds;
-    private pastedLinkIds;
-    private pastedGroupIds;
-    private idMap;
-    private portIdMap;
-    private pasteSlot;
-    constructor(clipboard: ClipboardManager, options?: {
-        offset?: Point;
-        selectPasted?: boolean;
-    });
-    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/PasteCommand.js

@@ -1,228 +0,0 @@
-"use strict";
-// PasteCommand - Paste entities from clipboard (Phase 1.8)
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PasteCommand = void 0;
-const Command_1 = require("../Command");
-const NodeModel_1 = require("../../models/NodeModel");
-const LinkModel_1 = require("../../models/LinkModel");
-const GroupModel_1 = require("../../models/GroupModel");
-const id_1 = require("../../utils/id");
-const remapNodePortIds_1 = require("./remapNodePortIds");
-/**
- * PasteCommand pastes entities from clipboard into diagram
- *
- * Features:
- * - Generates new IDs for pasted entities
- * - Remaps relationships (links, groups, hierarchy)
- * - Applies position offset
- * - Preserves all properties (transforms, layout configs, etc.)
- * - Supports undo/redo
- */
-class PasteCommand extends Command_1.Command {
-    constructor(clipboard, options = {}) {
-        super('Paste');
-        this.clipboard = clipboard;
-        this.options = options;
-        this.pastedNodeIds = [];
-        this.pastedLinkIds = [];
-        this.pastedGroupIds = [];
-        this.idMap = new Map(); // old node/group ID -> new ID
-        this.portIdMap = new Map(); // old port ID -> new port ID
-        this.pasteSlot = null; // claimed once; stable across redo
-    }
-    execute(context) {
-        var _a;
-        const diagram = context.diagram;
-        if (!diagram) {
-            throw new Error('Diagram not found in context');
-        }
-        const clipboardData = this.clipboard.get();
-        if (!clipboardData) {
-            throw new Error('Clipboard is empty');
-        }
-        // Reset ID maps for this execution
-        this.idMap.clear();
-        this.portIdMap.clear();
-        this.pastedNodeIds = [];
-        this.pastedLinkIds = [];
-        this.pastedGroupIds = [];
-        // An EXPLICIT offset is honored exactly (API contract). The DEFAULT
-        // cascades per paste of the same copy — clipboard positions are frozen at
-        // copy time, so without the cascade every default paste stacks on the
-        // same pixels. The slot is claimed once per command: redo re-executes at
-        // the same spot instead of drifting further.
-        if (this.pasteSlot === null) {
-            this.pasteSlot = this.clipboard.claimPasteSlot();
-        }
-        const offset = this.options.offset || { x: 20 * this.pasteSlot, y: 20 * this.pasteSlot };
-        // Step 1: Paste nodes with ID remapping
-        for (const nodeData of clipboardData.nodes) {
-            // Generate new ID
-            const oldId = nodeData.id;
-            const newId = (0, id_1.generateId)();
-            this.idMap.set(oldId, newId);
-            // Create new node with new ID
-            const node = NodeModel_1.NodeModel.fromJSON(Object.assign(Object.assign({}, nodeData), { id: newId }));
-            // Re-ID every port so the pasted node's ports are globally unique, and
-            // record oldPortId -> newPortId. NodeModel.fromJSON preserves the ORIGINAL
-            // port ids from the serialized data, so without this a pasted node would
-            // share port ids with its source — and links (which reference the engine's
-            // nanoid port ids, NOT "nodeId:portName" strings) would resolve to the
-            // wrong node. Rebuild the ports map since its keys are the port ids.
-            (0, remapNodePortIds_1.remapNodePortIds)(node, newId, this.portIdMap);
-            // Apply position offset
-            node.position = {
-                x: node.position.x + offset.x,
-                y: node.position.y + offset.y,
-                z: node.position.z,
-            };
-            // Remap parent ID if exists
-            if (node.parentId) {
-                const newParentId = this.idMap.get(node.parentId);
-                if (newParentId) {
-                    node.parentId = newParentId;
-                }
-                else {
-                    // Parent not in clipboard, remove parent relationship
-                    node.parentId = undefined;
-                }
-            }
-            // Remap children IDs
-            const newChildren = new Set();
-            for (const childId of node.children) {
-                const newChildId = this.idMap.get(childId);
-                if (newChildId) {
-                    newChildren.add(newChildId);
-                }
-            }
-            node.children = newChildren;
-            // Add to diagram
-            diagram.addNode(node);
-            this.pastedNodeIds.push(node.id);
-        }
-        // Step 2: Paste links with ID remapping
-        for (const linkData of clipboardData.links) {
-            // Remap the endpoints through the port-id map built while cloning nodes.
-            // A link's sourcePortId/targetPortId ARE port ids (engine nanoids), so if
-            // either endpoint's port was not among the pasted nodes, drop the link.
-            const newSourcePortId = this.portIdMap.get(linkData.sourcePortId);
-            const newTargetPortId = this.portIdMap.get(linkData.targetPortId);
-            if (!newSourcePortId || !newTargetPortId) {
-                // Source or target port not pasted, skip this link
-                continue;
-            }
-            // Generate new ID
-            const oldId = linkData.id;
-            const newId = (0, id_1.generateId)();
-            this.idMap.set(oldId, newId);
-            // Remap the cached owning-node ids through the node-id map (may be absent
-            // on legacy links — addLink() backfills them from the port lookup).
-            const newSourceNodeId = linkData.sourceNodeId
-                ? this.idMap.get(linkData.sourceNodeId)
-                : undefined;
-            const newTargetNodeId = linkData.targetNodeId
-                ? this.idMap.get(linkData.targetNodeId)
-                : undefined;
-            // Create new link with new ID and remapped ports + node caches
-            const link = LinkModel_1.LinkModel.fromJSON(Object.assign(Object.assign({}, linkData), { id: newId, sourcePortId: newSourcePortId, targetPortId: newTargetPortId, sourceNodeId: newSourceNodeId, targetNodeId: newTargetNodeId }));
-            // Add to diagram
-            diagram.addLink(link);
-            this.pastedLinkIds.push(link.id);
-        }
-        // Step 3: Paste groups with ID remapping
-        for (const groupData of clipboardData.groups) {
-            const oldGroup = GroupModel_1.GroupModel.fromJSON(groupData);
-            // Create new group with new ID
-            const oldId = oldGroup.id;
-            const newId = (0, id_1.generateId)();
-            const group = new GroupModel_1.GroupModel({ name: oldGroup.name });
-            group.id = newId; // Override readonly id
-            this.idMap.set(oldId, newId);
-            // Remap member IDs — from oldGroup, which is the one that HAS members.
-            // This iterated `group.members` (the freshly-constructed, empty group), so
-            // newMembers was always empty, the size>0 guard below dropped the group, and
-            // pasting a grouped selection silently lost the group. No test caught it
-            // because every paste test used groups:[]. See ClipboardCommands.spec.ts.
-            const newMembers = new Set();
-            for (const memberId of oldGroup.members) {
-                const newMemberId = this.idMap.get(memberId);
-                if (newMemberId) {
-                    newMembers.add(newMemberId);
-                }
-            }
-            // DIRECT field write, deliberately: `group` is DETACHED here (constructed,
-            // not yet addGroup'd), so nothing is capturing it and a tracked mutator would
-            // buy nothing — exactly like building a node before adding it. The addGroup
-            // below is the funnel: it emits the structural op carrying group.serialize(),
-            // whose `members` array is read wholesale, so a collab peer receives the
-            // pasted group correctly regardless of this assignment. (Contrast an ATTACHED
-            // group, where membership edits MUST go through addMember/removeMember.)
-            group.members = newMembers;
-            // Only add group if it has members
-            if (group.members.size > 0) {
-                diagram.addGroup(group);
-                this.pastedGroupIds.push(group.id);
-            }
-        }
-        // Step 4: Select pasted entities (if enabled)
-        if (this.options.selectPasted !== false && context.store) {
-            context.store.set('selectedNodes', new Set(this.pastedNodeIds));
-            context.store.set('selectedLinks', new Set());
-            // Update node states
-            diagram.getNodes().forEach((node) => {
-                node.setState({ selected: this.pastedNodeIds.includes(node.id) });
-            });
-            // Emit selection event
-            (_a = context.eventBus) === null || _a === void 0 ? void 0 : _a.emit('selection:changed', { nodes: this.pastedNodeIds });
-        }
-    }
-    undo(context) {
-        var _a;
-        const diagram = context.diagram;
-        if (!diagram) {
-            throw new Error('Diagram not found in context');
-        }
-        // Remove pasted entities in reverse order
-        for (const groupId of this.pastedGroupIds.reverse()) {
-            diagram.removeGroup(groupId);
-        }
-        for (const linkId of this.pastedLinkIds.reverse()) {
-            diagram.removeLink(linkId);
-        }
-        for (const nodeId of this.pastedNodeIds.reverse()) {
-            diagram.removeNode(nodeId);
-        }
-        // Clear selection
-        if (context.store) {
-            context.store.set('selectedNodes', new Set());
-            (_a = context.eventBus) === null || _a === void 0 ? void 0 : _a.emit('selection:cleared');
-        }
-    }
-    canExecute(context) {
-        return !!(context.diagram && this.clipboard.hasData());
-    }
-    canUndo(context) {
-        return !!(context.diagram && this.pastedNodeIds.length > 0);
-    }
-    serialize() {
-        return {
-            id: this.id,
-            name: this.name,
-            timestamp: this.timestamp,
-            data: {
-                pastedNodeIds: this.pastedNodeIds,
-                pastedLinkIds: this.pastedLinkIds,
-                pastedGroupIds: this.pastedGroupIds,
-                idMap: Object.fromEntries(this.idMap),
-                portIdMap: Object.fromEntries(this.portIdMap),
-                options: this.options,
-            },
-        };
-    }
-    getDescription() {
-        const count = this.pastedNodeIds.length;
-        return `Paste ${count} node${count !== 1 ? 's' : ''}`;
-    }
-}
-exports.PasteCommand = PasteCommand;
-//# sourceMappingURL=PasteCommand.js.map