@grafloria/element 0.3.17 → 0.3.19

package/src/libs/engine/src/collab/undo.js

@@ -0,0 +1,388 @@
+"use strict";
+// Wave 9 — Card 4: COLLABORATION-AWARE UNDO.
+//
+// ---------------------------------------------------------------------------
+// CTRL-Z MUST UNDO *MY* LAST EDIT, NOT THE LAST EDIT
+// ---------------------------------------------------------------------------
+//
+// If Alice moves a node and Bob presses Ctrl-Z, Bob must not undo Alice's move. It is the
+// single most infuriating bug in every home-grown multiplayer editor, and it comes from
+// the same place every time: one global history stack, shared by everyone, popped by
+// whoever pressed the key.
+//
+// Here the property is STRUCTURAL, not a filter. `OpCapture` emits ops for LOCAL edits
+// only — remote ops are applied with capture suppressed (that same three-character
+// re-entrancy guard that stops two peers ping-ponging). So an op that reaches this stack
+// is MINE BY CONSTRUCTION. There is nothing to filter out, and therefore no filter to get
+// wrong later. The test still asserts it, because a structural guarantee that nobody
+// checks is one refactor away from not being one.
+//
+// ---------------------------------------------------------------------------
+// THE HARD PART: UNDO MUST NOT RESURRECT STALE STATE
+// ---------------------------------------------------------------------------
+//
+// A naive undo restores the value it captured when the edit was made. That is wrong the
+// moment anyone else is in the document, and wrong in a way that destroys other people's
+// work:
+//
+//     Bob moves node N to (10,10).            [Bob's op]
+//     Alice moves N to (900,900).             [newer — this is what everyone now sees]
+//     Bob presses Ctrl-Z.
+//
+// Naive undo: "restore N to where it was before MY move" → N jumps back to its original
+// spot and ALICE'S MOVE IS SILENTLY DESTROYED. Bob undid his own edit and deleted hers.
+//
+// The correct answer is that BOB'S EDIT IS ALREADY GONE. Alice overwrote that register; the
+// document does not contain Bob's move any more. Undoing an edit that has no effect must
+// have no effect. So:
+//
+//     UNDO OF OP `O` ON REGISTER `R` IS SKIPPED IFF THE NEWEST SURVIVING WRITE TO `R`
+//     (EXCLUDING `O` AND EXCLUDING WRITES ALREADY UNDONE) IS NEWER THAN `O`.
+//
+// And when it is NOT skipped, the value restored is not the one we captured — it is THE
+// NEWEST SURVIVING WRITE OLDER THAN `O`, read out of the log. That distinction matters in
+// a case a captured `before` cannot get right:
+//
+//     Alice sets colour=red    (clock 5)
+//     Bob   sets colour=blue   (clock 9)   ← Bob captured before=red
+//     Alice sets colour=green  (clock 7)   ← arrives LATE at Bob; refused, 7 < 9
+//     Bob presses Ctrl-Z.
+//
+// Bob's captured `before` is `red` — a value that no longer exists anywhere in the
+// document's history-of-record. The log says the newest surviving write below Bob's is
+// Alice's GREEN at clock 7. Restoring red would resurrect a value two writes stale.
+// Restoring green is right, and only the log knows it.
+//
+// The captured `before` is still kept, as the fallback for the case the log CANNOT answer:
+// in production a peer joins from a SNAPSHOT plus a tail, so the op that originally set a
+// register may be long compacted away. Then `before` is the only witness there is.
+//
+// ---------------------------------------------------------------------------
+// UNDO IS AN OP
+// ---------------------------------------------------------------------------
+// An undo is an edit. It must converge, it must reach the other peers, and it must itself
+// be undoable (redo). So undo does not reach into the model behind the engine's back — it
+// applies the inverse THROUGH THE MODEL, with capture LIVE, and the op that results is
+// minted by the same clock as any other local edit. It sorts after everything it has seen,
+// so it wins its registers by the ordinary LWW rule. There is no special "undo op" kind and
+// no second code path to keep in step with the first.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UndoStack = void 0;
+const op_1 = require("./op");
+/** The register an op writes: a property path, or the entity's existence. */
+function registerOf(op) {
+    return op.op === 'set'
+        ? `${op.target} ${op.id} ${op.path}`
+        : `${op.target} ${op.id}  presence`;
+}
+/**
+ * A per-actor, supersession-aware undo/redo stack.
+ *
+ * Owns no model state. It reads the LOG to decide what an undo should do, and applies the
+ * result through the diagram so that capture mints a normal op for it.
+ */
+class UndoStack {
+    constructor(log, actor, 
+    /**
+     * Apply an inverse THROUGH THE MODEL, with capture live.
+     *
+     * Supplied by the Replica rather than called directly, because the Replica knows one
+     * thing this class must not have to: a link may be in QUARANTINE, in which case it has
+     * to be put back in the document before removing it can be a real mutation that capture
+     * can mint an op from.
+     */
+    apply) {
+        this.log = log;
+        this.actor = actor;
+        this.apply = apply;
+        this.undoable = [];
+        this.redoable = [];
+        /** Ops of mine that are currently undone. Excluded when resolving what a register held. */
+        this.undone = new Set();
+        /**
+         * Ops that MY OWN undo/redo emitted. Not authored edits — machinery.
+         *
+         * They have to be excluded when resolving what a register held, and the reason is a bug
+         * that only shows up on the SECOND press of Ctrl-Z. Undoing my move emits a fresh `set`
+         * with a fresh (therefore highest) clock. Ask "what is the newest write to this register"
+         * again, to undo the move BEFORE it, and the answer is that undo op — newer than the op
+         * being undone — so the supersession rule fires and the second Ctrl-Z silently does
+         * nothing. The user is stuck one step from where they wanted to be, for no visible reason.
+         *
+         * ONLY my own. Another peer's undo op is, to me, an ordinary write by another peer — I
+         * cannot tell it was an undo and I must not treat it as one. That asymmetry is the whole
+         * point: undo is local, ops are global.
+         */
+        this.machinery = new Set();
+        /** Open transaction: ops land here instead of becoming one entry each. */
+        this.txn = null;
+        /** True while we are applying an undo/redo, so the ops it emits are not recorded anew. */
+        this.replaying = false;
+    }
+    get canUndo() {
+        return this.undoable.length > 0;
+    }
+    get canRedo() {
+        return this.redoable.length > 0;
+    }
+    /** Depth of the undo stack — one entry per user-visible step. */
+    get depth() {
+        return this.undoable.length;
+    }
+    /**
+     * Record a local edit.
+     *
+     * Ignored while replaying: the ops an undo emits are the undo, not new work to undo.
+     */
+    record(op, before) {
+        if (this.replaying)
+            return;
+        // Any NEW work invalidates the redo branch — the same rule a single-player editor has.
+        //
+        // The entries are dropped; the ops in them STAY MARKED UNDONE. Losing the ability to redo
+        // an op is not the same as the op coming back into force: its effect was reversed by an
+        // undo op that is in the log and is never going away. Clearing the marks (which is what I
+        // wrote first) makes a discarded op count as a "surviving write" again, and the next undo
+        // of that register restores ITS value — a value the user already took back. You get it by
+        // undoing a move, typing anything at all, moving again, and undoing: the node jumps to the
+        // position you undid two steps ago.
+        this.redoable.length = 0;
+        if (this.txn) {
+            this.txn.push({ op, before });
+            return;
+        }
+        this.undoable.push({ records: [{ op, before }] });
+    }
+    /**
+     * Group everything `fn` does into ONE undo step.
+     *
+     * Without this, a gesture that touches four registers costs four Ctrl-Zs — and deleting
+     * a node with three links (which the editor does as four ops) would take four. The
+     * grouping is a LOCAL, UI-level concern: it changes what one keypress undoes, never what
+     * is on the wire, and two peers may group differently without diverging.
+     */
+    transact(fn) {
+        if (this.txn)
+            return fn(); // already in one — flatten, don't nest
+        const records = [];
+        this.txn = records;
+        try {
+            return fn();
+        }
+        finally {
+            this.txn = null;
+            if (records.length > 0)
+                this.undoable.push({ records });
+        }
+    }
+    /**
+     * Undo my last step. Returns the ops it emitted — empty if every part of it was already
+     * superseded, which is a legitimate and silent outcome.
+     *
+     * `apply` runs the inverse through the model with capture LIVE, so the resulting ops are
+     * minted, logged, gated and broadcast exactly like any other local edit.
+     */
+    undo() {
+        const entry = this.undoable.pop();
+        if (!entry)
+            return [];
+        const emitted = [];
+        this.replaying = true;
+        try {
+            // In REVERSE: the last thing done is the first thing undone, or a step that wrote the
+            // same register twice restores the wrong one of them.
+            for (const rec of [...entry.records].reverse()) {
+                this.undone.add((0, op_1.opId)(rec.op)); // …so it is excluded when we resolve the register
+                const inverse = this.invert(rec);
+                rec.undoOp = undefined;
+                if (!inverse)
+                    continue;
+                const before = this.log.size;
+                this.apply(inverse);
+                rec.undoOp = this.lastLogged(before);
+                if (rec.undoOp) {
+                    this.machinery.add((0, op_1.opId)(rec.undoOp));
+                    emitted.push(rec.undoOp);
+                }
+            }
+        }
+        finally {
+            this.replaying = false;
+        }
+        this.redoable.push(entry);
+        return emitted;
+    }
+    /** Redo the step undo last took back. */
+    redo() {
+        const entry = this.redoable.pop();
+        if (!entry)
+            return [];
+        const emitted = [];
+        this.replaying = true;
+        try {
+            for (const rec of entry.records) {
+                const forward = this.reapply(rec);
+                this.undone.delete((0, op_1.opId)(rec.op));
+                if (!forward)
+                    continue;
+                const before = this.log.size;
+                this.apply(forward);
+                const op = this.lastLogged(before);
+                if (op) {
+                    this.machinery.add((0, op_1.opId)(op));
+                    emitted.push(op);
+                }
+            }
+        }
+        finally {
+            this.replaying = false;
+        }
+        this.undoable.push(entry);
+        return emitted;
+    }
+    // -------------------------------------------------------------------------
+    /**
+     * The op that reverses `rec`, or undefined if it has already been superseded.
+     *
+     * The clock and actor on the returned op are PLACEHOLDERS and are never used: applyOp
+     * ignores them, and the op that actually reaches the log and the wire is the one capture
+     * mints from the resulting model mutation, with a fresh Lamport clock. Constructing a
+     * "real" op here and applying it directly would bypass capture and give the undo a
+     * second, divergent code path.
+     */
+    invert(rec) {
+        const { op, before } = rec;
+        const survivor = this.newestOther(op);
+        // Superseded: someone wrote this register after me. My edit is already invisible;
+        // undoing it must stay invisible. THIS IS THE LINE THAT PROTECTS ALICE'S WORK.
+        if (survivor && (0, op_1.compareOps)(survivor, op) > 0)
+            return undefined;
+        const stub = { clock: 0, actor: this.actor };
+        switch (op.op) {
+            case 'add': {
+                // If an OLDER `add` survives — I replaced an earlier incarnation of this entity —
+                // then undoing mine should restore THAT one, not delete the entity outright.
+                if (survivor && survivor.op === 'add') {
+                    return Object.assign(Object.assign({}, stub), { op: 'add', target: op.target, id: op.id, data: survivor.data });
+                }
+                return Object.assign(Object.assign({}, stub), { op: 'remove', target: op.target, id: op.id });
+            }
+            case 'remove': {
+                // TWO PEOPLE DELETE THE SAME NODE, AND ONE PRESSES CTRL-Z. This is the case that made
+                // me change the rule, and it is worth the paragraph.
+                //
+                // The tempting rule is "a colleague's delete is still standing, so the node stays
+                // gone" — recompute LWW presence excluding my undone op, and both removes vote
+                // delete. It is convergent, and it is a terrible editor: each peer only knows about
+                // its OWN undos, so BOTH users press Ctrl-Z, BOTH undos decline, and the node is gone
+                // for good with two people staring at it wondering why undo is broken. To fix that
+                // properly, an undo would have to be a first-class op that TOMBSTONES the op it
+                // undoes, so peers could recompute — a much bigger machine than this card.
+                //
+                // The rule that works is the simple one, and it is already written above: an undo is
+                // skipped IFF MY OP IS SUPERSEDED. Whoever's delete is currently IN FORCE can take it
+                // back, and the node returns. The other person's undo then finds a newer `add` on the
+                // register, sees that its own delete no longer decides anything, and correctly says
+                // nothing. One rule, both users get sane behaviour, and it converges.
+                //
+                // The `if (survivor && compareOps(...) > 0)` above is therefore LOAD-BEARING HERE and
+                // nowhere else: without it, the superseded peer re-adds ITS OWN STALE SNAPSHOT over
+                // the live incarnation, and a colleague's work vanishes.
+                //
+                // Restore the entity as it was AT THE MOMENT I DELETED IT — not as it was born. The
+                // snapshot carries every property edit it had accumulated, and because the resurrect
+                // op gets a fresh (highest) clock, the presence barrier voids every older write to
+                // it: the entity comes back exactly as the snapshot says, on every peer.
+                if (before.kind !== 'entity')
+                    return undefined; // nothing to restore it from
+                return Object.assign(Object.assign({}, stub), { op: 'add', target: op.target, id: op.id, data: before.data });
+            }
+            case 'set': {
+                // The newest surviving write BELOW mine is what the register should hold. Falling
+                // back to the captured `before` covers the case the log cannot answer — a peer that
+                // joined from a snapshot has no op for a register nobody has touched since.
+                if (before.kind !== 'value')
+                    return undefined;
+                const value = survivor && survivor.op === 'set' ? (0, op_1.setValueOf)(survivor) : before.value;
+                // `undefined` means THE REGISTER WAS EMPTY, and that is a state to restore, not a
+                // failure to find one. Bail out here and you cannot undo the FIRST label you ever
+                // put on a node — the commonest undo there is — because there was nothing there
+                // before it.
+                //
+                // wave14: restoring emptiness is an EXPLICIT, TYPED CLEAR now. This used to be a
+                // `value: undefined` cast past the OpValue type — it crossed the wire only because
+                // JSON.stringify drops an undefined key and the peer read missing-as-undefined.
+                // The lie Card 4 flagged is retired: a clear says `clear: true` and carries no
+                // value key at all. (A survivor that was itself a clear resolves to undefined via
+                // setValueOf and lands here too.)
+                if (value === undefined) {
+                    return Object.assign(Object.assign({}, stub), { op: 'set', target: op.target, id: op.id, path: op.path, clear: true });
+                }
+                return Object.assign(Object.assign({}, stub), { op: 'set', target: op.target, id: op.id, path: op.path, value });
+            }
+        }
+    }
+    /** The op that re-does `rec`, or undefined if redoing it would clobber newer work. */
+    reapply(rec) {
+        // The undo did nothing (it was already superseded), so the redo does nothing. Anything
+        // else would have Ctrl-Z do nothing and Ctrl-Y assert a stale value over a colleague's
+        // newer one — the exact stale-state resurrection the undo path exists to prevent.
+        if (!rec.undoOp)
+            return undefined;
+        // Someone edited this register AFTER my undo landed. Their write is the current truth;
+        // a redo must not silently overwrite it.
+        const after = this.newestOther(rec.op, rec.undoOp);
+        if (after && (0, op_1.compareOps)(after, rec.undoOp) > 0)
+            return undefined;
+        const stub = { clock: 0, actor: this.actor };
+        const { op } = rec;
+        switch (op.op) {
+            case 'add':
+                return Object.assign(Object.assign({}, stub), { op: 'add', target: op.target, id: op.id, data: op.data });
+            case 'remove':
+                return Object.assign(Object.assign({}, stub), { op: 'remove', target: op.target, id: op.id });
+            case 'set':
+                // Re-issue the op's write as it was — a clear as an explicit clear (this also
+                // renormalises a pre-wave14 record whose value key an old JSON hop dropped).
+                return (0, op_1.setValueOf)(op) === undefined
+                    ? Object.assign(Object.assign({}, stub), { op: 'set', target: op.target, id: op.id, path: op.path, clear: true }) : Object.assign(Object.assign({}, stub), { op: 'set', target: op.target, id: op.id, path: op.path, value: op.value });
+        }
+    }
+    /**
+     * The newest op in the log that writes the same register as `op`, ignoring `op` itself,
+     * anything else currently undone, and (optionally) one more op.
+     *
+     * O(log). That is fine for a keypress and would not be for a drag frame — nothing on a
+     * hot path calls it.
+     */
+    newestOther(op, alsoIgnore) {
+        const reg = registerOf(op);
+        const self = (0, op_1.opId)(op);
+        const skip = alsoIgnore ? (0, op_1.opId)(alsoIgnore) : undefined;
+        let best;
+        for (const candidate of this.log.toArray()) {
+            const id = (0, op_1.opId)(candidate);
+            if (id === self || id === skip)
+                continue;
+            if (this.undone.has(id))
+                continue; // an undone op is not a surviving write
+            if (this.machinery.has(id))
+                continue; // …and neither is my own undo of one
+            if (registerOf(candidate) !== reg)
+                continue;
+            if (!best || (0, op_1.compareOps)(candidate, best) > 0)
+                best = candidate;
+        }
+        return best;
+    }
+    /** The op capture minted for the mutation we just made, if it made one. */
+    lastLogged(sizeBefore) {
+        const ops = this.log.toArray();
+        if (ops.length === sizeBefore)
+            return undefined; // the write was a no-op
+        // The op we just minted has the highest clock we have ever issued, so it sorts last.
+        return ops[ops.length - 1];
+    }
+}
+exports.UndoStack = UndoStack;
+//# sourceMappingURL=undo.js.map

