@voithos-labs/aragonite 0.10.3 → 0.10.7

package/dist/selection/range-delete-chrome.js

@@ -1,21 +1,18 @@
 /**
- * Reserved-chrome branch of rangeDelete, the wall rule: nothing merges across a
- * `reservedChrome` container's wall. Outside endpoints truncate in place, covered chrome clears
- * (never node-deletes, G1.14), covered body children delete, and the container dies only when
- * the range consumes its whole subtree, then as ONE splice with children intact.
+ * The `rangeDelete` branch where nothing merges: an endpoint in a container with a title row (a
+ * details block's summary line) the range crosses, or an edge the range holds whole. Each kept edge
+ * is truncated in place. A covered title line is cleared, not deleted, so the title leaf stays at
+ * child 0 (G1.14).
  */
-import { displayLength } from '../core/lines';
+import { isChromeChild, nearestChromeContainer } from './range-coverage';
 import { comparePaths, pathsEqual } from './path-math';
-import { resolveEndWall, planCrossBlockDeletion, applyPlannedDeletion, truncateEndInPlace, truncateStartInPlace } from './range-delete-ceremony';
+import { planCrossBlockDeletion, applyPlannedDeletion, rebuildSharedAncestries, truncateEndInPlace, truncateStartInPlace } from './range-delete-ceremony';
 import { ensureUnsharedPath } from '../tree-operations/unshare';
 import { rebuildUnsharedChain } from '../tree-operations/chain-rebuild';
-import { reservedChromeKindOf, isReservedChromeChild } from '../schema/reserved-chrome';
+import { caretPointFor, survivorAfterRemoval, survivorWhereRangeResumes } from './caret-target';
 // ── Public API ──────────────────────────────────────────────────────────────
-/**
- * True when the range must take the wall path: an endpoint sits inside a `reservedChrome`
- * container the range crosses out of or into, or the range starts in the chrome leaf itself.
- * Same-block, body-only, and enclose-from-outside ranges stay on the generic path.
- */
+/** Whether an endpoint sits inside a title-line container the range crosses into or out of, or
+ *  the range starts on the title line itself. */
 export function involvesReservedChrome(doc, start, end) {
     if (comparePaths(start.path, end.path) === 0)
         return false;
@@ -28,79 +25,57 @@ export function involvesReservedChrome(doc, start, end) {
     }
     return true;
 }
