@grafloria/element 0.3.18 → 0.3.20

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

@@ -0,0 +1,309 @@
+"use strict";
+// DeleteSelectionCommand - Delete selected entities (Phase 1.8)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteSelectionCommand = void 0;
+const Command_1 = require("../Command");
+const resolveLinkNodeIds_1 = require("./resolveLinkNodeIds");
+/**
+ * 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
+ */
+class DeleteSelectionCommand extends Command_1.Command {
+    constructor(options = {}) {
+        super('Delete Selection');
+        this.options = options;
+        this.deletedNodes = [];
+        this.deletedLinks = [];
+        this.deletedGroups = [];
+        this.affectedGroups = new Map(); // groupId -> removed member IDs
+    }
+    execute(context) {
+        var _a, _b, _c;
+        const diagram = context.diagram;
+        if (!diagram) {
+            throw new Error('Diagram not found in context');
+        }
+        // Diagram selection first — mouse selection never writes the store's sets
+        // (see CopyCommand).
+        const diagramNodeSel = diagram.getSelectedNodes().map((n) => n.id);
+        const diagramLinkSel = diagram.getLinks().filter((l) => l.state === 'selected').map((l) => l.id);
+        const storeNodeSel = (_a = context.store) === null || _a === void 0 ? void 0 : _a.get('selectedNodes');
+        const storeLinkSel = (_b = context.store) === null || _b === void 0 ? void 0 : _b.get('selectedLinks');
+        const selectedNodeIds = new Set(diagramNodeSel.length > 0 ? diagramNodeSel : Array.from(storeNodeSel !== null && storeNodeSel !== void 0 ? storeNodeSel : []));
+        const selectedLinkIds = new Set(diagramLinkSel.length > 0 ? diagramLinkSel : Array.from(storeLinkSel !== null && storeLinkSel !== void 0 ? storeLinkSel : []));
+        if ((!selectedNodeIds || selectedNodeIds.size === 0) &&
+            (!selectedLinkIds || selectedLinkIds.size === 0)) {
+            throw new Error('No entities selected');
+        }
+        // Reset state
+        this.deletedNodes = [];
+        this.deletedLinks = [];
+        this.deletedGroups = [];
+        this.affectedGroups.clear();
+        const deleteChildren = this.options.deleteChildren !== false;
+        const deleteLinks = this.options.deleteLinks !== false;
+        // Collect all node IDs to delete (including children if enabled)
+        const nodeIdsToDelete = new Set();
+        if (selectedNodeIds) {
+            for (const nodeId of selectedNodeIds) {
+                this.collectNodeIdsToDelete(diagram, nodeId, nodeIdsToDelete, deleteChildren);
+            }
+        }
+        // Step 1: Delete links connected to nodes (if enabled) or selected links
+        if (deleteLinks && nodeIdsToDelete.size > 0) {
+            const allLinks = diagram.getLinks();
+            for (const link of allLinks) {
+                // Endpoints are PORT ids (nanoids), so the owning nodes must be resolved
+                // through the port index. Splitting on ':' resolved NOTHING for links
+                // made by connectNodes()/the interactive connect path, which left orphan
+                // links behind whenever their nodes were deleted (removeNode() does not
+                // cascade). See resolveLinkNodeIds().
+                const { sourceNodeId, targetNodeId } = (0, resolveLinkNodeIds_1.resolveLinkNodeIds)(diagram, link);
+                if ((sourceNodeId && nodeIdsToDelete.has(sourceNodeId)) ||
+                    (targetNodeId && nodeIdsToDelete.has(targetNodeId))) {
+                    this.deletedLinks.push(link.serialize());
+                    diagram.removeLink(link.id);
+                }
+            }
+        }
+        // Delete explicitly selected links
+        if (selectedLinkIds) {
+            for (const linkId of selectedLinkIds) {
+                const link = diagram.getLink(linkId);
+                if (link) {
+                    this.deletedLinks.push(link.serialize());
+                    diagram.removeLink(linkId);
+                }
+            }
+        }
+        // Step 2: Remove nodes from groups they belong to
+        const allGroups = diagram.getGroups();
+        for (const group of allGroups) {
+            const removedMembers = new Set();
+            for (const memberId of group.members) {
+                if (nodeIdsToDelete.has(memberId)) {
+                    removedMembers.add(memberId);
+                }
+            }
+            if (removedMembers.size > 0) {
+                this.affectedGroups.set(group.id, removedMembers);
+                for (const memberId of removedMembers) {
+                    group.removeMember(memberId);
+                }
+            }
+        }
+        // Step 3: Delete groups that have no members left or are empty
+        for (const group of allGroups) {
+            if (group.members.size === 0) {
+                this.deletedGroups.push(group.serialize());
+                diagram.removeGroup(group.id);
+            }
+        }
+        // Step 4: Delete nodes (in reverse hierarchy order - children first)
+        const nodesToDelete = Array.from(nodeIdsToDelete)
+            .map((id) => diagram.getNode(id))
+            .filter((node) => node !== undefined);
+        // Sort by hierarchy depth (deepest first)
+        nodesToDelete.sort((a, b) => {
+            const depthA = this.getNodeDepth(diagram, a.id);
+            const depthB = this.getNodeDepth(diagram, b.id);
+            return depthB - depthA;
+        });
+        const recordedLinkIds = new Set(this.deletedLinks.map((l) => l.id));
+        for (const node of nodesToDelete) {
+            // Record links about to CASCADE before they vanish (wave 14). With
+            // `deleteLinks: false`, Step 1 skipped them — but removeNode() cascades
+            // a node's links regardless, so undo silently lost every link the
+            // deleted nodes touched. Deduped: one link can touch two doomed nodes,
+            // and with `deleteLinks: true` Step 1 already recorded (and removed)
+            // all of these, so this records nothing new.
+            for (const link of diagram.getLinksForNode(node.id)) {
+                if (!recordedLinkIds.has(link.id)) {
+                    recordedLinkIds.add(link.id);
+                    this.deletedLinks.push(link.serialize());
+                }
+            }
+            this.deletedNodes.push(node.serialize());
+            diagram.removeNode(node.id);
+        }
+        // Step 5: Clear selection
+        if (context.store) {
+            context.store.set('selectedNodes', new Set());
+            context.store.set('selectedLinks', new Set());
+            (_c = context.eventBus) === null || _c === void 0 ? void 0 : _c.emit('selection:cleared');
+        }
+    }
+    undo(context) {
+        const diagram = context.diagram;
+        if (!diagram) {
+            throw new Error('Diagram not found in context');
+        }
+        // Restore in reverse order of deletion
+        // Step 1: Restore nodes (parents first)
+        const nodesToRestore = [...this.deletedNodes].reverse();
+        for (const nodeData of nodesToRestore) {
+            const node = diagram.restoreNode(nodeData);
+            if (!node) {
+                console.warn(`Failed to restore node ${nodeData.id}`);
+            }
+        }
+        // Step 2: Restore groups
+        for (const groupData of this.deletedGroups) {
+            const group = diagram.restoreGroup(groupData);
+            if (!group) {
+                console.warn(`Failed to restore group ${groupData.id}`);
+            }
+        }
+        // Step 3: Restore group memberships
+        for (const [groupId, memberIds] of this.affectedGroups.entries()) {
+            const group = diagram.getGroup(groupId);
+            if (group) {
+                for (const memberId of memberIds) {
+                    group.addMember(memberId);
+                }
+            }
+        }
+        // Step 4: Restore links (guarded: restoreLink() would re-install over a
+        // live link, double-registering its port connections)
+        for (const linkData of this.deletedLinks) {
+            if (diagram.getLink(linkData.id))
+                continue;
+            const link = diagram.restoreLink(linkData);
+            if (!link) {
+                console.warn(`Failed to restore link ${linkData.id}`);
+            }
+        }
+    }
+    /**
+     * 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) {
+        var _a;
+        const diagram = context.diagram;
+        if (!diagram) {
+            throw new Error('Diagram not found in context');
+        }
+        // Never executed yet (redo before execute) → nothing recorded, use the
+        // normal selection-driven path.
+        if (this.deletedNodes.length === 0 &&
+            this.deletedLinks.length === 0 &&
+            this.deletedGroups.length === 0) {
+            this.execute(context);
+            return;
+        }
+        // Same order as execute(): links → group memberships → groups → nodes.
+        for (const linkData of this.deletedLinks) {
+            diagram.removeLink(linkData.id);
+        }
+        for (const [groupId, memberIds] of this.affectedGroups.entries()) {
+            const group = diagram.getGroup(groupId);
+            if (group) {
+                for (const memberId of memberIds) {
+                    group.removeMember(memberId);
+                }
+            }
+        }
+        for (const groupData of this.deletedGroups) {
+            diagram.removeGroup(groupData.id);
+        }
+        // `deletedNodes` was recorded deepest-first, so children go before parents.
+        for (const nodeData of this.deletedNodes) {
+            diagram.removeNode(nodeData.id);
+        }
+        if (context.store) {
+            context.store.set('selectedNodes', new Set());
+            context.store.set('selectedLinks', new Set());
+            (_a = context.eventBus) === null || _a === void 0 ? void 0 : _a.emit('selection:cleared');
+        }
+    }
+    canExecute(context) {
+        var _a, _b;
+        const diagram = context.diagram;
+        if (!diagram)
+            return false;
+        if (diagram.getSelectedNodes().length > 0)
+            return true;
+        if (diagram.getLinks().some((l) => l.state === 'selected'))
+            return true;
+        const selectedNodeIds = (_a = context.store) === null || _a === void 0 ? void 0 : _a.get('selectedNodes');
+        const selectedLinkIds = (_b = context.store) === null || _b === void 0 ? void 0 : _b.get('selectedLinks');
+        return !!((selectedNodeIds && selectedNodeIds.size > 0) ||
+            (selectedLinkIds && selectedLinkIds.size > 0));
+    }
+    canUndo(context) {
+        return !!(context.diagram &&
+            (this.deletedNodes.length > 0 ||
+                this.deletedLinks.length > 0 ||
+                this.deletedGroups.length > 0));
+    }
+    serialize() {
+        return {
+            id: this.id,
+            name: this.name,
+            timestamp: this.timestamp,
+            data: {
+                deletedNodes: this.deletedNodes,
+                deletedLinks: this.deletedLinks,
+                deletedGroups: this.deletedGroups,
+                affectedGroups: Array.from(this.affectedGroups.entries()).map(([groupId, memberIds]) => ({
+                    groupId,
+                    memberIds: Array.from(memberIds),
+                })),
+                options: this.options,
+            },
+        };
+    }
+    getDescription() {
+        const nodeCount = this.deletedNodes.length;
+        const linkCount = this.deletedLinks.length;
+        const parts = [];
+        if (nodeCount > 0) {
+            parts.push(`${nodeCount} node${nodeCount !== 1 ? 's' : ''}`);
+        }
+        if (linkCount > 0) {
+            parts.push(`${linkCount} link${linkCount !== 1 ? 's' : ''}`);
+        }
+        return `Delete ${parts.join(' and ')}`;
+    }
+    /**
+     * Recursively collect node IDs to delete (including children if enabled)
+     */
+    collectNodeIdsToDelete(diagram, nodeId, collected, includeChildren) {
+        if (collected.has(nodeId))
+            return;
+        collected.add(nodeId);
+        if (includeChildren) {
+            const node = diagram.getNode(nodeId);
+            if (node) {
+                for (const childId of node.children) {
+                    this.collectNodeIdsToDelete(diagram, childId, collected, includeChildren);
+                }
+            }
+        }
+    }
+    /**
+     * Get hierarchy depth of a node (root = 0)
+     */
+    getNodeDepth(diagram, nodeId) {
+        const node = diagram.getNode(nodeId);
+        if (!node || !node.parentId)
+            return 0;
+        return 1 + this.getNodeDepth(diagram, node.parentId);
+    }
+}
+exports.DeleteSelectionCommand = DeleteSelectionCommand;
+//# sourceMappingURL=DeleteSelectionCommand.js.map

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