package/src/libs/engine/src/collab/undo.js.map

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

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

@@ -0,0 +1,66 @@
+export interface CommandContext {
+    diagram: any;
+    eventBus: any;
+    store?: any;
+    engine?: any;
+}
+export interface SerializedCommand {
+    id: string;
+    name: string;
+    timestamp: number;
+    data: any;
+}
+export declare abstract class Command {
+    readonly id: string;
+    readonly name: string;
+    readonly timestamp: number;
+    constructor(name: string);
+    /**
+     * Execute the command
+     */
+    abstract execute(context: CommandContext): void | Promise<void>;
+    /**
+     * Undo the command
+     */
+    abstract undo(context: CommandContext): void | Promise<void>;
+    /**
+     * Redo the command (default: re-execute)
+     */
+    redo(context: CommandContext): void | Promise<void>;
+    /**
+     * Check if command can be executed
+     */
+    canExecute(context: CommandContext): boolean;
+    /**
+     * Check if command can be undone
+     */
+    canUndo(context: CommandContext): boolean;
+    /**
+     * Does this command belong on the undo stack AT ALL?
+     *
+     * `canUndo(context)` is a state probe ("can I undo RIGHT NOW?") consulted at
+     * undo time — many commands answer it from live diagram state. This is the
+     * static declaration consulted at EXECUTE time: a non-mutating command
+     * (Copy) answers false and never enters history. Recording one used to
+     * poison the stack — undo() hit the entry, threw "Cannot undo command:
+     * Copy", never decremented the index, and everything behind it became
+     * permanently unreachable.
+     */
+    isUndoable(): boolean;
+    /**
+     * Check if can merge with another command
+     */
+    canMergeWith(other: Command): boolean;
+    /**
+     * Merge with another command
+     */
+    mergeWith(other: Command): Command;
+    /**
+     * Serialize command
+     */
+    abstract serialize(): SerializedCommand;
+    /**
+     * Get description for UI
+     */
+    getDescription(): string;
+}

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