-/**
- * Delete [start, end] under the wall rule. Both endpoints truncate in place (chrome by a raw
- * write, keeping the kind via contextDependentKind; prose by a reparse of the surviving slice),
- * and nothing merges across the wall. Collapsed caret keeps generic start-position semantics.
- */
-export function chromeAwareRangeDelete(doc, start, end, sharing, grammar, presentationMode, linkRef) {
-    const startC = nearestChromeContainer(doc, start.path);
-    const endC = nearestChromeContainer(doc, end.path);
-    const live = { presentationMode, linkRef };
-    // Own every written spine BEFORE identities are captured (G1.9): chains stay valid across
-    // splices, paths don't.
-    const startChain = ensureUnsharedPath(doc, start.path, sharing);
-    const endChain = ensureUnsharedPath(doc, end.path, sharing);
-    // Shared deletion plan (range-delete-ceremony.ts). Chrome marks no endpoint paths for
-    // deletion: both endpoints truncate in place below. resolveEndWall returns null when start
-    // sits inside the end container, which needs no chrome-clear either way, since that
-    // container's chrome child 0 never lands in the strictly-between walk.
-    const wall = resolveEndWall(doc, start, end, null);
-    const endConsumed = wall?.consumed ?? false;
-    const { plan, lcaPath } = planCrossBlockDeletion(doc, start, end, [], wall, sharing);
-    // End truncates in place first (its path is still live), the wall: its tail never merges
-    // into start. Skipped when its container dies whole.
-    if (!endConsumed) {
-        truncateEndInPlace(doc, end, endChain[endChain.length - 1], endC !== null && isChromeChild(endC, end.path), live, sharing, 'chromeAwareRangeDelete:end');
+/** Deletes what the range covers with no merge: removes what it holds whole and truncates each kept
+ *  edge in place. `gesture` lands the caret when the range keeps neither edge. */
+export function unjoinedRangeDelete(doc, coverage, sharing, reading, gesture) {
+    const { grammar } = reading;
+    const { start, end } = coverage.range;
+    const { startEdge, endEdge } = coverage;
+    // Copy every chain that will be written before node identities are captured: chains stay
+    // valid across splices, paths do not (G1.9).
+    const startChain = startEdge ? ensureUnsharedPath(doc, start.path, sharing) : null;
+    const endChain = endEdge ? ensureUnsharedPath(doc, end.path, sharing) : null;
+    const plan = planCrossBlockDeletion(doc, coverage, [], sharing);
+    // The end truncates first, while its path is still valid.
+    if (endChain) {
+        const endC = nearestChromeContainer(doc, end.path);
+        truncateEndInPlace(doc, end, endChain[endChain.length - 1], endC !== null && isChromeChild(endC, end.path), reading, sharing, 'unjoinedRangeDelete:end');
     }
-    applyPlannedDeletion(doc, plan, lcaPath);
-    // Start truncates in place; every deletion sits after it in doc order, so start.path is
-    // still live.
-    const seam = truncateStartInPlace(doc, start, startChain[startChain.length - 1], startC !== null && isChromeChild(startC, start.path), live, sharing, 'chromeAwareRangeDelete:start');
+    applyPlannedDeletion(doc, plan, grammar);
+    // Every deletion sits after the start in document order, so its path is still live.
+    const startC = nearestChromeContainer(doc, start.path);
+    const seam = startChain
+        ? truncateStartInPlace(doc, start, startChain[startChain.length - 1], startC !== null && isChromeChild(startC, start.path), reading, sharing, 'unjoinedRangeDelete:start')
+        : null;
     // Chain-based rebuilds: node references survive the splices above where paths may not, and
     // every touched container re-emits raw (G1.12).
-    rebuildUnsharedChain(doc, startChain, sharing, null, grammar);
-    rebuildUnsharedChain(doc, endChain, sharing, null, grammar);
+    if (startChain)
+        rebuildUnsharedChain(doc, startChain, sharing, null, grammar);
+    if (endChain)
+        rebuildUnsharedChain(doc, endChain, sharing, null, grammar);
+    rebuildSharedAncestries(doc, plan, sharing, grammar);
+    if (seam !== null) {
+        const joinAt = { path: start.path.slice(), offset: seam };
+        return { newDoc: doc, caret: () => joinAt };
+    }
+    const first = coverage.wholeRoots[0];
     return {
         newDoc: doc,
-        collapsedCaret: { path: start.path.slice(), offset: seam }
+        caret: endEdge
+            ? (committed) => caretWhereRangeResumes(committed, coverage.rootHolding(start.path) ?? first)
+            : (committed) => caretWhereRemoved(committed, first, gesture)
     };
 }
-/** Deepest strict ancestor of `path` whose kind declares reservedChrome. */
-export function nearestChromeContainer(doc, path) {
-    let found = null;
-    let children = doc.children;
-    for (let i = 0; i < path.length - 1; i++) {
-        const node = children[path[i]];
-        if (!node)
-            break;
-        if (reservedChromeKindOf(node.kind) !== undefined) {
-            found = { path: path.slice(0, i + 1), node };
-        }
-        children = node.children ?? [];
-    }
-    return found;
-}
-export function isChromeChild(container, leafPath) {
-    return (leafPath.length === container.path.length + 1 &&
-        isReservedChromeChild(container.node, leafPath[container.path.length]));
+/** The caret once the block at `path` went, on the side `gesture` points; read on the committed
+ *  tree, which holds the block the commit gives an emptied document. */
+export function caretWhereRemoved(committed, path, gesture) {
+    return caretAt(committed, survivorAfterRemoval(committed, path, gesture));
 }
-/**
- * The range's end lands on the container's last byte: every step from the container is a
- * last-child edge and the offset consumes the block's visible text.
- */
-export function rangeConsumesContainer(container, end) {
-    const endNode = lastChildDescendant(container, end.path);
-    return endNode !== null && end.offset >= displayLength(endNode.raw);
+/** The caret once a range took the block at `path` whole and ran on: where what's left of the
+ *  range's end begins, read on the committed tree. */
+export function caretWhereRangeResumes(committed, path) {
+    return caretAt(committed, survivorWhereRangeResumes(committed, path));
 }
-/** The node at `path` when every step from the container is a last-child edge, else null. */
-export function lastChildDescendant(container, path) {
-    let node = container.node;
-    for (let i = container.path.length; i < path.length; i++) {
-        const children = node.children ?? [];
-        if (path[i] !== children.length - 1)
-            return null;
-        node = children[path[i]];
-    }
-    return node;
+function caretAt(committed, survivor) {
+    return survivor && caretPointFor(committed, survivor);
 }

package/dist/selection/range-delete-table-coverage.d.ts

@@ -1,28 +1,14 @@
 /**
- * Intra-table coverage-driven delete: a full-table/row/column selection lands inside one table
- * block, so it routes to a structural delete of that table/row/column rather than the
- * cross-block range delete. Subset (cell) coverage returns null for the caller's cell-clear.
+ * Deletes the whole row or column a pair inside one table holds, at the table's own path, as
+ * Ctrl+Shift+Backspace and Alt+Shift+Backspace do. The coverage itself is read by `rangeCoverage`.
  */
 import { type SelectionPoint } from './primitives';
-import type { CstNode } from '../core/nodes';
-import type { CrossBlockDeleteOptions, CrossBlockMutationContext } from './cross-block/ops';
-/**
- * Coverage of an intra-table cell-index range, driving the Backspace dispatch: a full
- * table/row/column deletes structurally, anything else clears cells.
- */
-export type TableCoverage = {
-    kind: 'table';
-} | {
-    kind: 'row';
-    rowIdx: number;
-} | {
-    kind: 'column';
-    colIdx: number;
-} | {
-    kind: 'cells';
-};
-export declare function classifyTableSelectionCoverage(startCellIdx: number, endCellIdx: number, columnCount: number, rowCount: number): TableCoverage;
-/** Null when the selection doesn't qualify (subset coverage, or a guard refusal). */
-export declare function maybeCommitTableCoverageDelete(ctx: CrossBlockMutationContext, table: CstNode, start: SelectionPoint, end: SelectionPoint, options: Pick<CrossBlockDeleteOptions, 'undoEntry'> | undefined, caretRestore: ((caret: SelectionPoint | null) => void) | undefined): Promise<{
-    caret: SelectionPoint | null;
-} | null>;
+import type { GridCoverage } from './range-coverage';
+import type { CrossBlockMutationContext } from './cross-block/ops';
+/** A pair inside one table that holds a whole row or a whole column of it. */
+export type GridLineCoverage = Extract<GridCoverage, {
+    kind: 'row' | 'column';
+}>;
+/** The collapsed caret, or null for a refused delete (no body row or one column left), which
+ *  clears nothing either; `lands` has the commit put the caret there. */
+export declare function commitGridLineDelete(ctx: CrossBlockMutationContext, grid: GridLineCoverage, lands: boolean): Promise<SelectionPoint | null>;

package/dist/selection/range-delete-table-coverage.js

@@ -1,169 +1,99 @@
 /**
- * Intra-table coverage-driven delete: a full-table/row/column selection lands inside one table
- * block, so it routes to a structural delete of that table/row/column rather than the
- * cross-block range delete. Subset (cell) coverage returns null for the caller's cell-clear.
+ * Deletes the whole row or column a pair inside one table holds, at the table's own path, as
+ * Ctrl+Shift+Backspace and Alt+Shift+Backspace do. The coverage itself is read by `rangeCoverage`.
  */
 import { deleteSnapshot } from './primitives';
 import { metadataOf } from '../core/nodes';
-import { emptyParagraph } from '../tree-operations/node-primitives';
-import { deleteNode } from '../tree-operations/settle';
-import { trailingLineEnding } from '../core/lines';
 import { expectStateForNode, getStateForNode } from '../reactivity/state-registry';
 import { deleteRow as mutDeleteRow, deleteColumn as mutDeleteColumn, canDeleteRow, canDeleteColumn } from '../tree-operations/table-mutations';
 import { ensureUnsharedChildren } from '../tree-operations/unshare';
-import { cellRowCol, docPathFrom } from '../cursor/coordinate-spaces';
-export function classifyTableSelectionCoverage(startCellIdx, endCellIdx, columnCount, rowCount) {
-    const lo = Math.min(startCellIdx, endCellIdx);
-    const hi = Math.max(startCellIdx, endCellIdx);
-    const cellCount = columnCount * rowCount;
-    if (lo === 0 && hi === cellCount - 1)
-        return { kind: 'table' };
-    const { row: startRow, col: startCol } = cellRowCol(lo, columnCount);
-    const { row: endRow, col: endCol } = cellRowCol(hi, columnCount);
-    if (startRow === endRow && startCol === 0 && endCol === columnCount - 1) {
-        return { kind: 'row', rowIdx: startRow };
-    }
-    if (startCol === endCol && startRow === 0 && endRow === rowCount - 1) {
-        return { kind: 'column', colIdx: startCol };
-    }
-    return { kind: 'cells' };
-}
-/** Null when the selection doesn't qualify (subset coverage, or a guard refusal). */
-export async function maybeCommitTableCoverageDelete(ctx, table, start, end, options, caretRestore) {
-    const meta = metadataOf(table, 'table');
-    const columnCount = meta.columnCount;
-    const rowCount = table.children?.length ?? 0;
-    // Same-path intra-table endpoints are context-established, not flagged, so they read directly.
-    const coverage = classifyTableSelectionCoverage(start.offset, end.offset, columnCount, rowCount);
-    switch (coverage.kind) {
-        case 'cells':
+import { blockNodeAt } from '../tree-operations/node-primitives';
+import { docPathFrom } from '../cursor/coordinate-spaces';
+/** The collapsed caret, or null for a refused delete (no body row or one column left), which
+ *  clears nothing either; `lands` has the commit put the caret there. */
+export async function commitGridLineDelete(ctx, grid, lands) {
+    const table = blockNodeAt(ctx.getDoc(), grid.path);
+    if (!table?.children)
+        return null;
+    if (grid.kind === 'row') {
+        if (!canDeleteRow(grid.rect.top, table.children.length))
             return null;
-        case 'table':
-            return { caret: await commitFullTableDelete(ctx, start, options, caretRestore) };
-        case 'row': {
-            // Mirror Ctrl+Shift+Backspace: ≥1 body row must remain. Refusal is a silent no-op, since
-            // falling through to a cell-clear would rewrite the user's intent.
-            if (!canDeleteRow(coverage.rowIdx, rowCount))
-                return { caret: null };
-            const caret = await commitRowDelete(ctx, table, start, coverage.rowIdx, options, caretRestore);
-            return { caret };
-        }
-        case 'column': {
-            // Mirror Alt+Shift+Backspace: ≥2 columns must remain.
-            if (!canDeleteColumn(columnCount))
-                return { caret: null };
-            const caret = await commitColumnDelete(ctx, table, start, coverage.colIdx, options, caretRestore);
-            return { caret };
-        }
+        return commitRowDelete(ctx, table, grid.path, grid.rect.top, lands);
     }
+    if (!canDeleteColumn(metadataOf(table, 'table').columnCount))
+        return null;
+    return commitColumnDelete(ctx, table, grid.path, grid.rect.left, lands);
 }
-async function commitFullTableDelete(ctx, start, options, caretRestore) {
-    const tableIdx = start.path[0];
-    const snapshot = deleteSnapshot(options, [tableIdx]);
-    let collapsedCaret = null;
-    await ctx.controller.commitStructural({
-        snapshot,
-        mutate: (children) => {
-            // Read before the delete: with the table gone no block is left to take an ending
-            // from, and the filler below IS a line ending (G4.20).
-            const lineEnding = trailingLineEnding(children[tableIdx]?.raw ?? '\n');
-            const change = deleteNode({ children, ownerKind: undefined, owner: undefined }, tableIdx, ctx.controller.sharing);
-            ctx.selection.collapse();
-            // A sole-table doc empties to zero blocks, stranding the caret on <body>. Materialize
-            // a filler in the same commit so undo restores the table in one step.
-            if (children.length === 0) {
-                const filler = emptyParagraph('', lineEnding);
-                ctx.controller.sharing.stamp(filler);
-                children.push(filler);
-                collapsedCaret = { path: [0], offset: 0 };
-                return { op: 'replace', at: 0, count: 1, newCount: 1 };
-            }
-            const survivorIdx = Math.min(tableIdx, children.length - 1);
-            collapsedCaret = { path: [survivorIdx], offset: 0 };
-            return change;
-        },
-        op: {
-            kind: 'delete',
-            detail: { crossBlock: true, table: 'whole' },
-            eventPath: docPathFrom([tableIdx])
-        },
-        afterTick: caretRestore ? () => caretRestore(collapsedCaret) : undefined
-    });
-    return collapsedCaret;
-}
-async function commitRowDelete(ctx, table, start, rowIdx, options, caretRestore) {
-    const tableIdx = start.path[0];
-    const rowsState = expectStateForNode(table);
-    const snapshot = deleteSnapshot(options, [tableIdx, rowIdx]);
+// ── Internal ────────────────────────────────────────────────────────────────
+async function commitRowDelete(ctx, table, tablePath, rowIdx, lands) {
+    const snapshot = deleteSnapshot([...tablePath, rowIdx]);
     let collapsedCaret = null;
     await ctx.controller.commitContainerStructural({
         containerNode: table,
-        path: [tableIdx],
-        state: rowsState,
+        path: tablePath,
+        state: expectStateForNode(table),
         snapshot,
         mutate: (scope) => {
-            // deleteRow promotes the next row to header (a metadata write).
-            ensureUnsharedChildren(scope.node, scope.sharing);
             mutDeleteRow(scope.node, rowIdx);
             const newRowCount = scope.node.children?.length ?? 0;
             const targetRow = Math.min(rowIdx, Math.max(0, newRowCount - 1));
-            collapsedCaret = { path: [tableIdx, targetRow, 0], offset: 0 };
+            collapsedCaret = { path: [...tablePath, targetRow, 0], offset: 0 };
             ctx.selection.collapse();
             return { op: 'delete', at: rowIdx, count: 1 };
         },
         op: {
             kind: 'tableDeleteRow',
             detail: { rowIdx, crossBlock: true },
-            eventPath: docPathFrom([tableIdx, rowIdx])
+            eventPath: docPathFrom([...tablePath, rowIdx])
         },
-        afterTick: caretRestore ? () => caretRestore(collapsedCaret) : undefined
+        landing: lands ? () => cellLanding(collapsedCaret) : undefined
     });
     return collapsedCaret;
 }
-async function commitColumnDelete(ctx, table, start, colIdx, options, caretRestore) {
-    const tableIdx = start.path[0];
-    const rowsState = expectStateForNode(table);
+async function commitColumnDelete(ctx, table, tablePath, colIdx, lands) {
     const rows = table.children ?? [];
-    // A row's BlockListState registers on mount, so a windowed-out row has none. Scope only the
-    // mounted rows for reactivity; the ensureUnsharedChildren below copy-path-on-writes EVERY
-    // row, so the per-row cell splice stays G1.9-safe regardless of mount state.
+    // Only mounted rows have reactive state; `ensureUnsharedChildren` copies every row, so the
+    // cell splice never writes a shared node whatever a row's mount state (G1.9).
     const mountedRowScopes = [];
     for (let i = 0; i < rows.length; i++) {
         const state = getStateForNode(rows[i]);
         if (state)
-            mountedRowScopes.push({ node: rows[i], state, path: [tableIdx, i] });
+            mountedRowScopes.push({ node: rows[i], state, path: [...tablePath, i] });
     }
     const scopes = [
-        { node: table, state: rowsState, path: [tableIdx] },
+        { node: table, state: expectStateForNode(table), path: tablePath },
         ...mountedRowScopes
     ];
-    const snapshot = deleteSnapshot(options, [tableIdx]);
     let collapsedCaret = null;
     await ctx.controller.commitMultiScope({
         scopes,
-        snapshot,
+        snapshot: deleteSnapshot(tablePath),
         mutate: (scopeViews) => {
             const ownedTable = scopeViews[0].node;
-            // Unshare every row before the splice: mounted rows are already owned via their
-            // scope, and this reaches the windowed-out rows the scopes skip.
+            // Unshare every row before the splice: mounted rows are already copied through their
+            // state, and the call reaches the windowed-out rows that have none.
             ensureUnsharedChildren(ownedTable, scopeViews[0].sharing);
             mutDeleteColumn(ownedTable, colIdx);
             const newColumnCount = metadataOf(ownedTable, 'table').columnCount;
             const targetCol = Math.min(colIdx, Math.max(0, newColumnCount - 1));
-            collapsedCaret = { path: [tableIdx, 0, targetCol], offset: 0 };
+            collapsedCaret = { path: [...tablePath, 0, targetCol], offset: 0 };
             ctx.selection.collapse();
-            // Every mounted row loses the same cell; the table scope is a no-op.
+            // Every mounted row loses the same cell; the table's own change is a no-op.
             const rowDelete = { op: 'delete', at: colIdx, count: 1 };
             return [{ op: 'noop' }, ...mountedRowScopes.map(() => rowDelete)];
         },
-        // Event targets the TABLE: a column index is not a child path (parity with
-        // table-context's column ops), so colIdx rides in the detail.
+        // A column index is not a child path, so the event targets the table and the column goes
+        // in the detail, as the table's own column edits do.
         op: {
             kind: 'tableDeleteColumn',
             detail: { colIdx, crossBlock: true },
-            eventPath: docPathFrom([tableIdx])
+            eventPath: docPathFrom(tablePath)
         },
-        afterTick: caretRestore ? () => caretRestore(collapsedCaret) : undefined
+        landing: lands ? () => cellLanding(collapsedCaret) : undefined
     });
     return collapsedCaret;
 }
+/** The cell a row or column delete keeps the caret in, as the commit's landing. */
+function cellLanding(cell) {
+    return cell && { path: docPathFrom(cell.path), offset: cell.offset };
+}

package/dist/selection/range-delete-table.d.ts

@@ -1,16 +1,18 @@
 /**
- * Table-aware branch of rangeDelete: tables encode selection offsets as cell indices, so prose
- * raw-merge doesn't apply. Post-delete survivors are located by identity scan
- * ({@link survivorPath}), not index arithmetic, because deletions and cascade cleanup shift
- * sibling indices at arbitrary depths. One early-exiting scan per delete, and it rides the cold
- * Backspace/Delete gesture, so the linear cost is accepted.
+ * The `rangeDelete` branches for tables, whose selection offsets are cell indices, so no text
+ * merges: a pair inside one table clears the cells it holds, and a kept table edge of a longer
+ * range loses the whole rows the range covers.
  */
-import type { GrammarView } from '../schema/block-openers';
-import type { PresentationMode } from '../presentation-mode';
-import type { InlineResolverRef } from '../schema/inline-construct-policy';
-import type { CstNode, Document } from '../core/nodes';
-import type { SelectionPoint } from './primitives';
+import type { Reading } from '../schema/reading';
+import type { Document } from '../core/nodes';
 import type { RangeDeleteResult } from './range-delete';
+import { type GridCoverage, type RangeCoverage } from './range-coverage';
 import type { SharingState } from '../tree-operations/sharing';
-export declare function involvesTable(startBlock: CstNode, endBlock: CstNode): boolean;
-export declare function tableAwareRangeDelete(doc: Document, start: SelectionPoint, end: SelectionPoint, sharing: SharingState, grammar: GrammarView | undefined, presentationMode?: PresentationMode, linkRef?: InlineResolverRef): RangeDeleteResult;
+/** Whether an edge the range keeps sits on a table, so its rows are cut rather than its text. */
+export declare function keepsTableEdge(coverage: RangeCoverage): boolean;
+/** Clears the cells a pair inside one table holds, keeping the table's rows and columns; the
+ *  caret goes in the start cell, so a follow-up paste or typed text lands inside the table. */
+export declare function clearGridCells(doc: Document, coverage: RangeCoverage, grid: GridCoverage, sharing: SharingState, reading: Reading): RangeDeleteResult;
+/** Deletes a range that keeps a table edge: that table loses the rows from the start's row on,
+ *  or up to the end's; a kept text edge is truncated in place and what lies between goes. */
+export declare function tableAwareRangeDelete(doc: Document, coverage: RangeCoverage, sharing: SharingState, reading: Reading): RangeDeleteResult;