@@ -0,0 +1,31 @@
+import { Command, CommandContext, SerializedCommand } from '../Command';
+import type { Point } from '../../types';
+/**
+ * DuplicateCommand duplicates selected entities in the diagram
+ *
+ * Features:
+ * - Generates new IDs for duplicated entities
+ * - Remaps relationships (links, groups, hierarchy)
+ * - Applies position offset
+ * - Preserves all properties (transforms, layout configs, etc.)
+ * - Supports undo/redo
+ * - Similar to paste but operates directly on selection
+ */
+export declare class DuplicateCommand extends Command {
+    private options;
+    private duplicatedNodeIds;
+    private duplicatedLinkIds;
+    private duplicatedGroupIds;
+    private idMap;
+    private portIdMap;
+    constructor(options?: {
+        offset?: Point;
+        selectDuplicated?: 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/DuplicateCommand.js

@@ -0,0 +1,232 @@
+"use strict";
+// DuplicateCommand - Duplicate selected entities (Phase 1.8)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuplicateCommand = 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");
+/**
+ * DuplicateCommand duplicates selected entities in the diagram
+ *
+ * Features:
+ * - Generates new IDs for duplicated entities
+ * - Remaps relationships (links, groups, hierarchy)
+ * - Applies position offset
+ * - Preserves all properties (transforms, layout configs, etc.)
+ * - Supports undo/redo
+ * - Similar to paste but operates directly on selection
+ */
+class DuplicateCommand extends Command_1.Command {
+    constructor(options = {}) {
+        super('Duplicate');
+        this.options = options;
+        this.duplicatedNodeIds = [];
+        this.duplicatedLinkIds = [];
+        this.duplicatedGroupIds = [];
+        this.idMap = new Map(); // old node/group ID -> new ID
+        this.portIdMap = new Map(); // old port ID -> new port ID
+    }
+    execute(context) {
+        var _a, _b;
+        const diagram = context.diagram;
+        if (!diagram) {
+            throw new Error('Diagram not found in context');
+        }
+        // Diagram selection first — a mouse click selects through
+        // diagram.selectNode() and never writes the store's set (see CopyCommand).
+        const diagramSel = diagram.getSelectedNodes().map((n) => n.id);
+        const storeSel = (_a = context.store) === null || _a === void 0 ? void 0 : _a.get('selectedNodes');
+        const selectedNodeIds = new Set(diagramSel.length > 0 ? diagramSel : Array.from(storeSel !== null && storeSel !== void 0 ? storeSel : []));
+        if (selectedNodeIds.size === 0) {
+            throw new Error('No nodes selected');
+        }
+        // Reset ID maps for this execution
+        this.idMap.clear();
+        this.portIdMap.clear();
+        this.duplicatedNodeIds = [];
+        this.duplicatedLinkIds = [];
+        this.duplicatedGroupIds = [];
+        const offset = this.options.offset || { x: 20, y: 20 };
+        const nodeIdSet = new Set();
+        // Step 1: Duplicate nodes with ID remapping
+        for (const nodeId of selectedNodeIds) {
+            const node = diagram.getNode(nodeId);
+            if (!node)
+                continue;
+            // Clone node
+            const nodeData = node.serialize();
+            const oldId = node.id;
+            const newId = (0, id_1.generateId)();
+            const newNode = NodeModel_1.NodeModel.fromJSON(Object.assign(Object.assign({}, nodeData), { id: newId }));
+            this.idMap.set(oldId, newId);
+            nodeIdSet.add(oldId);
+            // Re-ID every port so the duplicate's ports are globally unique, and
+            // record oldPortId -> newPortId for link remapping below (see
+            // remapNodePortIds for why the serialized-id preservation makes this
+            // mandatory).
+            (0, remapNodePortIds_1.remapNodePortIds)(newNode, newId, this.portIdMap);
+            // Apply position offset
+            newNode.position = {
+                x: newNode.position.x + offset.x,
+                y: newNode.position.y + offset.y,
+                z: newNode.position.z,
+            };
+            // Remap parent ID if exists
+            if (newNode.parentId) {
+                const newParentId = this.idMap.get(newNode.parentId);
+                if (newParentId) {
+                    newNode.parentId = newParentId;
+                }
+                else {
+                    // Parent not in selection, remove parent relationship
+                    newNode.parentId = undefined;
+                }
+            }
+            // Remap children IDs
+            const newChildren = new Set();
+            for (const childId of newNode.children) {
+                const newChildId = this.idMap.get(childId);
+                if (newChildId) {
+                    newChildren.add(newChildId);
+                }
+            }
+            newNode.children = newChildren;
+            // Add to diagram
+            diagram.addNode(newNode);
+            this.duplicatedNodeIds.push(newNode.id);
+        }
+        // Step 2: Duplicate links between selected nodes
+        const allLinks = diagram.getLinks();
+        for (const link of allLinks) {
+            // A link connects two duplicated nodes iff BOTH of its endpoint port ids
+            // were re-mapped while cloning nodes above. This uses the engine's real
+            // nanoid port ids — no "nodeId:portName" string parsing.
+            const newSourcePortId = this.portIdMap.get(link.sourcePortId);
+            const newTargetPortId = this.portIdMap.get(link.targetPortId);
+            if (!newSourcePortId || !newTargetPortId) {
+                continue;
+            }
+            // Clone link
+            const linkData = link.serialize();
+            const newId = (0, id_1.generateId)();
+            // Remap the cached owning-node ids through the node-id map (may be absent;
+            // addLink() backfills from the port lookup when so).
+            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 newLink = LinkModel_1.LinkModel.fromJSON(Object.assign(Object.assign({}, linkData), { id: newId, sourcePortId: newSourcePortId, targetPortId: newTargetPortId, sourceNodeId: newSourceNodeId, targetNodeId: newTargetNodeId }));
+            // Add to diagram
+            diagram.addLink(newLink);
+            this.duplicatedLinkIds.push(newLink.id);
+        }
+        // Step 3: Duplicate groups containing only selected nodes
+        const allGroups = diagram.getGroups();
+        for (const group of allGroups) {
+            // Check if all group members are selected
+            const allMembersSelected = Array.from(group.members).every((memberId) => nodeIdSet.has(memberId));
+            if (!allMembersSelected || group.members.size === 0) {
+                continue;
+            }
+            // Clone group
+            const groupData = group.serialize();
+            const oldId = group.id;
+            const newId = (0, id_1.generateId)();
+            // Create new group with new ID
+            const newGroup = new GroupModel_1.GroupModel({ name: group.name });
+            newGroup.id = newId; // Override readonly id
+            this.idMap.set(oldId, newId);
+            // Remap member IDs. Iterate the ORIGINAL group's members — `newGroup` was
+            // just constructed and is empty, so iterating it produced no members, the
+            // `size > 0` guard below dropped the group, and duplicating a grouped
+            // selection silently lost the grouping. (Twin of the PasteCommand bug in
+            // b661cc945.)
+            const newMembers = new Set();
+            for (const memberId of group.members) {
+                const newMemberId = this.idMap.get(memberId);
+                if (newMemberId) {
+                    newMembers.add(newMemberId);
+                }
+            }
+            newGroup.members = newMembers;
+            // Only add group if it has members
+            if (newGroup.members.size > 0) {
+                diagram.addGroup(newGroup);
+                this.duplicatedGroupIds.push(newGroup.id);
+            }
+        }
+        // Step 4: Select duplicated entities (if enabled)
+        if (this.options.selectDuplicated !== false && context.store) {
+            context.store.set('selectedNodes', new Set(this.duplicatedNodeIds));
+            context.store.set('selectedLinks', new Set());
+            // Update node states
+            diagram.getNodes().forEach((node) => {
+                node.setState({ selected: this.duplicatedNodeIds.includes(node.id) });
+            });
+            // Emit selection event
+            (_b = context.eventBus) === null || _b === void 0 ? void 0 : _b.emit('selection:changed', { nodes: this.duplicatedNodeIds });
+        }
+    }
+    undo(context) {
+        var _a;
+        const diagram = context.diagram;
+        if (!diagram) {
+            throw new Error('Diagram not found in context');
+        }
+        // Remove duplicated entities in reverse order
+        for (const groupId of this.duplicatedGroupIds.reverse()) {
+            diagram.removeGroup(groupId);
+        }
+        for (const linkId of this.duplicatedLinkIds.reverse()) {
+            diagram.removeLink(linkId);
+        }
+        for (const nodeId of this.duplicatedNodeIds.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) {
+        var _a;
+        const diagram = context.diagram;
+        if (!diagram)
+            return false;
+        if (diagram.getSelectedNodes().length > 0)
+            return true;
+        const selectedNodeIds = (_a = context.store) === null || _a === void 0 ? void 0 : _a.get('selectedNodes');
+        return !!(selectedNodeIds && selectedNodeIds.size > 0);
+    }
+    canUndo(context) {
+        return !!(context.diagram && this.duplicatedNodeIds.length > 0);
+    }
+    serialize() {
+        return {
+            id: this.id,
+            name: this.name,
+            timestamp: this.timestamp,
+            data: {
+                duplicatedNodeIds: this.duplicatedNodeIds,
+                duplicatedLinkIds: this.duplicatedLinkIds,
+                duplicatedGroupIds: this.duplicatedGroupIds,
+                idMap: Object.fromEntries(this.idMap),
+                portIdMap: Object.fromEntries(this.portIdMap),
+                options: this.options,
+            },
+        };
+    }
+    getDescription() {
+        const count = this.duplicatedNodeIds.length;
+        return `Duplicate ${count} node${count !== 1 ? 's' : ''}`;
+    }
+}
+exports.DuplicateCommand = DuplicateCommand;
+//# sourceMappingURL=DuplicateCommand.js.map

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

@@ -0,0 +1,12 @@
+import { Command, CommandContext, SerializedCommand } from '../Command';
+export declare class ExpandGroupCommand extends Command {
+    private groupId;
+    private wasCollapsed?;
+    constructor(groupId: string);
+    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/ExpandGroupCommand.js

@@ -0,0 +1,69 @@
+"use strict";
+// ExpandGroupCommand - Expands a collapsed group (Phase 1.6c)
+//
+// Wave-5 Card 4: expands a REAL collapse (restores members, positions, removed
+// links, and boundary-edge endpoints) via GroupCollapseService. Reverses a
+// collapse that was performed either by the service or by the bare flag.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpandGroupCommand = void 0;
+const Command_1 = require("../Command");
+const GroupCollapseService_1 = require("../../interaction/GroupCollapseService");
+class ExpandGroupCommand extends Command_1.Command {
+    constructor(groupId) {
+        super('Expand Group');
+        this.groupId = groupId;
+    }
+    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.wasCollapsed = group.isCollapsed;
+        new GroupCollapseService_1.GroupCollapseService(diagram).expand(group);
+    }
+    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 — re-collapse if it had been collapsed.
+        if (this.wasCollapsed) {
+            new GroupCollapseService_1.GroupCollapseService(diagram).collapse(group);
+        }
+    }
+    canExecute(context) {
+        if (!context.diagram) {
+            return false;
+        }
+        const group = context.diagram.getGroup(this.groupId);
+        return !!group;
+    }
+    canUndo(context) {
+        return this.canExecute(context) && this.wasCollapsed !== undefined;
+    }
+    serialize() {
+        return {
+            id: this.id,
+            name: this.name,
+            timestamp: this.timestamp,
+            data: {
+                groupId: this.groupId,
+                wasCollapsed: this.wasCollapsed,
+            },
+        };
+    }
+    getDescription() {
+        return `Expand group ${this.groupId}`;
+    }
+}
+exports.ExpandGroupCommand = ExpandGroupCommand;
+//# sourceMappingURL=ExpandGroupCommand.js.map