@voithos-labs/aragonite 0.10.1

package/dist/tree-operations/unshare.js

@@ -0,0 +1,248 @@
+import { assertInvariant } from '../assert';
+import { checkCloneSafeMetadata } from '../invariants/node-shape';
+import { rebuildContainerRawIfContainer } from '../schema/container-raw';
+import { dropChildSpans } from '../schema/child-spans';
+import { getBlockKindDescriptor } from '../schema/block-kind-descriptor';
+import { trimTrailingLineEnding } from '../core/lines';
+import { perfEnabled, recordRebuildDepth } from '../perf/instruments';
+import { cloneMetadata } from './clone';
+import { absorbWindowSeams, lineOpensAs, reclassifyContainer } from './node-ops';
+import { settleSublistSeparator } from './list/sublist-separator';
+function copyNode(node, sharing) {
+    const copy = { ...node };
+    if (node.children)
+        copy.children = [...node.children];
+    if (node.childIds)
+        copy.childIds = [...node.childIds];
+    // A splice writes spans in place, so sharing the array would rewrite the snapshot's own.
+    if (node.childSpans)
+        copy.childSpans = node.childSpans.slice();
+    if (node.metadata) {
+        assertInvariant('clone-safe-metadata', () => checkCloneSafeMetadata(node));
+        copy.metadata = cloneMetadata(node.metadata);
+    }
+    sharing.stamp(copy);
+    return copy;
+}
+/**
+ * The copy-on-write spine walk, returning the owned chain outermost-first.
+ * `assertInRange` fires G1.22 for the strict `ensureUnsharedPath` caller and stays
+ * silent for tolerant rebuild passes, which legitimately hand short paths; the walk
+ * stops at the first gap either way.
+ */
+function walkUnsharing(root, path, sharing, assertInRange) {
+    const chain = [];
+    // Root is the live document or a ceremony-owned array — writable by contract (file header).
+    let parentChildren = root.children;
+    for (const index of path) {
+        let node = parentChildren[index];
+        if (assertInRange) {
+            assertInvariant('unshare-path-in-range', () => node ? null : { code: 'unshare-path', message: `path index ${index} out of range` });
+        }
+        if (!node)
+            break;
+        if (sharing.isShared(node)) {
+            parentChildren[index] = copyNode(node, sharing);
+            // Write-then-re-read (file header).
+            node = parentChildren[index];
+        }
+        chain.push(node);
+        parentChildren = node.children ?? [];
+    }
+    return chain;
+}
+/**
+ * Unshare every node along `path` from `root`; returns the chain outermost-first.
+ * The caller owns `root.children` (live document, or a commit ceremony's array copy),
+ * which is what makes the splice safe.
+ */
+export function ensureUnsharedPath(root, path, sharing) {
+    return walkUnsharing(root, path, sharing, true);
+}
+/**
+ * Unshare one direct child of an already-unshared parent — a node, or a
+ * caller-owned `{ children }` view (e.g. a commit ceremony's array copy).
+ */
+export function ensureUnsharedChild(parent, index, sharing) {
+    const child = parent.children[index];
+    // G1.22 — an index off the end is a caller bug; fail here rather than
+    // epoch-dependently inside `isShared`.
+    assertInvariant('unshare-path-in-range', () => child ? null : { code: 'unshare-path', message: `child index ${index} out of range` });
+    if (!child || !sharing.isShared(child))
+        return child;
+    parent.children[index] = copyNode(child, sharing);
+    // Write-then-re-read (file header).
+    return parent.children[index];
+}
+/**
+ * Standalone copy for a node being MOVED out of a parent the snapshot keeps: the caller
+ * attaches the returned copy, the original stays in the old parent untouched. An
+ * unshared input passes through — unshared already means live-tree-owned.
+ */
+export function ensureUnsharedNode(node, sharing) {
+    return sharing.isShared(node) ? copyNode(node, sharing) : node;
+}
+/** Unshare every direct child of an owned parent (e.g. table rows before a whole-table rebuild). */
+export function ensureUnsharedChildren(parent, sharing) {
+    const count = parent.children?.length ?? 0;
+    for (let i = 0; i < count; i++)
+        ensureUnsharedChild(parent, i, sharing);
+}
+/**
+ * Deep-unshare an owned node's subtree. Intended for small bounded subtrees
+ * (tables: rows + cells) ahead of ops that write at arbitrary depth.
+ */
+export function ensureUnsharedSubtree(node, sharing) {
+    const count = node.children?.length ?? 0;
+    for (let i = 0; i < count; i++) {
+        ensureUnsharedSubtree(ensureUnsharedChild(node, i, sharing), sharing);
+    }
+}
+// ── Sharing-aware raw rebuilds ───────────────────────────────────────────────
+/**
+ * Rebuild one owned container's raw. A grid rebuild rewrites its children's raw, so a
+ * grid's children are unshared first — keyed off `containerContract`, not a `table` kind
+ * test, or a plugin grid writes through shared children.
+ */
+export function rebuildOwnedContainer(node, sharing, changed) {
+    if (getBlockKindDescriptor(node.kind).containerContract === 'grid') {
+        ensureUnsharedChildren(node, sharing);
+    }
+    rebuildContainerRawIfContainer(node, changed);
+}
+/**
+ * Longest prefix of `chain` still attached under `root`, identity-checked level by level.
+ * A commit mutation can splice a node out mid-ceremony; rebuilding the detached node's
+ * raw against its emptied children writes `raw: ''` and trips the commit-time staleness
+ * check. Ancestors above the detachment still need their rebuild — hence prefix.
+ */
+export function attachedChainPrefix(root, chain) {
+    let parentChildren = root.children;
+    for (let i = 0; i < chain.length; i++) {
+        if (!parentChildren.includes(chain[i]))
+            return chain.slice(0, i);
+        parentChildren = chain[i].children ?? [];
+    }
+    return chain;
+}
+/**
+ * Rebuild raws along an owned spine chain innermost-first, re-deriving each container's kind and
+ * settling the seams at its own slot; chain- rather than path-based so it survives index shifts.
+ * Both passes gate on a boundary line of the rebuilt raw moving; the re-derive additionally needs
+ * `lineOpensAs` not to name the current kind, a positive identification so a declining opener
+ * parses rather than eliding a real kind change. `folds` is required-nullable: a fold splices the
+ * PARENT's array, so only a caller that reconciles that scope's ids/refs passes a sink.
+ */
+export function rebuildUnsharedChain(root, chain, sharing, folds, grammar, hint) {
+    const reclassified = [];
+    // The bytes chain[i + 1] held before this pass, which is what its own level captures on the
+    // way past. It rides up only from a door that named the leaf's own: a caller passing no hint
+    // re-derives at every level, which is what makes the structural paths a reseed (editor.md § 9).
+    let childPreviousRaw;
+    for (let i = chain.length - 1; i >= 0; i--) {
+        const node = chain[i];
+        const rawBefore = node.raw;
+        const child = chain[i + 1];
+        rebuildOwnedContainer(node, sharing, child && childPreviousRaw !== undefined
+            ? childRawChange(node, child, childPreviousRaw, hint?.path[i + 1])
+            : undefined);
+        if (hint)
+            childPreviousRaw = i === chain.length - 1 ? hint.leafPreviousRaw : rawBefore;
+        const openerMoved = firstLine(rawBefore) !== firstLine(node.raw);
+        const closerMoved = lastLine(rawBefore) !== lastLine(node.raw);
+        if (!openerMoved && !closerMoved)
+            continue;
+        const owner = i === 0 ? null : chain[i - 1];
+        const siblings = (owner ?? root).children;
+        const index = siblings ? childIndexOf(siblings, node, hint?.path[i]) : -1;
+        if (!siblings || index < 0)
+            continue;
+        if (openerMoved && lineOpensAs(firstLine(node.raw), grammar) !== node.kind) {
+            const replacement = reclassifyContainer({ children: siblings }, index, grammar);
+            if (replacement) {
+                sharing.stamp(replacement);
+                reclassified.push({ siblings, index, previous: node, replacement });
+            }
+        }
+        // Ahead of the seam ask, which then reads the settled bytes: a list rebuilt down to an
+        // empty marker owes the paragraph above it a separating line.
+        if (openerMoved)
+            settleSublistSeparator(siblings, index);
+        // After the re-derive: the seam reads whatever occupies the slot now.
+        if (folds) {
+            const before = folds.length;
+            settleSlotSeams({ siblings, owner, depth: i, index, openerMoved, closerMoved }, sharing, folds);
+            // A fold re-tiled the owner's children, so its spans describe a shape that is gone.
+            if (folds.length > before && owner)
+                dropChildSpans(owner);
+        }
+    }
+    if (perfEnabled())
+        recordRebuildDepth(chain.length);
+    return reclassified;
+}
+/**
+ * The changed-child hint for `node`, or undefined when `child` cannot be placed in it. The
+ * path index is a guess: an identity match is what makes it an answer, and a splice since the
+ * unshare falls back to the scan.
+ */
+function childRawChange(node, child, previousRaw, guess) {
+    const siblings = node.children;
+    if (!siblings)
+        return undefined;
+    const index = childIndexOf(siblings, child, guess);
+    return index < 0 ? undefined : { index, previousRaw };
+}
+/** `indexOf` with a guess first: the scan is O(children) through the `$state` proxy. */
+function childIndexOf(siblings, child, guess) {
+    if (guess !== undefined && siblings[guess] === child)
+        return guess;
+    return siblings.indexOf(child);
+}
+/**
+ * Ask the joins at a rebuilt container's slot, since its new bytes can stop interrupting a
+ * neighbour, which the reload then reads as one block with it. Byte-identical by construction,
+ * like every other seam absorb. `absorbWindowSeams` walks `at - 1 … at + added - 1`, so the two
+ * arguments below name exactly the sides whose line moved.
+ */
+function settleSlotSeams(slot, sharing, folds) {
+    const { siblings, index, openerMoved, closerMoved } = slot;
+    // The rollback snapshot is captured only once a fold is certain: an eager copy here cost
+    // O(children) reactive reads on every keystroke inside a large container.
+    let before = null;
+    const landing = { index, offset: 0 };
+    const settled = absorbWindowSeams({ children: siblings }, openerMoved ? index : index + 1, openerMoved && closerMoved ? 1 : 0, index, { op: 'noop' }, sharing, landing, index, () => {
+        before ??= siblings.slice();
+    });
+    if (settled.change.op === 'noop')
+        return;
+    folds.push({
+        depth: slot.depth,
+        siblings,
+        owner: slot.owner,
+        change: settled.change,
+        // A non-noop change means a splice ran, so the capture ran first.
+        before: before,
+        landing
+    });
+}
+/** The container's opener line. */
+function firstLine(raw) {
+    const nl = raw.indexOf('\n');
+    return nl < 0 ? raw : raw.slice(0, nl);
+}
+/** The container's closing line: its last line carrying bytes, without the ending. */
+function lastLine(raw) {
+    const body = trimTrailingLineEnding(raw);
+    const nl = body.lastIndexOf('\n');
+    return nl < 0 ? body : body.slice(nl + 1);
+}
+/**
+ * Unshare the spine to `path` and rebuild it innermost-first, tolerating paths that ran
+ * out of range mid-walk (post-delete rebuild passes). Prefer `rebuildUnsharedChain` when
+ * indices may have shifted since the unshare.
+ */
+export function rebuildUnsharedAncestry(root, path, sharing, folds, grammar) {
+    const chain = walkUnsharing(root, path, sharing, false);
+    return rebuildUnsharedChain(root, chain, sharing, folds, grammar);
+}

