@voithos-labs/aragonite 0.10.2 → 0.10.3

package/dist/tree-operations/table-grid-clipboard.js

@@ -0,0 +1,90 @@
+/**
+ * The grid a clipboard payload holds, for a spreadsheet-like paste into a table: tab-separated
+ * rows (what Excel and Sheets write to text/plain) or a GFM table (what this editor's own
+ * rectangle copy writes). Anything else is not a grid and takes the ordinary paste route. The
+ * inverse, an HTML table for the spreadsheets that read text/html, lives here too.
+ */
+/** Rows of cell texts, rectangular: every row padded to the widest. Null for a non-grid payload. */
+export function parseClipboardGrid(text) {
+    const lines = text.replace(/\r\n?/g, '\n').split('\n');
+    while (lines.length && lines[lines.length - 1].trim() === '')
+        lines.pop();
+    if (lines.length === 0)
+        return null;
+    const rows = parseGfmRows(lines) ?? parseTsvRows(lines);
+    if (!rows || rows.length === 0)
+        return null;
+    let width = 0;
+    for (const row of rows)
+        width = Math.max(width, row.length);
+    if (width < 2 && rows.length < 2)
+        return null;
+    return rows.map((row) => [...row, ...Array(width - row.length).fill('')]);
+}
+// Every line a pipe row; the delimiter line (second, all dashes and colons) is dropped.
+function parseGfmRows(lines) {
+    if (!lines.every((line) => /^\s*\|.*\|\s*$/.test(line)))
+        return null;
+    const rows = lines.map(splitPipeRow);
+    if (rows.length >= 2 && rows[1].every((cell) => /^:?-+:?$/.test(cell)))
+        rows.splice(1, 1);
+    return rows;
+}
+function splitPipeRow(line) {
+    const inner = line.trim().slice(1, -1);
+    const cells = [];
+    let cell = '';
+    for (let i = 0; i < inner.length; i++) {
+        const ch = inner[i];
+        if (ch === '\\' && inner[i + 1] === '|') {
+            cell += '|';
+            i++;
+        }
+        else if (ch === '|') {
+            cells.push(cell.trim());
+            cell = '';
+        }
+        else
+            cell += ch;
+    }
+    cells.push(cell.trim());
+    return cells;
+}
+function parseTsvRows(lines) {
+    if (!lines.some((line) => line.includes('\t')))
+        return null;
+    return lines.map((line) => line.split('\t'));
+}
+/** A rectangle's cell texts, pipes unescaped, as the clipboard's grid. */
+export function rectangleGrid(table, a, b) {
+    const rows = table.children ?? [];
+    const grid = [];
+    for (let r = Math.min(a.rowIdx, b.rowIdx); r <= Math.max(a.rowIdx, b.rowIdx); r++) {
+        const cells = rows[r]?.children ?? [];
+        const line = [];
+        for (let c = Math.min(a.colIdx, b.colIdx); c <= Math.max(a.colIdx, b.colIdx); c++) {
+            line.push((cells[c]?.raw ?? '').replace(/\\\|/g, '|'));
+        }
+        grid.push(line);
+    }
+    return grid;
+}
+/** The grid repeated to fill a selection whose sides are multiples of it (a spreadsheet's
+ *  tiling); any other selection takes the grid once from its top-left corner. */
+export function tileGridTo(grid, rows, cols) {
+    const height = grid.length;
+    const width = grid[0]?.length ?? 0;
+    if (height === 0 || width === 0)
+        return grid;
+    if (rows % height !== 0 || cols % width !== 0 || (rows === height && cols === width)) {
+        return grid;
+    }
+    return Array.from({ length: rows }, (_, r) => Array.from({ length: cols }, (_, c) => grid[r % height][c % width]));
+}
+export function gridToHtmlTable(grid) {
+    const escape = (text) => text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+    const rows = grid
+        .map((row) => `<tr>${row.map((cell) => `<td>${escape(cell)}</td>`).join('')}</tr>`)
+        .join('');
+    return `<table>${rows}</table>`;
+}

package/dist/tree-operations/unshare.d.ts

@@ -8,94 +8,32 @@
 import type { CstNode } from '../core/nodes';
 import type { NodeParentView, NodeView } from '../core/node-views';
 import type { SharingState } from './sharing';
-import type { NodeParent, TrackedPosition } from './node-ops';
-import type { StructuralChange } from './structural-change';
-import { type ChildRawChange } from '../schema/child-spans';
-import type { GrammarView } from '../schema/block-openers';
+import type { NodeParent } from './node-primitives';
+import type { ChildRawChange } from '../schema/child-spans';
 /**
- * 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.
+ * 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.
  */
-export declare function ensureUnsharedPath(root: NodeParentView, path: number[], sharing: SharingState): CstNode[];
+export declare function walkUnsharing(root: NodeParentView, path: number[], sharing: SharingState, assertInRange: boolean): CstNode[];
 /**
- * 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).
+ * 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).
  */
