@grafloria/element 0.3.18 → 0.3.19

package/src/libs/engine/src/commands/CommandManager.d.ts

@@ -0,0 +1,161 @@
+import { Command, CommandContext } from './Command';
+import { EventBus } from '../events/EventBus';
+export interface CommandHistoryEntry {
+    command: Command;
+    timestamp: number;
+    duration: number;
+    /**
+     * Wave 14: history only ever records commands that EXECUTED successfully, so
+     * this is always `true` and `error` is never set. Both fields survive purely
+     * for API compatibility — a command that throws (or fails strict validation)
+     * no longer enters history at all, because canUndo()/undo() never consulted
+     * these flags and would happily "undo" a mutation that never happened.
+     */
+    success: boolean;
+    error?: Error;
+}
+export declare class CommandManager {
+    private context;
+    private eventBus;
+    private history;
+    private currentIndex;
+    private maxHistorySize;
+    private batchMode;
+    private batchCommands;
+    private mergingEnabled;
+    private mergingWindow;
+    constructor(context: CommandContext, eventBus?: EventBus);
+    /**
+     * Wave 9 — Card 7. Is the document locked against edits?
+     *
+     * THE choke point for every command-shaped mutation. It matters far more than it
+     * looks, because these all funnel through here:
+     *   - clipboard: Paste / Cut / Duplicate commands (and `engine.paste()` etc.)
+     *   - the Wave-6 a11y keyboard layer, which is a pure COMMAND FACTORY — it
+     *     returns `Command | null` and never executes, so refusing here refuses
+     *     keyboard delete / nudge / duplicate / connect in one place
+     *   - `ext/public-api.ts`, the extension escape hatch
+     *
+     * `context.diagram` is typed `any` on CommandContext, hence the defensive probe.
+     */
+    private isReadonly;
+    /**
+     * Execute a command
+     */
+    execute(command: Command): Promise<void>;
+    /**
+     * Merge `incoming` into the previous history entry and re-execute (wave 14).
+     *
+     * Order matters: the merged command EXECUTES FIRST and only then replaces the
+     * entry's command — the old code overwrote the entry BEFORE re-executing, so
+     * a throwing merged execution left history claiming the merged command was
+     * applied.
+     *
+     * Strict validation applies here too — deliberately NOT skipped: had
+     * `incoming` not merged, the normal path would have validated this exact
+     * terminal state (mergeable commands are set-to-value, so executing the
+     * merged command lands exactly where executing `incoming` on top of
+     * `previous` would have). Merging is a history-compression detail and must
+     * not double as a validation bypass. The revert is two steps because a
+     * merged command keeps the ORIGINAL before-state (see MoveNodeCommand):
+     * merged.undo() rewinds PAST `previous`, so previous.redo() then re-applies
+     * the last valid state, leaving the history entry untouched.
+     */
+    private executeMerged;
+    /**
+     * Real-time validation of the diagram AFTER a command executed (wave 14).
+     *
+     * In strict mode an invalid diagram runs `revert` — which must undo exactly
+     * the just-executed command — and throws. It must NOT call this.undo(): the
+     * failing command is not in history (yet), so undo() would revert the
+     * PREVIOUS entry and decrement currentIndex, which is precisely the old
+     * triple corruption (previous good command reverted, then permanently erased
+     * by addToHistory's redo-truncation, failed command left as the undoable top).
+     */
+    private assertResultValid;
+    /**
+     * Undo last command
+     */
+    undo(): Promise<void>;
+    /**
+     * Redo command
+     */
+    redo(): Promise<void>;
+    /**
+     * Begin batch mode
+     */
+    beginBatch(): void;
+    /**
+     * End batch mode: commit the queued commands as ONE BatchCommand through the
+     * normal execute() path (wave 14) — one history entry, one undo step (with
+     * reverse-order undo), and the same strict-validation gate as any other
+     * command. The old code looped executeCommand() directly, so a "batch"
+     * mutated the diagram while building NO history at all.
+     *
+     * Note BatchCommand's existing gate contract: its canExecute() checks every
+     * queued command against the CURRENT (pre-batch) state, so a queue whose
+     * later commands only become executable after earlier ones ran is refused
+     * up front rather than applied halfway.
+     */
+    endBatch(name?: string): Promise<void>;
+    /**
+     * Cancel batch
+     */
+    cancelBatch(): void;
+    /**
+     * Clear history
+     */
+    clear(): void;
+    /**
+     * Can undo
+     */
+    canUndo(): boolean;
+    /**
+     * Can redo
+     */
+    canRedo(): boolean;
+    /**
+     * Get history
+     */
+    getHistory(): ReadonlyArray<CommandHistoryEntry>;
+    /**
+     * Get undo stack
+     */
+    getUndoStack(): ReadonlyArray<Command>;
+    /**
+     * Get redo stack
+     */
+    getRedoStack(): ReadonlyArray<Command>;
+    /**
+     * Set max history size
+     */
+    setMaxHistorySize(size: number): void;
+    /**
+     * Enable/disable merging
+     */
+    setMergingEnabled(enabled: boolean): void;
+    /**
+     * Set merging window
+     */
+    setMergingWindow(milliseconds: number): void;
+    /**
+     * Update command context
+     */
+    updateContext(updates: Partial<CommandContext>): void;
+    /**
+     * Execute command without adding to history
+     */
+    private executeCommand;
+    /**
+     * Add command to history
+     */
+    private addToHistory;
+    /**
+     * Trim history to max size
+     */
+    private trimHistory;
+    /**
+     * Check if can merge with previous command
+     */
+    private canMergeWithPrevious;
+}