package/dist/undo/manager.d.ts

@@ -0,0 +1,2 @@
+import type { UndoManager } from './types';
+export declare function createUndoManager(): UndoManager;

package/dist/undo/manager.js

@@ -0,0 +1,50 @@
+const MAX_UNDO = 200;
+export function createUndoManager() {
+    const undoStack = [];
+    const redoStack = [];
+    return {
+        push(entry) {
+            // Stored as-is: the caller builds entries safe to hold.
+            undoStack.push(entry);
+            if (undoStack.length > MAX_UNDO)
+                undoStack.shift();
+            redoStack.length = 0;
+        },
+        peekUndo() {
+            return undoStack[undoStack.length - 1] ?? null;
+        },
+        undo(currentState) {
+            const entry = undoStack.pop();
+            if (!entry)
+                return null;
+            redoStack.push(currentState);
+            return entry;
+        },
+        redo(currentState) {
+            const entry = redoStack.pop();
+            if (!entry)
+                return null;
+            undoStack.push(currentState);
+            return entry;
+        },
+        clear() {
+            undoStack.length = 0;
+            redoStack.length = 0;
+        },
+        getStacks() {
+            return { undo: [...undoStack], redo: [...redoStack] };
+        },
+        restoreStacks(stacks) {
+            undoStack.length = 0;
+            undoStack.push(...stacks.undo);
+            redoStack.length = 0;
+            redoStack.push(...stacks.redo);
+        },
+        get canUndo() {
+            return undoStack.length > 0;
+        },
+        get canRedo() {
+            return redoStack.length > 0;
+        }
+    };
+}

