@voithos-labs/aragonite 0.10.3 → 0.10.7

package/dist/cursor/reveal-anchor.js

@@ -1,31 +0,0 @@
-export function createRevealAnchorState() {
-    let target = null;
-    // A new claim supersedes the last MINT, not the current holder: supersession is a fact
-    // about reveals, and reading the holder would let `claim → release → claim` leave the
-    // first reveal believing it still owns the viewport (two settle loops, one scrollTop).
-    let owner = null;
-    let lastMinted = null;
-    function drop() {
-        owner = null;
-        target = null;
-    }
-    return {
-        get: () => target,
-        claim(path, block = 'nearest') {
-            const token = { superseded: false };
-            if (lastMinted)
-                lastMinted.superseded = true;
-            lastMinted = token;
-            owner = token;
-            target = { path: [...path], block };
-            return {
-                release: () => {
-                    if (owner === token)
-                        drop();
-                },
-                isSuperseded: () => token.superseded
-            };
-        },
-        releaseAll: drop
-    };
-}

package/dist/invariants/split-landing.d.ts

@@ -1,8 +0,0 @@
-/**
- * G1.34 — a split's landing is the index the primitive returned. `blockIndex + 1` is right
- * only while the first half stays one block; a first half whose bytes reparse plural pushes
- * the second half further down, and a caller that re-derives the landing seats the caret on
- * the first half's tail.
- */
-import type { InvariantViolation } from '../assert';
-export declare function checkSplitLanding(expected: number, landing: number): InvariantViolation | null;

package/dist/invariants/split-landing.js

@@ -1,15 +0,0 @@
-/**
- * G1.34 — a split's landing is the index the primitive returned. `blockIndex + 1` is right
- * only while the first half stays one block; a first half whose bytes reparse plural pushes
- * the second half further down, and a caller that re-derives the landing seats the caret on
- * the first half's tail.
- */
-export function checkSplitLanding(expected, landing) {
-    if (landing === expected)
-        return null;
-    return {
-        code: 'split-landing',
-        message: `a split landed at index ${landing}, but its second half starts at ${expected}`,
-        detail: { landing, expected }
-    };
-}

package/dist/selection/double-click-trim.d.ts

@@ -1,17 +0,0 @@
-/**
- * Word selection without its trailing space. Windows Chromium's double-click takes the whitespace
- * after a word (the desktop-Word convention); a formatting toggle over that range would wrap the
- * space too, and every other platform selects the bare word. The browser paints its own range
- * before any `dblclick` handler runs, so the word is selected HERE, on the second press, with
- * the native selection suppressed: the trimmed range is the first one ever painted.
- */
-/** Trim trailing whitespace off the document's current selection when it ends in a text node.
- *  A selection that is only whitespace is left alone: collapsing it would undo the click. */
-export declare function trimDoubleClickSelection(doc: Document): boolean;
-/**
- * Select the word under the point of a double-click's second press, trimmed, synchronously.
- * Word edges come from the engine's own `modify` walk so they match what its double-click would
- * have chosen. False when the point names no text position; the caller then leaves the press to
- * the browser.
- */
-export declare function selectWordAtPoint(doc: Document, x: number, y: number): boolean;

package/dist/selection/double-click-trim.js