package/src/libs/engine/src/commands/CommandManager.js

@@ -0,0 +1,417 @@
+"use strict";
+// CommandManager - Manages command execution, undo, and redo
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandManager = void 0;
+const tslib_1 = require("tslib");
+const BatchCommand_1 = require("./composite/BatchCommand");
+const event_types_1 = require("../types/event.types");
+class CommandManager {
+    constructor(context, eventBus = context.eventBus) {
+        this.context = context;
+        this.eventBus = eventBus;
+        this.history = [];
+        this.currentIndex = -1;
+        this.maxHistorySize = 100;
+        this.batchMode = false;
+        this.batchCommands = [];
+        this.mergingEnabled = true;
+        this.mergingWindow = 500; // ms
+    }
+    /**
+     * Wave 9 — Card 7. Is the document locked against edits?
+     *
+     * THE choke point for every command-shaped mutation. It matters far more than it
+     * looks, because these all funnel through here:
+     *   - clipboard: Paste / Cut / Duplicate commands (and `engine.paste()` etc.)
+     *   - the Wave-6 a11y keyboard layer, which is a pure COMMAND FACTORY — it
+     *     returns `Command | null` and never executes, so refusing here refuses
+     *     keyboard delete / nudge / duplicate / connect in one place
+     *   - `ext/public-api.ts`, the extension escape hatch
+     *
+     * `context.diagram` is typed `any` on CommandContext, hence the defensive probe.
+     */
+    isReadonly() {
+        var _a, _b, _c;
+        return ((_c = (_b = (_a = this.context) === null || _a === void 0 ? void 0 : _a.diagram) === null || _b === void 0 ? void 0 : _b.blocksDocumentWrite) === null || _c === void 0 ? void 0 : _c.call(_b)) === true;
+    }
+    /**
+     * Execute a command
+     */
+    execute(command) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            // Refused BEFORE canExecute so a command cannot mutate anything in its own
+            // permission check, and before the merge path below — a merged command
+            // re-executes, which would otherwise be a hole straight through the lock.
+            if (this.isReadonly()) {
+                this.eventBus.emit('command:refused', { command, reason: 'readonly' });
+                return;
+            }
+            if (!command.canExecute(this.context)) {
+                throw new Error(`Cannot execute command: ${command.name}`);
+            }
+            if (this.batchMode) {
+                this.batchCommands.push(command);
+                return;
+            }
+            // Try to merge with previous command
+            if (this.mergingEnabled && this.canMergeWithPrevious(command)) {
+                const lastEntry = this.history[this.currentIndex];
+                if (lastEntry) {
+                    yield this.executeMerged(lastEntry, command);
+                    return;
+                }
+            }
+            // Execute command
+            const startTime = performance.now();
+            try {
+                yield this.executeCommand(command);
+                // Real-time validation (Phase 1 - Critical Fixes). In strict mode an
+                // invalid result reverts THIS command and throws — see assertResultValid.
+                yield this.assertResultValid(() => command.undo(this.context));
+            }
+            catch (e) {
+                this.eventBus.emit(event_types_1.DiagramEventTypes.COMMAND_FAILED, {
+                    command,
+                    duration: performance.now() - startTime,
+                    error: e,
+                });
+                throw e;
+            }
+            const duration = performance.now() - startTime;
+            // Only a command that EXECUTED (and validated) may enter history. A thrown
+            // execute() used to land here anyway — via a `finally` — leaving Ctrl+Z
+            // pointing at a mutation that never happened.
+            //
+            // And only a command that DECLARES ITSELF UNDOABLE. A non-mutating command
+            // (Copy) recorded here used to poison the stack: undo() reached the entry,
+            // its canUndo() said no, the throw skipped the index decrement, and every
+            // entry behind it became permanently unreachable while canUndo() kept
+            // reporting true.
+            if (command.isUndoable()) {
+                this.addToHistory({
+                    command,
+                    timestamp: Date.now(),
+                    duration,
+                    success: true,
+                });
+            }
+            this.eventBus.emit(event_types_1.DiagramEventTypes.COMMAND_EXECUTED, {
+                command,
+                duration,
+            });
+        });
+    }
+    /**
+     * Merge `incoming` into the previous history entry and re-execute (wave 14).
+     *
+     * Order matters: the merged command EXECUTES FIRST and only then replaces the
+     * entry's command — the old code overwrote the entry BEFORE re-executing, so
+     * a throwing merged execution left history claiming the merged command was
+     * applied.
+     *
+     * Strict validation applies here too — deliberately NOT skipped: had
+     * `incoming` not merged, the normal path would have validated this exact
+     * terminal state (mergeable commands are set-to-value, so executing the
+     * merged command lands exactly where executing `incoming` on top of
+     * `previous` would have). Merging is a history-compression detail and must
+     * not double as a validation bypass. The revert is two steps because a
+     * merged command keeps the ORIGINAL before-state (see MoveNodeCommand):
+     * merged.undo() rewinds PAST `previous`, so previous.redo() then re-applies
+     * the last valid state, leaving the history entry untouched.
+     */
+    executeMerged(lastEntry, incoming) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const previous = lastEntry.command;
+            const merged = previous.mergeWith(incoming);
+            const startTime = performance.now();
+            try {
+                yield this.executeCommand(merged);
+                yield this.assertResultValid(() => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                    yield merged.undo(this.context);
+                    yield previous.redo(this.context);
+                }));
+            }
+            catch (e) {
+                // History untouched: the entry still describes `previous`, which IS
+                // what remains applied.
+                this.eventBus.emit(event_types_1.DiagramEventTypes.COMMAND_FAILED, {
+                    command: merged,
+                    duration: performance.now() - startTime,
+                    error: e,
+                });
+                throw e;
+            }
+            lastEntry.command = merged;
+            lastEntry.timestamp = Date.now();
+            this.eventBus.emit(event_types_1.DiagramEventTypes.COMMAND_MERGED, { command: merged });
+        });
+    }
+    /**
+     * Real-time validation of the diagram AFTER a command executed (wave 14).
+     *
+     * In strict mode an invalid diagram runs `revert` — which must undo exactly
+     * the just-executed command — and throws. It must NOT call this.undo(): the
+     * failing command is not in history (yet), so undo() would revert the
+     * PREVIOUS entry and decrement currentIndex, which is precisely the old
+     * triple corruption (previous good command reverted, then permanently erased
+     * by addToHistory's redo-truncation, failed command left as the undoable top).
+     */
+    assertResultValid(revert) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const engine = this.context.engine;
+            if (!engine)
+                return;
+            if (!(engine.isRealTimeValidationEnabled && engine.isRealTimeValidationEnabled()))
+                return;
+            const config = engine.getConfig && engine.getConfig();
+            const strict = ((_a = config === null || config === void 0 ? void 0 : config.validation) === null || _a === void 0 ? void 0 : _a.strict) || false;
+            const validationResult = engine.validateDiagram({ strict });
+            if (!validationResult.valid && strict) {
+                yield revert();
+                throw new Error(`Command validation failed: ${(_b = validationResult.errors[0]) === null || _b === void 0 ? void 0 : _b.message}`);
+            }
+        });
+    }
+    /**
+     * Undo last command
+     */
+    undo() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            // Undo is a MUTATION and it bypasses executeCommand() entirely (it calls
+            // command.undo() directly), so it needs its own guard — gating execute()
+            // alone would leave undo/redo as a wide-open door into a locked document.
+            if (this.isReadonly()) {
+                this.eventBus.emit('command:refused', { reason: 'readonly', phase: 'undo' });
+                return;
+            }
+            if (!this.canUndo()) {
+                return;
+            }
+            const entry = this.history[this.currentIndex];
+            if (!entry)
+                return;
+            const command = entry.command;
+            if (!command.canUndo(this.context)) {
+                throw new Error(`Cannot undo command: ${command.name}`);
+            }
+            const startTime = performance.now();
+            try {
+                yield command.undo(this.context);
+                this.currentIndex--;
+                const duration = performance.now() - startTime;
+                this.eventBus.emit(event_types_1.DiagramEventTypes.COMMAND_UNDONE, {
+                    command,
+                    duration,
+                });
+            }
+            catch (error) {
+                this.eventBus.emit(event_types_1.DiagramEventTypes.COMMAND_FAILED, {
+                    command,
+                    action: 'undo',
+                    error,
+                });
+                throw error;
+            }
+        });
+    }
+    /**
+     * Redo command
+     */
+    redo() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isReadonly()) {
+                this.eventBus.emit('command:refused', { reason: 'readonly', phase: 'redo' });
+                return;
+            }
+            if (!this.canRedo()) {
+                return;
+            }
+            this.currentIndex++;
+            const entry = this.history[this.currentIndex];
+            if (!entry)
+                return;
+            const command = entry.command;
+            const startTime = performance.now();
+            try {
+                yield command.redo(this.context);
+                const duration = performance.now() - startTime;
+                this.eventBus.emit(event_types_1.DiagramEventTypes.COMMAND_REDONE, {
+                    command,
+                    duration,
+                });
+            }
+            catch (error) {
+                this.currentIndex--;
+                this.eventBus.emit(event_types_1.DiagramEventTypes.COMMAND_FAILED, {
+                    command,
+                    action: 'redo',
+                    error,
+                });
+                throw error;
+            }
+        });
+    }
+    /**
+     * Begin batch mode
+     */
+    beginBatch() {
+        this.batchMode = true;
+        this.batchCommands = [];
+    }
+    /**
+     * End batch mode: commit the queued commands as ONE BatchCommand through the
+     * normal execute() path (wave 14) — one history entry, one undo step (with
+     * reverse-order undo), and the same strict-validation gate as any other
+     * command. The old code looped executeCommand() directly, so a "batch"
+     * mutated the diagram while building NO history at all.
+     *
+     * Note BatchCommand's existing gate contract: its canExecute() checks every
+     * queued command against the CURRENT (pre-batch) state, so a queue whose
+     * later commands only become executable after earlier ones ran is refused
+     * up front rather than applied halfway.
+     */
+    endBatch() {
+        return tslib_1.__awaiter(this, arguments, void 0, function* (name = 'Batch Operation') {
+            this.batchMode = false;
+            // Guarded here as well as in execute(): the refusal must clear the queue
+            // and announce phase 'batch', which execute()'s generic guard would not.
+            // A batch opened before the document was locked and flushed after would
+            // otherwise replay every queued command straight through the lock.
+            if (this.isReadonly()) {
+                this.batchCommands = [];
+                this.eventBus.emit('command:refused', { reason: 'readonly', phase: 'batch' });
+                return;
+            }
+            if (this.batchCommands.length === 0) {
+                return;
+            }
+            const commands = [...this.batchCommands];
+            this.batchCommands = [];
+            yield this.execute(new BatchCommand_1.BatchCommand(name, commands));
+        });
+    }
+    /**
+     * Cancel batch
+     */
+    cancelBatch() {
+        this.batchMode = false;
+        this.batchCommands = [];
+    }
+    /**
+     * Clear history
+     */
+    clear() {
+        this.history = [];
+        this.currentIndex = -1;
+        this.eventBus.emit(event_types_1.DiagramEventTypes.COMMAND_HISTORY_CLEARED);
+    }
+    /**
+     * Can undo
+     */
+    canUndo() {
+        return this.currentIndex >= 0;
+    }
+    /**
+     * Can redo
+     */
+    canRedo() {
+        return this.currentIndex < this.history.length - 1;
+    }
+    /**
+     * Get history
+     */
+    getHistory() {
+        return [...this.history];
+    }
+    /**
+     * Get undo stack
+     */
+    getUndoStack() {
+        return this.history.slice(0, this.currentIndex + 1).map((e) => e.command);
+    }
+    /**
+     * Get redo stack
+     */
+    getRedoStack() {
+        return this.history.slice(this.currentIndex + 1).map((e) => e.command);
+    }
+    /**
+     * Set max history size
+     */
+    setMaxHistorySize(size) {
+        this.maxHistorySize = size;
+        this.trimHistory();
+    }
+    /**
+     * Enable/disable merging
+     */
+    setMergingEnabled(enabled) {
+        this.mergingEnabled = enabled;
+    }
+    /**
+     * Set merging window
+     */
+    setMergingWindow(milliseconds) {
+        this.mergingWindow = milliseconds;
+    }
+    /**
+     * Update command context
+     */
+    updateContext(updates) {
+        this.context = Object.assign(Object.assign({}, this.context), updates);
+    }
+    /**
+     * Execute command without adding to history
+     */
+    executeCommand(command) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            yield command.execute(this.context);
+        });
+    }
+    /**
+     * Add command to history
+     */
+    addToHistory(entry) {
+        // Remove any redo history
+        if (this.currentIndex < this.history.length - 1) {
+            this.history = this.history.slice(0, this.currentIndex + 1);
+        }
+        // Add new entry
+        this.history.push(entry);
+        this.currentIndex++;
+        // Trim if needed
+        this.trimHistory();
+    }
+    /**
+     * Trim history to max size
+     */
+    trimHistory() {
+        if (this.history.length > this.maxHistorySize) {
+            const removeCount = this.history.length - this.maxHistorySize;
+            this.history = this.history.slice(removeCount);
+            this.currentIndex -= removeCount;
+        }
+    }
+    /**
+     * Check if can merge with previous command
+     */
+    canMergeWithPrevious(command) {
+        if (this.currentIndex < 0) {
+            return false;
+        }
+        const lastEntry = this.history[this.currentIndex];
+        if (!lastEntry)
+            return false;
+        const lastCommand = lastEntry.command;
+        // Check time window
+        const timeDiff = Date.now() - lastEntry.timestamp;
+        if (timeDiff > this.mergingWindow) {
+            return false;
+        }
+        // Check if commands can merge
+        return lastCommand.canMergeWith(command);
+    }
+}
+exports.CommandManager = CommandManager;
+//# sourceMappingURL=CommandManager.js.map