package/dist/undo/types.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Undo/redo state model: the snapshot entry a manager stores and the
+ * manager interface the editor controller talks to.
+ */
+import type { Document } from '../core/nodes';
+import type { GapCaretPosition } from '../selection/gap-caret';
+import type { EditorSelection } from '../selection/primitives';
+/**
+ * A gap caret at push. Its own type, never a member of `EditorSelection`: the gap is
+ * collapsed-only and can never be a cross-block endpoint.
+ */
+export interface GapCaretSelection {
+    gapCaret: GapCaretPosition;
+}
+export declare function isGapSelection(selection: EditorSelection | GapCaretSelection): selection is GapCaretSelection;
+export interface UndoEntry {
+    snapshot: Document;
+    blockIds: string[];
+    /** Effective selection at push. See docs/design/editor.md § Undo / redo. */
+    selection: EditorSelection | GapCaretSelection;
+    /** DEV-only digest of `snapshot` at push; restore verifies no mutation wrote through a shared node. */
+    integrity?: number;
+}
+export interface UndoManager {
+    push(entry: UndoEntry): void;
+    /** Top undo entry without the per-call stack copies of getStacks. */
+    peekUndo(): UndoEntry | null;
+    undo(currentState: UndoEntry): UndoEntry | null;
+    redo(currentState: UndoEntry): UndoEntry | null;
+    clear(): void;
+    /** Snapshots of both stacks for inspection. */
+    getStacks(): {
+        undo: UndoEntry[];
+        redo: UndoEntry[];
+    };
+    /** Restore both stacks from a `getStacks()` snapshot. Wholesale, not a pop, because
+     *  `push` may have evicted the oldest entry at MAX_UNDO. */
+    restoreStacks(stacks: {
+        undo: UndoEntry[];
+        redo: UndoEntry[];
+    }): void;
+    readonly canUndo: boolean;
+    readonly canRedo: boolean;
+}

package/dist/undo/types.js

@@ -0,0 +1,7 @@
+/**
+ * Undo/redo state model: the snapshot entry a manager stores and the
+ * manager interface the editor controller talks to.
+ */
+export function isGapSelection(selection) {
+    return 'gapCaret' in selection;
+}