@grafloria/element 0.3.19 → 0.3.21

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

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

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

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

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

@@ -1 +0,0 @@
-{"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"}