+export declare function ensureUnsharedPath(root: NodeParentView, path: number[], sharing: SharingState): CstNode[];
+/** Unshare one direct child of an already-unshared parent, or of a caller-owned `{ children }`. */
 export declare function ensureUnsharedChild(parent: CstNode | NodeParent, index: number, sharing: SharingState): CstNode;
 /**
- * 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.
+ * Standalone copy for a node being MOVED out of a parent the snapshot keeps: the caller attaches
+ * the copy, the original stays put. An unshared input passes through as live-tree-owned.
  */
 export declare function ensureUnsharedNode(node: NodeView, sharing: SharingState): CstNode;
 /** Unshare every direct child of an owned parent (e.g. table rows before a whole-table rebuild). */
 export declare function ensureUnsharedChildren(parent: CstNode, sharing: SharingState): void;
-/**
- * Deep-unshare an owned node's subtree. Intended for small bounded subtrees
- * (tables: rows + cells) ahead of ops that write at arbitrary depth.
- */
+/** Deep-unshare an owned node's subtree, for small bounded subtrees written at arbitrary depth. */
 export declare function ensureUnsharedSubtree(node: CstNode, sharing: SharingState): void;
 /**
- * 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.
+ * 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` rather than a `table` kind test.
  */
 export declare function rebuildOwnedContainer(node: CstNode, sharing: SharingState, changed?: ChildRawChange): void;
-/**
- * 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 declare function attachedChainPrefix(root: NodeParent, chain: CstNode[]): CstNode[];
-/**
- * One container slot a rebuild re-kinded. `previous` is the rollback register: a commit
- * unwinding after the swap has already published `replacement` into a live children
- * array, which no other rollback register reaches.
- */
-export interface ContainerReclassification {
-    siblings: CstNode[];
-    index: number;
-    previous: CstNode;
-    replacement: CstNode;
-}
-/**
- * A fold the rebuilt container's own slot owed: its bytes stopped interrupting a neighbour, so
- * the parent's array reloads as fewer blocks and no scope-local settle reaches that join
- * `before` is the pre-splice array — the rollback register, since the splice lands in
- * an array no commit descriptor covers. `landing` is where the container's first byte ended up.
- */
-export interface AncestrySeamFold {
-    /** Chain level of the folded container, so a caller composes the owner's path from its own. */
-    depth: number;
-    siblings: CstNode[];
-    /** The chain node owning `siblings`, or null when they are the rebuild root's children. */
-    owner: CstNode | null;
-    change: StructuralChange;
-    before: CstNode[];
-    landing: TrackedPosition;
-}
-/**
- * What the typing door knows and a bare chain does not: where the chain sits in the document,
- * and the bytes its leaf carried before the write. Both are guesses the rebuild identity-checks.
- */
-export interface ChainWriteHint {
-    path: number[];
-    leafPreviousRaw: string;
-}
-/**
- * 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 declare function rebuildUnsharedChain(root: NodeParent | CstNode, chain: CstNode[], sharing: SharingState, folds: AncestrySeamFold[] | null, grammar: GrammarView | undefined, hint?: ChainWriteHint): ContainerReclassification[];
-/**
- * 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 declare function rebuildUnsharedAncestry(root: NodeParent, path: number[], sharing: SharingState, folds: AncestrySeamFold[] | null, grammar: GrammarView | undefined): ContainerReclassification[];

package/dist/tree-operations/unshare.js

@@ -1,13 +1,8 @@
 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)
@@ -25,12 +20,11 @@ function copyNode(node, sharing) {
     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.
+ * 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) {
+export 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;
@@ -52,21 +46,17 @@ function walkUnsharing(root, path, sharing, assertInRange) {
     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.
+ * 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).
  */
 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).
- */
+/** Unshare one direct child of an already-unshared parent, or of a caller-owned `{ children }`. */
 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`.
+    // G1.22: an index off the end is a caller bug, failed 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;
@@ -75,9 +65,8 @@ export function ensureUnsharedChild(parent, index, sharing) {
     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.
+ * Standalone copy for a node being MOVED out of a parent the snapshot keeps: the caller attaches
+ * the copy, the original stays put. An unshared input passes through as live-tree-owned.
  */
 export function ensureUnsharedNode(node, sharing) {
     return sharing.isShared(node) ? copyNode(node, sharing) : node;
@@ -88,21 +77,17 @@ export function ensureUnsharedChildren(parent, sharing) {
     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.
- */
+/** Deep-unshare an owned node's subtree, for small bounded subtrees written 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 ───────────────────────────────────────────────
+// ── Sharing-aware raw rebuild ───────────────────────────────────────────────
 /**
- * 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.
+ * 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` rather than a `table` kind test.
  */
 export function rebuildOwnedContainer(node, sharing, changed) {
     if (getBlockKindDescriptor(node.kind).containerContract === 'grid') {
@@ -110,139 +95,3 @@ export function rebuildOwnedContainer(node, sharing, changed) {
     }
     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);
-}