@@ -1,57 +0,0 @@
-/**
- * Word selection without its trailing space. Windows Chromium's double-click takes the whitespace
- * after a word (the desktop-Word convention); a formatting toggle over that range would wrap the
- * space too, and every other platform selects the bare word. The browser paints its own range
- * before any `dblclick` handler runs, so the word is selected HERE, on the second press, with
- * the native selection suppressed: the trimmed range is the first one ever painted.
- */
-/** Trim trailing whitespace off the document's current selection when it ends in a text node.
- *  A selection that is only whitespace is left alone: collapsing it would undo the click. */
-export function trimDoubleClickSelection(doc) {
-    const sel = doc.getSelection();
-    if (!sel || sel.rangeCount === 0 || sel.isCollapsed)
-        return false;
-    const range = sel.getRangeAt(0);
-    const endNode = range.endContainer;
-    if (!(endNode instanceof Text))
-        return false;
-    const text = range.toString();
-    const trimmed = text.trimEnd().length;
-    if (trimmed === 0 || trimmed === text.length)
-        return false;
-    const cut = text.length - trimmed;
-    if (cut > range.endOffset)
-        return false;
-    sel.setBaseAndExtent(range.startContainer, range.startOffset, endNode, range.endOffset - cut);
-    return true;
-}
-/**
- * Select the word under the point of a double-click's second press, trimmed, synchronously.
- * Word edges come from the engine's own `modify` walk so they match what its double-click would
- * have chosen. False when the point names no text position; the caller then leaves the press to
- * the browser.
- */
-export function selectWordAtPoint(doc, x, y) {
-    const sel = doc.getSelection();
-    const hit = textPositionAt(doc, x, y);
-    if (!sel || !hit || typeof sel.modify !== 'function')
-        return false;
-    sel.setBaseAndExtent(hit.node, hit.offset, hit.node, hit.offset);
-    sel.modify('move', 'backward', 'word');
-    sel.modify('extend', 'forward', 'word');
-    if (sel.isCollapsed)
-        return false;
-    trimDoubleClickSelection(doc);
-    return true;
-}
-function textPositionAt(doc, x, y) {
-    const position = doc.caretPositionFromPoint?.(x, y);
-    if (position?.offsetNode instanceof Text) {
-        return { node: position.offsetNode, offset: position.offset };
-    }
-    const range = doc.caretRangeFromPoint?.(x, y);
-    if (range?.startContainer instanceof Text) {
-        return { node: range.startContainer, offset: range.startOffset };
-    }
-    return null;
-}

package/dist/tree-operations/list/terminator.d.ts

@@ -1,17 +0,0 @@
-/**
- * Ensure a list item's `raw` ends with a line ending. Without it `rebuildListRaw`
- * concatenates adjacent items' raws into one line, which re-parses as one item. The
- * ending is a parameter, never a literal `'\n'`: an item arriving without one adopts the
- * target's (G4.20), or a paste strands an LF line inside a CRLF list. Parse-time items
- * keep their original state; only mid-list splices normalize.
- */
-import type { CstNode } from '../../core/nodes';
-export declare function ensureListItemNewlineTerminated(item: CstNode, ending: '\n' | '\r\n'): void;
-/** Normalize every pasted listItem in `items` (non-listItems pass through). */
-export declare function newlineTerminateListItems(items: CstNode[], ending: '\n' | '\r\n'): void;
-/**
- * THE way pasted items enter a list's children mid-array: termination is welded to the
- * splice so a new paste path cannot forget it. The ending comes from the neighbours the
- * items join — displaced target, then the item above, then the list head.
- */
-export declare function spliceTerminatedItems(children: CstNode[], at: number, removeCount: number, items: CstNode[]): void;

package/dist/tree-operations/list/terminator.js

