@grafloria/element 0.3.20 → 0.3.22

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

@@ -1,14 +0,0 @@
-import { Command, CommandContext, SerializedCommand } from '../Command';
-export type LinkPathType = 'direct' | 'orthogonal' | 'smooth' | 'bezier';
-export declare class SetLinkPathTypeCommand extends Command {
-    private readonly linkId;
-    private readonly pathType;
-    private previous?;
-    constructor(linkId: string, pathType: LinkPathType);
-    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/SetLinkPathTypeCommand.js

@@ -1,77 +0,0 @@
-"use strict";
-// SetLinkPathTypeCommand — undoable edit of a link's ROUTE (visio-panel: the
-// properties panel's "Route: smooth | orthogonal" selector).
-//
-// `link.setPathType()` is a raw model write outside undo — the same hole
-// SetNodeStyleCommand closed for node style and UpdateLinkStyleCommand closed
-// for link style. A route change from the panel must be ONE undo entry.
-//
-// setPathType() also CLEARS the cached polyline and drops the manual-waypoints
-// flag (the old route belongs to the old algorithm), so a plain "set it back"
-// undo would silently throw away waypoints the user placed by hand. The
-// snapshot therefore carries the points and the flag, and undo restores them
-// when — and only when — they were manual (an auto-routed polyline is
-// recomputed on the next paint anyway, so restoring it would just pin a stale
-// route).
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SetLinkPathTypeCommand = void 0;
-const Command_1 = require("../Command");
-class SetLinkPathTypeCommand extends Command_1.Command {
-    constructor(linkId, pathType) {
-        super('Set Link Route');
-        this.linkId = linkId;
-        this.pathType = pathType;
-    }
-    execute(context) {
-        var _a;
-        const link = (_a = context.diagram) === null || _a === void 0 ? void 0 : _a.getLink(this.linkId);
-        if (!link)
-            throw new Error(`Link ${this.linkId} not found`);
-        // Snapshot on EVERY execute (not just the first): an execute → undo →
-        // redo → undo round-trip must restore the state each undo actually followed.
-        this.previous = {
-            pathType: link.pathType,
-            points: link.points.map((p) => (Object.assign({}, p))),
-            hasManualWaypoints: link.getMetadata('hasManualWaypoints') === true,
-        };
-        link.setPathType(this.pathType);
-    }
-    undo(context) {
-        var _a;
-        const link = (_a = context.diagram) === null || _a === void 0 ? void 0 : _a.getLink(this.linkId);
-        if (!link || !this.previous) {
-            throw new Error('Cannot undo: missing link or previous path type');
-        }
-        link.setPathType(this.previous.pathType);
-        // setPathType wiped the cache; put back the hand-placed geometry it owned.
-        if (this.previous.hasManualWaypoints && this.previous.points.length > 0) {
-            link.setPoints(this.previous.points.map((p) => (Object.assign({}, p))));
-            link.setMetadata('hasManualWaypoints', true);
-        }
-    }
-    canExecute(context) {
-        var _a;
-        return !!((_a = context.diagram) === null || _a === void 0 ? void 0 : _a.getLink(this.linkId));
-    }
-    canUndo(context) {
-        var _a;
-        return !!((_a = context.diagram) === null || _a === void 0 ? void 0 : _a.getLink(this.linkId)) && !!this.previous;
-    }
-    serialize() {
-        return {
-            id: this.id,
-            name: this.name,
-            timestamp: this.timestamp,
-            data: {
-                linkId: this.linkId,
-                pathType: this.pathType,
-                previous: this.previous,
-            },
-        };
-    }
-    getDescription() {
-        return `Set route of link ${this.linkId} to ${this.pathType}`;
-    }
-}
-exports.SetLinkPathTypeCommand = SetLinkPathTypeCommand;
-//# sourceMappingURL=SetLinkPathTypeCommand.js.map

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

@@ -1,32 +0,0 @@
-import { Command, CommandContext, SerializedCommand } from '../Command';
-import { Point } from '../../types';
-/**
- * Replace a link's `points` (its routed polyline, including any user waypoints),
- * undoable.
- *
- * Waypoint editing — add / move / remove a vertex — used to mutate
- * `link.points` directly through {@link WaypointEditor}, which meant NONE of it
- * was undoable: Ctrl+Z after dragging a vertex did nothing (or, worse, rewound
- * some unrelated earlier command). Every vertex gesture now commits exactly one
- * of these at pointer-up.
- *
- * `hasManualWaypoints` is part of the state being changed: the renderer only
- * preserves interior points when that metadata flag is set, so undoing back to a
- * 2-point route must also clear it or the old vertices would be resurrected on
- * the next re-route.
- */
-export declare class SetLinkPointsCommand extends Command {
-    private linkId;
-    private readonly newPoints;
-    private oldPoints?;
-    private oldManual?;
-    constructor(linkId: string, newPoints: Point[], oldPoints?: Point[]);
-    execute(context: CommandContext): void;
-    undo(context: CommandContext): void;
-    canExecute(context: CommandContext): boolean;
-    canUndo(context: CommandContext): boolean;
-    /** One vertex gesture = one undo step; never merge two of them. */
-    canMergeWith(): boolean;
-    serialize(): SerializedCommand;
-    getDescription(): string;
-}

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

@@ -1,87 +0,0 @@
-"use strict";
-// SetLinkPointsCommand - Replaces a link's routed points (wave4/interaction: vertex tools)
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SetLinkPointsCommand = void 0;
-const Command_1 = require("../Command");
-/**
- * Replace a link's `points` (its routed polyline, including any user waypoints),
- * undoable.
- *
- * Waypoint editing — add / move / remove a vertex — used to mutate
- * `link.points` directly through {@link WaypointEditor}, which meant NONE of it
- * was undoable: Ctrl+Z after dragging a vertex did nothing (or, worse, rewound
- * some unrelated earlier command). Every vertex gesture now commits exactly one
- * of these at pointer-up.
- *
- * `hasManualWaypoints` is part of the state being changed: the renderer only
- * preserves interior points when that metadata flag is set, so undoing back to a
- * 2-point route must also clear it or the old vertices would be resurrected on
- * the next re-route.
- */
-class SetLinkPointsCommand extends Command_1.Command {
-    constructor(linkId, newPoints, oldPoints) {
-        super('Edit Link Path');
-        this.linkId = linkId;
-        this.newPoints = newPoints.map((p) => (Object.assign({}, p)));
-        if (oldPoints) {
-            this.oldPoints = oldPoints.map((p) => (Object.assign({}, p)));
-        }
-    }
-    execute(context) {
-        const diagram = context.diagram;
-        if (!diagram) {
-            throw new Error('Diagram not found in context');
-        }
-        const link = diagram.getLink(this.linkId);
-        if (!link) {
-            throw new Error(`Link ${this.linkId} not found`);
-        }
-        if (!this.oldPoints) {
-            this.oldPoints = link.points.map((p) => (Object.assign({}, p)));
-            this.oldManual = link.getMetadata('hasManualWaypoints') === true;
-        }
-        link.setPoints(this.newPoints.map((p) => (Object.assign({}, p))));
-        link.setMetadata('hasManualWaypoints', this.newPoints.length > 2);
-        link.markDirty('link-points-changed');
-    }
-    undo(context) {
-        const diagram = context.diagram;
-        if (!diagram || !this.oldPoints) {
-            throw new Error('Cannot undo: missing diagram or old points');
-        }
-        const link = diagram.getLink(this.linkId);
-        if (!link) {
-            throw new Error(`Link ${this.linkId} not found`);
-        }
-        link.setPoints(this.oldPoints.map((p) => (Object.assign({}, p))));
-        link.setMetadata('hasManualWaypoints', this.oldManual === true);
-        link.markDirty('link-points-changed');
-    }
-    canExecute(context) {
-        return context.diagram && context.diagram.links.has(this.linkId);
-    }
-    canUndo(context) {
-        return context.diagram && !!this.oldPoints;
-    }
-    /** One vertex gesture = one undo step; never merge two of them. */
-    canMergeWith() {
-        return false;
-    }
-    serialize() {
-        return {
-            id: this.id,
-            name: this.name,
-            timestamp: this.timestamp,
-            data: {
-                linkId: this.linkId,
-                oldPoints: this.oldPoints,
-                newPoints: this.newPoints,
-            },
-        };
-    }
-    getDescription() {
-        return `Edit link path (${this.newPoints.length} points)`;
-    }
-}
-exports.SetLinkPointsCommand = SetLinkPointsCommand;
-//# sourceMappingURL=SetLinkPointsCommand.js.map

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

@@ -1,14 +0,0 @@
-import { Command, CommandContext, SerializedCommand } from '../Command';
-export declare class SetNodeDataCommand extends Command {
-    private readonly data;
-    private readonly nodeIds;
-    /** Per-node snapshot of ONLY the touched keys, keyed by node id. */
-    private previous?;
-    constructor(nodeId: string | readonly string[], data: Readonly<Record<string, unknown>>);
-    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/SetNodeDataCommand.js

@@ -1,93 +0,0 @@
-"use strict";
-// SetNodeDataCommand — undoable edit of a node's SHAPE DATA (`node.data`).
-//
-// T9/visio. Shape data is the field a Visio user actually edits: a master ships a
-// `dataSchema` (all 80 generated masters do), a property sheet renders it, and the
-// values live on `node.data`. But `setData()` is a raw per-key write outside undo —
-// the same hole `SetNodeStyleCommand` closed for style. Typing in a property sheet
-// and being unable to Ctrl+Z it is the bug a user hits within a minute.
-//
-// Per-KEY, not wholesale: `node.data` syncs as per-key LWW registers over collab, so
-// writing only the keys that changed keeps two people editing DIFFERENT fields of the
-// same shape from clobbering each other. Undo restores exactly the keys this command
-// touched (including deleting keys that did not exist before).
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SetNodeDataCommand = void 0;
-const Command_1 = require("../Command");
-/** The sentinel for "this key did not exist before" — distinct from a stored undefined. */
-const ABSENT = Symbol('absent');
-class SetNodeDataCommand extends Command_1.Command {
-    constructor(nodeId, data) {
-        super('Set Shape Data');
-        this.data = data;
-        this.nodeIds = typeof nodeId === 'string' ? [nodeId] : [...nodeId];
-    }
-    execute(context) {
-        const diagram = context.diagram;
-        if (!diagram)
-            throw new Error('Diagram not found in context');
-        // Resolve every target before mutating: a partial application would leave the
-        // selection half-edited with no undo entry to come back through.
-        const nodes = this.nodeIds.map((id) => {
-            const n = diagram.getNode(id);
-            if (!n)
-                throw new Error(`Node ${id} not found`);
-            return n;
-        });
-        // Snapshot on EVERY execute so execute → undo → redo → undo restores the state
-        // each undo actually followed.
-        this.previous = new Map(nodes.map((n) => {
-            const before = new Map();
-            for (const key of Object.keys(this.data)) {
-                const has = n.data && Object.prototype.hasOwnProperty.call(n.data, key);
-                before.set(key, has ? n.getData(key) : ABSENT);
-            }
-            return [n.id, before];
-        }));
-        for (const n of nodes) {
-            for (const [key, value] of Object.entries(this.data))
-                n.setData(key, value);
-        }
-    }
-    undo(context) {
-        const diagram = context.diagram;
-        if (!diagram || !this.previous)
-            throw new Error('Cannot undo: missing diagram or snapshot');
-        for (const [id, before] of this.previous) {
-            const node = diagram.getNode(id);
-            if (!node)
-                continue; // deleted since; its removal owns its own undo entry
-            for (const [key, value] of before) {
-                if (value === ABSENT) {
-                    // The key did not exist before this command invented it — remove it rather
-                    // than leaving an `undefined` that serializes and syncs as a real value.
-                    if (node.data)
-                        delete node.data[key];
-                }
-                else {
-                    node.setData(key, value);
-                }
-            }
-        }
-    }
-    canExecute(context) {
-        return !!context.diagram && this.nodeIds.length > 0 && Object.keys(this.data).length > 0;
-    }
-    canUndo(context) {
-        return !!context.diagram && !!this.previous;
-    }
-    serialize() {
-        return {
-            id: this.id,
-            name: this.name,
-            timestamp: this.timestamp,
-            data: { nodeIds: this.nodeIds, data: this.data },
-        };
-    }
-    getDescription() {
-        const keys = Object.keys(this.data);
-        return `Set ${keys.length === 1 ? keys[0] : `${keys.length} fields`} on ${this.nodeIds.length} node(s)`;
-    }
-}
-exports.SetNodeDataCommand = SetNodeDataCommand;
-//# sourceMappingURL=SetNodeDataCommand.js.map

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

@@ -1,26 +0,0 @@
-import { Command, CommandContext, SerializedCommand } from '../Command';
-/**
- * Set a node's label text, undoable.
- *
- * A node's label lives in metadata under `label` (that is what
- * `SVGRenderer.renderNodeLabel` reads), so this command is the metadata write
- * plus the dirty flag the renderer needs to repaint. It exists because in-place
- * text editing must be ONE undo step like every other direct manipulation —
- * before this, nothing in the command layer could touch a label.
- */
-export declare class SetNodeLabelCommand extends Command {
-    private nodeId;
-    private oldLabel?;
-    private readonly newLabel;
-    constructor(nodeId: string, newLabel: string, oldLabel?: string);
-    execute(context: CommandContext): void;
-    undo(context: CommandContext): void;
-    canExecute(context: CommandContext): boolean;
-    canUndo(context: CommandContext): boolean;
-    /**
-     * Never merge: each committed edit (one editor session) is one undo step.
-     */
-    canMergeWith(): boolean;
-    serialize(): SerializedCommand;
-    getDescription(): string;
-}

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

@@ -1,81 +0,0 @@
-"use strict";
-// SetNodeLabelCommand - Edits a node's label (wave4/interaction: in-place text editing)
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SetNodeLabelCommand = void 0;
-const Command_1 = require("../Command");
-/**
- * Set a node's label text, undoable.
- *
- * A node's label lives in metadata under `label` (that is what
- * `SVGRenderer.renderNodeLabel` reads), so this command is the metadata write
- * plus the dirty flag the renderer needs to repaint. It exists because in-place
- * text editing must be ONE undo step like every other direct manipulation —
- * before this, nothing in the command layer could touch a label.
- */
-class SetNodeLabelCommand extends Command_1.Command {
-    constructor(nodeId, newLabel, oldLabel) {
-        super('Edit Node Label');
-        this.nodeId = nodeId;
-        this.newLabel = newLabel;
-        if (oldLabel !== undefined) {
-            this.oldLabel = oldLabel;
-        }
-    }
-    execute(context) {
-        var _a;
-        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`);
-        }
-        if (this.oldLabel === undefined) {
-            this.oldLabel = (_a = node.getMetadata('label')) !== null && _a !== void 0 ? _a : '';
-        }
-        node.setLabel(this.newLabel);
-        node.markDirty('label-edited');
-    }
-    undo(context) {
-        const diagram = context.diagram;
-        if (!diagram || this.oldLabel === undefined) {
-            throw new Error('Cannot undo: missing diagram or old label');
-        }
-        const node = diagram.getNode(this.nodeId);
-        if (!node) {
-            throw new Error(`Node ${this.nodeId} not found`);
-        }
-        node.setLabel(this.oldLabel);
-        node.markDirty('label-edited');
-    }
-    canExecute(context) {
-        return context.diagram && context.diagram.nodes.has(this.nodeId);
-    }
-    canUndo(context) {
-        return context.diagram && this.oldLabel !== undefined;
-    }
-    /**
-     * Never merge: each committed edit (one editor session) is one undo step.
-     */
-    canMergeWith() {
-        return false;
-    }
-    serialize() {
-        return {
-            id: this.id,
-            name: this.name,
-            timestamp: this.timestamp,
-            data: {
-                nodeId: this.nodeId,
-                oldLabel: this.oldLabel,
-                newLabel: this.newLabel,
-            },
-        };
-    }
-    getDescription() {
-        return `Set node label to "${this.newLabel}"`;
-    }
-}
-exports.SetNodeLabelCommand = SetNodeLabelCommand;
-//# sourceMappingURL=SetNodeLabelCommand.js.map

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

@@ -1,14 +0,0 @@
-import { Command, CommandContext, SerializedCommand } from '../Command';
-export declare class SetNodeShapeConfigCommand extends Command {
-    private readonly nodeId;
-    private readonly patch;
-    /** The whole `metadata.shape` object before execute() — undefined = key absent. */
-    private previous?;
-    constructor(nodeId: string, patch: Readonly<Record<string, unknown>>);
-    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/SetNodeShapeConfigCommand.js

@@ -1,69 +0,0 @@
-"use strict";
-// SetNodeShapeConfigCommand — undoable edit of `metadata.shape` keys.
-//
-// visio-panel. A node's paints live in TWO dialects: the typed `node.style`
-// (SetNodeStyleCommand's territory, wins the cascade) and the legacy
-// `metadata.shape` config a stamped master carries. For paints the style wins,
-// so the panel writes style and is done — but `cornerRadius` is NOT a paint:
-// the renderer emits it as rect GEOMETRY (rx/ry), and a geometry rx DEFERS over
-// the style-borne `borderRadius` (shape-registry `bodyDeferGeomKeys`). On the
-// 12 masters that ship `shape.cornerRadius` (the BPMN task family), a
-// style-only write would change nothing on screen — the panel must edit the
-// key that actually paints, undoably. This is that command.
-//
-// The whole `shape` object is ONE metadata key (one LWW register over collab),
-// so the snapshot is the whole object — per-key undo would be finer than the
-// sync granularity and could resurrect keys a peer deleted.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SetNodeShapeConfigCommand = void 0;
-const Command_1 = require("../Command");
-class SetNodeShapeConfigCommand extends Command_1.Command {
-    constructor(nodeId, patch) {
-        super('Set Node Shape Config');
-        this.nodeId = nodeId;
-        this.patch = patch;
-    }
-    execute(context) {
-        var _a;
-        const node = (_a = context.diagram) === null || _a === void 0 ? void 0 : _a.getNode(this.nodeId);
-        if (!node)
-            throw new Error(`Node ${this.nodeId} not found`);
-        // Snapshot on EVERY execute — execute → undo → redo → undo must restore the
-        // state each undo actually followed.
-        const current = node.getMetadata('shape');
-        this.previous = { shape: current ? Object.assign({}, current) : undefined };
-        node.setMetadata('shape', Object.assign(Object.assign({}, (current !== null && current !== void 0 ? current : {})), this.patch));
-    }
-    undo(context) {
-        var _a;
-        const node = (_a = context.diagram) === null || _a === void 0 ? void 0 : _a.getNode(this.nodeId);
-        if (!node || !this.previous) {
-            throw new Error('Cannot undo: missing node or previous shape config');
-        }
-        // Restore verbatim through setMetadata — the one funnel trackChange (and so
-        // collab) captures. A shape that did not exist goes back to undefined, which
-        // the renderer treats as the plain-rect default it always had.
-        node.setMetadata('shape', this.previous.shape ? Object.assign({}, this.previous.shape) : undefined);
-    }
-    canExecute(context) {
-        var _a;
-        return !!((_a = context.diagram) === null || _a === void 0 ? void 0 : _a.getNode(this.nodeId)) && Object.keys(this.patch).length > 0;
-    }
-    canUndo(context) {
-        var _a;
-        return !!((_a = context.diagram) === null || _a === void 0 ? void 0 : _a.getNode(this.nodeId)) && !!this.previous;
-    }
-    serialize() {
-        return {
-            id: this.id,
-            name: this.name,
-            timestamp: this.timestamp,
-            data: { nodeId: this.nodeId, patch: this.patch, previous: this.previous },
-        };
-    }
-    getDescription() {
-        return `Set shape config of node ${this.nodeId}`;
-    }
-}
-exports.SetNodeShapeConfigCommand = SetNodeShapeConfigCommand;
-//# sourceMappingURL=SetNodeShapeConfigCommand.js.map

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

@@ -1,15 +0,0 @@
-import { Command, CommandContext, SerializedCommand } from '../Command';
-import type { NodeStyle } from '../../types';
-export declare class SetNodeStyleCommand extends Command {
-    private readonly style;
-    private readonly nodeIds;
-    /** Per-node snapshot of the WHOLE style before execute(), keyed by node id. */
-    private previousStyles?;
-    constructor(nodeId: string | readonly string[], style: Partial<NodeStyle>);
-    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/SetNodeStyleCommand.js

@@ -1,88 +0,0 @@
-"use strict";
-// SetNodeStyleCommand — undoable edit of one or many nodes' style.
-//
-// The gap analysis recorded this as the hole it was: "of 35 commands the only style one
-// is UpdateLinkStyleCommand; NO node style command — setStyle() is a raw write outside
-// undo." Changing a node's fill is the most ordinary edit a diagram editor has, and it
-// was the one edit Ctrl+Z could not take back.
-//
-// It takes MANY nodes on purpose. Restyling is almost always done to a selection, and a
-// selection restyle has to be ONE undo entry — pressing Ctrl+Z five times to undo one
-// gesture is a bug the user feels immediately. A batch of single-node commands would
-// also work, but each node still needs its OWN snapshot, which is the part that is easy
-// to get wrong (see the test that gives two nodes different prior styles).
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SetNodeStyleCommand = void 0;
-const Command_1 = require("../Command");
-class SetNodeStyleCommand extends Command_1.Command {
-    constructor(nodeId, style) {
-        super('Set Node Style');
-        this.style = style;
-        this.nodeIds = typeof nodeId === 'string' ? [nodeId] : [...nodeId];
-    }
-    execute(context) {
-        const diagram = context.diagram;
-        if (!diagram)
-            throw new Error('Diagram not found in context');
-        // Resolve EVERY target before mutating anything. A partial application is worse
-        // than a refusal: the caller sees a thrown error but half the selection has already
-        // changed, and the undo entry the manager discards would have been the only way
-        // back. Resolve-then-write makes the failure atomic.
-        const nodes = this.nodeIds.map((id) => {
-            const n = diagram.getNode(id);
-            if (!n)
-                throw new Error(`Node ${id} not found`);
-            return n;
-        });
-        // Snapshot on EVERY execute, not just the first: an execute → undo → redo → undo
-        // round-trip must restore the state each undo actually followed.
-        this.previousStyles = new Map(nodes.map((n) => [n.id, Object.assign({}, n.style)]));
-        for (const n of nodes)
-            n.setStyle(this.style);
-    }
-    undo(context) {
-        const diagram = context.diagram;
-        if (!diagram || !this.previousStyles) {
-            throw new Error('Cannot undo: missing diagram or previous style');
-        }
-        for (const [id, previous] of this.previousStyles) {
-            const node = diagram.getNode(id);
-            if (!node)
-                continue; // deleted since; its removal owns its own undo entry
-            // `replaceStyle`, never `setStyle` and never the field. setStyle MERGES, so it
-            // cannot remove a key this command introduced; the field write skips
-            // `trackChange()` and so never reaches a collab peer.
-            node.replaceStyle(previous);
-        }
-    }
-    canExecute(context) {
-        const diagram = context.diagram;
-        if (!diagram)
-            return false;
-        return this.nodeIds.length > 0 && this.nodeIds.every((id) => !!diagram.getNode(id));
-    }
-    canUndo(context) {
-        return !!context.diagram && !!this.previousStyles;
-    }
-    serialize() {
-        return {
-            id: this.id,
-            name: this.name,
-            timestamp: this.timestamp,
-            data: {
-                nodeIds: [...this.nodeIds],
-                style: this.style,
-                previousStyles: this.previousStyles
-                    ? Object.fromEntries(this.previousStyles)
-                    : undefined,
-            },
-        };
-    }
-    getDescription() {
-        return this.nodeIds.length === 1
-            ? `Set style of node ${this.nodeIds[0]}`
-            : `Set style of ${this.nodeIds.length} nodes`;
-    }
-}
-exports.SetNodeStyleCommand = SetNodeStyleCommand;
-//# sourceMappingURL=SetNodeStyleCommand.js.map

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

@@ -1,13 +0,0 @@
-import { Command, CommandContext, SerializedCommand } from '../Command';
-export declare class SetParentCommand extends Command {
-    private nodeId;
-    private newParentId?;
-    private oldParentId?;
-    constructor(nodeId: string, newParentId?: string | undefined);
-    execute(context: CommandContext): void;
-    undo(context: CommandContext): void;
-    canExecute(context: CommandContext): boolean;
-    canUndo(context: CommandContext): boolean;
-    serialize(): SerializedCommand;
-    getDescription(): string;
-}