@grafloria/element 0.3.20 → 0.3.21

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

@@ -1,417 +0,0 @@
-"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/basic/AddGroupCommand.d.ts

@@ -1,13 +0,0 @@
-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

@@ -1,50 +0,0 @@
-"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/AddLinkCommand.d.ts

@@ -1,13 +0,0 @@
-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;
-}

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

@@ -1,50 +0,0 @@
-"use strict";
-// AddLinkCommand - Adds a link to the diagram
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AddLinkCommand = void 0;
-const Command_1 = require("../Command");
-const LinkModel_1 = require("../../models/LinkModel");
-class AddLinkCommand extends Command_1.Command {
-    constructor(link) {
-        super('Add Link');
-        this.link = link;
-        this.linkData = link.serialize();
-    }
-    execute(context) {
-        const diagram = context.diagram;
-        if (!diagram) {
-            throw new Error('Diagram not found in context');
-        }
-        // Restore link from serialized data
-        const link = LinkModel_1.LinkModel.fromJSON(this.linkData);
-        diagram.addLink(link);
-    }
-    undo(context) {
-        const diagram = context.diagram;
-        if (!diagram) {
-            throw new Error('Diagram not found in context');
-        }
-        diagram.removeLink(this.linkData.id);
-    }
-    canExecute(context) {
-        return context.diagram && !context.diagram.links.has(this.linkData.id);
-    }
-    canUndo(context) {
-        return context.diagram && context.diagram.links.has(this.linkData.id);
-    }
-    serialize() {
-        return {
-            id: this.id,
-            name: this.name,
-            timestamp: this.timestamp,
-            data: {
-                link: this.linkData,
-            },
-        };
-    }
-    getDescription() {
-        return `Add link from ${this.linkData.sourcePortId} to ${this.linkData.targetPortId}`;
-    }
-}
-exports.AddLinkCommand = AddLinkCommand;
-//# sourceMappingURL=AddLinkCommand.js.map

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

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

@@ -1,65 +0,0 @@
-"use strict";
-// AddNodeCommand - Adds a node to the diagram
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AddNodeCommand = void 0;
-const Command_1 = require("../Command");
-const NodeModel_1 = require("../../models/NodeModel");
-class AddNodeCommand extends Command_1.Command {
-    constructor(node) {
-        super('Add Node');
-        this.node = node;
-        this.nodeData = node.serialize();
-    }
-    execute(context) {
-        const diagram = context.diagram;
-        if (!diagram) {
-            throw new Error('Diagram not found in context');
-        }
-        // Restore node from serialized data
-        const node = NodeModel_1.NodeModel.fromJSON(this.nodeData);
-        diagram.addNode(node);
-        // Set up hierarchy if node has parent (Phase 1.6a Part 5)
-        if (node.parentId) {
-            const parent = diagram.getNode(node.parentId);
-            if (parent) {
-                parent.addChild(node.id);
-            }
-        }
-    }
-    undo(context) {
-        const diagram = context.diagram;
-        if (!diagram) {
-            throw new Error('Diagram not found in context');
-        }
-        // Clean up hierarchy before removing (Phase 1.6a Part 5)
-        const node = diagram.getNode(this.nodeData.id);
-        if (node && node.parentId) {
-            const parent = diagram.getNode(node.parentId);
-            if (parent) {
-                parent.removeChild(node.id);
-            }
-        }
-        diagram.removeNode(this.nodeData.id);
-    }
-    canExecute(context) {
-        return context.diagram && !context.diagram.nodes.has(this.nodeData.id);
-    }
-    canUndo(context) {
-        return context.diagram && context.diagram.nodes.has(this.nodeData.id);
-    }
-    serialize() {
-        return {
-            id: this.id,
-            name: this.name,
-            timestamp: this.timestamp,
-            data: {
-                node: this.nodeData,
-            },
-        };
-    }
-    getDescription() {
-        return `Add ${this.nodeData.type} node`;
-    }
-}
-exports.AddNodeCommand = AddNodeCommand;
-//# sourceMappingURL=AddNodeCommand.js.map

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

@@ -1,12 +0,0 @@
-import { Command, CommandContext, SerializedCommand } from '../Command';
-export declare class AddToGroupCommand extends Command {
-    private groupId;
-    private entityId;
-    constructor(groupId: string, entityId: string);
-    execute(context: CommandContext): void;
-    undo(context: CommandContext): void;
-    canExecute(context: CommandContext): boolean;
-    canUndo(context: CommandContext): boolean;
-    serialize(): SerializedCommand;
-    getDescription(): string;
-}