@@ -1,60 +0,0 @@
-/**
- * Ensure a list item's `raw` ends with a line ending. Without it `rebuildListRaw`
- * concatenates adjacent items' raws into one line, which re-parses as one item. The
- * ending is a parameter, never a literal `'\n'`: an item arriving without one adopts the
- * target's (G4.20), or a paste strands an LF line inside a CRLF list. Parse-time items
- * keep their original state; only mid-list splices normalize.
- */
-import { trailingLineEnding } from '../../core/lines';
-import { spliceMany } from '../splice-many';
-import { rebuildContainerRawIfContainer } from '../../schema/container-raw';
-import { getBlockKindDescriptor } from '../../schema/block-kind-descriptor';
-/**
- * The child holding the node's last LINE, or null when the node's own raw holds it. Only a
- * strip container serializes its children's raws as whole lines; a grid cell and an opaque
- * body live inside a line their container emits, so the ending belongs to the container.
- */
-function lastLineOwningChild(node) {
-    if (getBlockKindDescriptor(node.kind).containerContract !== 'strip')
-        return null;
-    const children = node.children;
-    if (!children || children.length === 0)
-        return null;
-    return children[children.length - 1];
-}
-/**
- * Terminate the deepest node that owns its own last line, then rebuild every strip container
- * above it: such a container's raw is DERIVED from its children, so appending to it directly
- * leaves the two disagreeing (G1.1) and its tail item still unterminated.
- */
-function terminateLastLine(node, ending) {
-    if (node.raw.endsWith('\n'))
-        return;
-    const child = lastLineOwningChild(node);
-    if (!child) {
-        node.raw += ending;
-        return;
-    }
-    terminateLastLine(child, ending);
-    rebuildContainerRawIfContainer(node);
-}
-export function ensureListItemNewlineTerminated(item, ending) {
-    terminateLastLine(item, ending);
-}
-/** Normalize every pasted listItem in `items` (non-listItems pass through). */
-export function newlineTerminateListItems(items, ending) {
-    for (const item of items) {
-        if (item.kind === 'listItem')
-            ensureListItemNewlineTerminated(item, ending);
-    }
-}
-/**
- * THE way pasted items enter a list's children mid-array: termination is welded to the
- * splice so a new paste path cannot forget it. The ending comes from the neighbours the
- * items join — displaced target, then the item above, then the list head.
- */
-export function spliceTerminatedItems(children, at, removeCount, items) {
-    const neighbour = (removeCount > 0 ? children[at] : undefined) ?? children[at - 1] ?? children[0];
-    newlineTerminateListItems(items, neighbour ? trailingLineEnding(neighbour.raw) : '\n');
-    spliceMany(children, at, removeCount, items);
-}

package/dist/tree-operations/paste/replace-block-at-parent.d.ts

@@ -1,29 +0,0 @@
-/**
- * Replace the block at `blockPath`, committing at its parent scope (`parent-scope.ts`)
- * rather than through the caller's blockEdit — paste-into-cell must mutate `doc.children`
- * while holding the row-level nested bundle.
- */
-import type { UndoEntryMode } from '../../action-contracts';
-import type { OperationDetailMap } from '../../schema/operations';
-import type { CstNode, Document } from '../../core/nodes';
-import type { GrammarView } from '../../schema/block-openers';
-import type { PasteCommitCoordinator } from './paste-deps';
-export interface ReplaceBlockAtParentArgs {
-    doc: Document;
-    /** Path to the block being replaced. Length ≥ 1. */
-    blockPath: number[];
-    replacement: CstNode[];
-    controller: PasteCommitCoordinator;
-    undoEntry: UndoEntryMode;
-    /** Index into `replacement` to focus after the commit. */
-    focusReplacementIndex: number;
-    focusOffset: number;
-    source: Extract<OperationDetailMap['replaceBlock'], {
-        source: unknown;
-    }>['source'];
-    /** Instance grammar for the escape's kind re-derive; absent = global. */
-    grammar?: GrammarView;
-    /** The clipboard's own trailing blank line, where nothing in the splice stands for it. */
-    trailingSeparator?: string;
-}
-export declare function replaceBlockAtParent(args: ReplaceBlockAtParentArgs): Promise<void>;

package/dist/tree-operations/paste/replace-block-at-parent.js