@@ -0,0 +1,64 @@
+"use strict";
+// Command interface for undo/redo system
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Command = void 0;
+const utils_1 = require("../utils");
+class Command {
+    constructor(name) {
+        this.id = (0, utils_1.generateId)();
+        this.name = name;
+        this.timestamp = Date.now();
+    }
+    /**
+     * Redo the command (default: re-execute)
+     */
+    redo(context) {
+        return this.execute(context);
+    }
+    /**
+     * Check if command can be executed
+     */
+    canExecute(context) {
+        return true;
+    }
+    /**
+     * Check if command can be undone
+     */
+    canUndo(context) {
+        return true;
+    }
+    /**
+     * Does this command belong on the undo stack AT ALL?
+     *
+     * `canUndo(context)` is a state probe ("can I undo RIGHT NOW?") consulted at
+     * undo time — many commands answer it from live diagram state. This is the
+     * static declaration consulted at EXECUTE time: a non-mutating command
+     * (Copy) answers false and never enters history. Recording one used to
+     * poison the stack — undo() hit the entry, threw "Cannot undo command:
+     * Copy", never decremented the index, and everything behind it became
+     * permanently unreachable.
+     */
+    isUndoable() {
+        return true;
+    }
+    /**
+     * Check if can merge with another command
+     */
+    canMergeWith(other) {
+        return false;
+    }
+    /**
+     * Merge with another command
+     */
+    mergeWith(other) {
+        throw new Error('Merge not supported');
+    }
+    /**
+     * Get description for UI
+     */
+    getDescription() {
+        return this.name;
+    }
+}
+exports.Command = Command;
+//# sourceMappingURL=Command.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Command.js","sourceRoot":"","sources":["../../../../../../engine/src/commands/Command.ts"],"names":[],"mappings":";AAAA,yCAAyC;;;AAEzC,oCAAsC;AAiBtC,MAAsB,OAAO;IAK3B,YAAY,IAAY;QACtB,IAAI,CAAC,EAAE,GAAG,IAAA,kBAAU,GAAE,CAAC;QACvB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAC9B,CAAC;IAYD;;OAEG;IACH,IAAI,CAAC,OAAuB;QAC1B,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IAC/B,CAAC;IAED;;OAEG;IACH,UAAU,CAAC,OAAuB;QAChC,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACH,OAAO,CAAC,OAAuB;QAC7B,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;;;;OAUG;IACH,UAAU;QACR,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACH,YAAY,CAAC,KAAc;QACzB,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;OAEG;IACH,SAAS,CAAC,KAAc;QACtB,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;IACzC,CAAC;IAOD;;OAEG;IACH,cAAc;QACZ,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;CACF;AAlFD,0BAkFC"}