package/src/libs/engine/src/commands/CommandManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CommandManager.js","sourceRoot":"","sources":["../../../../../../engine/src/commands/CommandManager.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,13 @@
+import { Command, CommandContext, SerializedCommand } from '../Command';
+import { GroupModel } from '../../models/GroupModel';
+export declare class AddGroupCommand extends Command {
+    private group;
+    private groupData;
+    constructor(group: GroupModel);
+    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/AddGroupCommand.js

@@ -0,0 +1,50 @@
+"use strict";
+// AddGroupCommand - Adds a group to the diagram (Phase 1.6c)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddGroupCommand = void 0;
+const Command_1 = require("../Command");
+const GroupModel_1 = require("../../models/GroupModel");
+class AddGroupCommand extends Command_1.Command {
+    constructor(group) {
+        super('Add Group');
+        this.group = group;
+        this.groupData = group.serialize();
+    }
+    execute(context) {
+        const diagram = context.diagram;
+        if (!diagram) {
+            throw new Error('Diagram not found in context');
+        }
+        // Restore group from serialized data
+        const group = GroupModel_1.GroupModel.fromJSON(this.groupData);
+        diagram.addGroup(group);
+    }
+    undo(context) {
+        const diagram = context.diagram;
+        if (!diagram) {
+            throw new Error('Diagram not found in context');
+        }
+        diagram.removeGroup(this.groupData.id);
+    }
+    canExecute(context) {
+        return !!(context.diagram && !context.diagram.groups.has(this.groupData.id));
+    }
+    canUndo(context) {
+        return !!(context.diagram && context.diagram.groups.has(this.groupData.id));
+    }
+    serialize() {
+        return {
+            id: this.id,
+            name: this.name,
+            timestamp: this.timestamp,
+            data: {
+                group: this.groupData,
+            },
+        };
+    }
+    getDescription() {
+        return `Add group "${this.groupData.name}"`;
+    }
+}
+exports.AddGroupCommand = AddGroupCommand;
+//# sourceMappingURL=AddGroupCommand.js.map

package/src/libs/engine/src/commands/basic/AddGroupCommand.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AddGroupCommand.js","sourceRoot":"","sources":["../../../../../../../engine/src/commands/basic/AddGroupCommand.ts"],"names":[],"mappings":";AAAA,6DAA6D;;;AAE7D,wCAAwE;AACxE,wDAAsE;AAEtE,MAAa,eAAgB,SAAQ,iBAAO;IAG1C,YAAoB,KAAiB;QACnC,KAAK,CAAC,WAAW,CAAC,CAAC;QADD,UAAK,GAAL,KAAK,CAAY;QAEnC,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC,SAAS,EAAE,CAAC;IACrC,CAAC;IAEQ,OAAO,CAAC,OAAuB;QACtC,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;QAChC,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC;QAClD,CAAC;QAED,qCAAqC;QACrC,MAAM,KAAK,GAAG,uBAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAClD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC1B,CAAC;IAEQ,IAAI,CAAC,OAAuB;QACnC,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;QAChC,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC;QAClD,CAAC;QAED,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;IACzC,CAAC;IAEQ,UAAU,CAAC,OAAuB;QACzC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC;IAC/E,CAAC;IAEQ,OAAO,CAAC,OAAuB;QACtC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC;IAC9E,CAAC;IAEQ,SAAS;QAChB,OAAO;YACL,EAAE,EAAE,IAAI,CAAC,EAAE;YACX,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,IAAI,EAAE;gBACJ,KAAK,EAAE,IAAI,CAAC,SAAS;aACtB;SACF,CAAC;IACJ,CAAC;IAEQ,cAAc;QACrB,OAAO,cAAc,IAAI,CAAC,SAAS,CAAC,IAAI,GAAG,CAAC;IAC9C,CAAC;CACF;AAlDD,0CAkDC"}

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

@@ -0,0 +1,13 @@
+import { Command, CommandContext, SerializedCommand } from '../Command';
+import { LinkModel } from '../../models/LinkModel';
+export declare class AddLinkCommand extends Command {
+    private link;
+    private linkData;
+    constructor(link: LinkModel);
+    execute(context: CommandContext): void;
+    undo(context: CommandContext): void;
+    canExecute(context: CommandContext): boolean;
+    canUndo(context: CommandContext): boolean;
+    serialize(): SerializedCommand;
+    getDescription(): string;
+}