@@ -1,75 +0,0 @@
-/**
- * Replace the block at `blockPath`, committing at its parent scope (`parent-scope.ts`)
- * rather than through the caller's blockEdit — paste-into-cell must mutate `doc.children`
- * while holding the row-level nested bundle.
- */
-import { nodeAt } from '../node-primitives';
-import { spliceMany } from '../splice-many';
-import { trailingLineEnding } from '../../core/lines';
-import { normalizeReplacementForBody } from './body-write';
-import { landedPasteOffset, trackedPasteCaret } from './focus-target';
-import { resolveParentScope } from './parent-scope';
-import { docPathFrom } from '../../cursor/coordinate-spaces';
-import { replacePreservingFirst, stampStructuralChange } from '../structural-change';
-/**
- * Land the clipboard's trailing blank where a reload folds one: the DOCUMENT's own suffix, and
- * only at a tail whose slot is empty — one separation is one separation. A container tail
- * declines, since `innerSuffix` is the wrap-peel settle's register on this same commit. The
- * clipboard says WHETHER a line lands, never which one: normalized to LF at every entry point,
- * its own suffix would strand an LF line in a CRLF document (G4.20).
- */
-function landTrailingSeparator(args, children, afterIndex, ending) {
-    if (!args.trailingSeparator || args.blockPath.length !== 1)
-        return;
-    if (args.doc.suffix !== '' || afterIndex !== children.length)
-        return;
-    args.doc.suffix = ending;
-}
-export async function replaceBlockAtParent(args) {
-    const { doc, blockPath, controller, undoEntry, focusOffset, source } = args;
-    const blockIdx = blockPath[blockPath.length - 1];
-    const scope = resolveParentScope(doc, blockPath, controller);
-    if (!scope)
-        return;
-    // A replacement is minted before any byte sink sees it, so the owner's bodyWrite escape
-    // lands here — on the clipboard blocks AND the target's split halves alike.
-    const ownerKind = blockPath.length > 1 ? scope.node.kind : undefined;
-    const { replacement, mapIndex } = normalizeReplacementForBody(ownerKind, args.replacement, args.grammar);
-    const focusReplacementIndex = mapIndex(args.focusReplacementIndex);
-    // The settle can fold the spliced window into its neighbours, which moves both halves of the
-    // landing: the residue reattaches inside the last pasted leaf, and an absorb above moves the
-    // slot itself. The commit carries this through its folds and `afterTick` reads it back.
-    const caret = trackedPasteCaret(replacement, blockIdx, focusReplacementIndex, focusOffset);
-    const oldBlock = nodeAt(doc, blockPath);
-    const sameKindFirst = oldBlock !== null && replacement.length > 0 && replacement[0].kind === oldBlock.kind;
-    // Read as bytes before the commit: the displaced block is the document's own ending, and a
-    // node held across a commit goes stale the moment the spine unshares.
-    const tailEnding = oldBlock ? trailingLineEnding(oldBlock.raw) : '\n';
-    await controller.commitMultiScope({
-        scopes: [scope],
-        snapshot: undoEntry === 'join' ? 'skip' : { path: docPathFrom(blockPath), offset: 0 },
-        mutate: ([scopeView]) => {
-            spliceMany(scopeView.children, blockIdx, 1, replacement);
-            // Identity preservation only helps on a kind match; BlockHost dispatches by kind,
-            // so a different kind remounts anyway.
-            const change = sameKindFirst
-                ? replacePreservingFirst(blockIdx, 1, replacement.length)
-                : { op: 'replace', at: blockIdx, count: 1, newCount: replacement.length };
-            stampStructuralChange(scopeView.children, change, scopeView.sharing);
-            landTrailingSeparator(args, scopeView.children, blockIdx + replacement.length, tailEnding);
-            return [change];
-        },
-        op: {
-            kind: 'replaceBlock',
-            detail: { source },
-            eventPath: docPathFrom(blockPath)
-        },
-        trackCaret: [caret],
-        afterTick: () => {
-            // Re-read from the document: the ceremony unshares the spine, so the scope node the
-            // caller resolved is a stale copy by now.
-            const landed = nodeAt(doc, scope.path)?.children?.[caret.index];
-            return controller.landCaret([...scope.path, caret.index], landedPasteOffset(landed, caret, focusOffset));
-        }
-    });
-}