@voithos-labs/aragonite 0.10.3 → 0.10.7

package/dist/editor-actions/index.js

@@ -1,14 +1,15 @@
 /**
- * Editor-root action bundle factory. Composes the undo controller plus four
- * sub-interface bundles for Editor.svelte to wire into Svelte context.
+ * The editor root's action bundle: the undo controller plus the four action groups
+ * Editor.svelte puts into Svelte context.
  */
 import { createUndoController } from './commit/undo-controller';
 import { createBlockEditActions } from './block-edit';
 import { createFocusActions } from './focus/focus';
 import { createHistoryActions } from './commit/history';
 import { createContainerEditActions } from './container-edit';
-export function createEditorActions(deps) {
-    const controller = createUndoController(deps);
+/** `announceEdit` goes to the undo controller alone (`createUndoController`). */
+export function createEditorActions(deps, announceEdit) {
+    const controller = createUndoController(deps, announceEdit);
     return {
         blockEdit: createBlockEditActions(deps, controller),
         focus: createFocusActions(deps, controller),

package/dist/editor-actions/inline-range-commit.d.ts

@@ -1,20 +1,22 @@
 /**
- * Rewrite a byte range inside one leaf's raw as a single undo entry. The anchored inline editors
- * (image properties, link card) all reach their bytes this way, so the scope choice — top-level
- * vs container ceremony — and the no-op discard live here rather than at each popover.
+ * Rewrite a byte range inside one leaf's raw as a single undo entry. The inline popovers and the
+ * inline menus all write their bytes this way, through the content write every keystroke takes, so
+ * a splice that fills or empties a blank line keeps the separators a reload reads.
  */
-import type { Document } from '../core/nodes';
-import type { GrammarView } from '../schema/block-openers';
-import type { UndoController } from './deps';
-export interface InlineRangeCommitDeps {
-    getDoc: () => Document;
-    controller: UndoController;
-    /** The instance's grammar, for the leaf's own raw-write rule. Absent = the global grammar. */
-    grammar?: GrammarView;
-}
+import type { EditorRoot } from './deps';
 export interface InlineRangeCommit {
-    /** Splice `bytes` over `[start, end)` of the leaf at `path`; `caretAfter` is the raw offset the
-     *  entry's snapshot restores. A splice that changes no byte commits nothing. */
-    commitInlineRange(path: number[], start: number, end: number, bytes: string, caretAfter: number): Promise<void>;
+    /**
+     * The length change the same splice would store once the leaf's kind and its container rewrite
+     * it, read before committing; 0 when it would store nothing.
+     */
+    writtenDelta(path: number[], start: number, end: number, bytes: string): number;
+    /** Splice `bytes` over `[start, end)` of the leaf at `path`; the undo entry restores the caret
+     *  to `caretAfter`. Resolves whether the leaf holds the bytes (true for a no-change splice). */
+    commitInlineRange(path: number[], start: number, end: number, bytes: string, caretAfter: number, opts?: InlineRangeOptions): Promise<boolean>;
+}
+export interface InlineRangeOptions {
+    /** Put the caret at `caretAfter` too, counted in the bytes the leaf stores (a table cell's
+     *  escaped pipe included), and bring it into view: the next key goes to the document. */
+    landCaret?: boolean;
 }
-export declare function createInlineRangeCommit(deps: InlineRangeCommitDeps): InlineRangeCommit;
+export declare function createInlineRangeCommit(root: EditorRoot): InlineRangeCommit;

package/dist/editor-actions/inline-range-commit.js

@@ -1,63 +1,54 @@
 /**
- * Rewrite a byte range inside one leaf's raw as a single undo entry. The anchored inline editors
- * (image properties, link card) all reach their bytes this way, so the scope choice — top-level
- * vs container ceremony — and the no-op discard live here rather than at each popover.
+ * Rewrite a byte range inside one leaf's raw as a single undo entry. The inline popovers and the
+ * inline menus all write their bytes this way, through the content write every keystroke takes, so
+ * a splice that fills or empties a blank line keeps the separators a reload reads.
  */
 import { docPathFrom } from '../cursor/coordinate-spaces';
-import { expectStateForNode } from '../reactivity/state-registry';
-import { isBlockNode, nodeAt, normalizeOwnRaw, writeOwnRaw } from '../tree-operations/node-primitives';
-import { ensureUnsharedChild, ensureUnsharedPath } from '../tree-operations/unshare';
-export function createInlineRangeCommit(deps) {
-    async function commitInlineRange(path, start, end, bytes, caretAfter) {
+import { legalizeWrite } from '../tree-operations/content-write';
+import { createPathScope } from './block-edit-scope';
+import { commitLeafText } from './block-edit-core';
+export function createInlineRangeCommit(root) {
+    /** The leaf's list and the write the splice makes, or null when there is no leaf or the write
+     *  would store the bytes the leaf already has. */
+    function planSplice(path, start, end, bytes) {
         if (path.length === 0)
-            return;
-        const leaf = nodeAt(deps.getDoc(), path);
-        if (leaf === null || !isBlockNode(leaf))
-            return;
+            return null;
+        const scope = createPathScope(root, docPathFrom(path.slice(0, -1)));
+        const index = path[path.length - 1];
+        const leaf = scope?.children()[index];
+        if (!scope || !leaf)
+            return null;
         const newRaw = leaf.raw.slice(0, start) + bytes + leaf.raw.slice(end);
-        // Compared against the bytes the KIND would actually land (G4.28), so a splice a cell's
-        // pipe escape normalizes away adds no undo entry — the dismiss-after-resize shape.
-        const legal = normalizeOwnRaw(leaf, newRaw);
-        if (legal === leaf.raw)
-            return;
-        const { controller } = deps;
-        const snapshot = { path: docPathFrom(path), offset: caretAfter };
-        const leafIdx = path[path.length - 1];
-        const op = {
-            kind: 'updateContent',
-            detail: { length: legal.length },
-            eventPath: docPathFrom(path)
-        };
-        const writeRaw = (node) => {
-            writeOwnRaw(node, newRaw, deps.grammar);
-        };
-        if (path.length === 1) {
-            await controller.commitStructural({
-                snapshot,
-                mutate: (children) => {
-                    const [owned] = ensureUnsharedPath({ children }, [leafIdx], controller.sharing);
-                    writeRaw(owned);
-                    return { op: 'noop' };
-                },
-                op
-            });
-            return;
+        // Compared against the bytes the write would store (G4.28), so a splice a table cell's pipe
+        // escaping cancels out adds no undo entry (dismissing an image after a resize).
+        const write = legalizeWrite(scope.target(), index, newRaw, 'literal');
+        return { scope, index, write: write.text === leaf.raw ? null : write };
+    }
+    function writtenDelta(path, start, end, bytes) {
+        const plan = planSplice(path, start, end, bytes);
+        if (!plan?.write)
+            return 0;
+        return plan.write.text.length - plan.scope.children()[plan.index].raw.length;
+    }
+    async function commitInlineRange(path, start, end, bytes, caretAfter, opts = {}) {
+        const plan = planSplice(path, start, end, bytes);
+        if (!plan)
+            return false;
+        // Not held: the height correction already keeps the focused line still.
+        const reveal = 'into-view';
+        if (!plan.write) {
+            if (opts.landCaret) {
+                await root.deps.caretLanding.land(plan.scope.at(plan.index, [], caretAfter), { reveal });
+            }
+            return true;
         }
-        // path.length > 1, so the parent is a container node, never the root.
-        const container = nodeAt(deps.getDoc(), path.slice(0, -1));
-        if (container === null || !isBlockNode(container))
-            return;
-        await controller.commitContainerStructural({
-            containerNode: container,
-            path: path.slice(0, -1),
-            state: expectStateForNode(container),
-            snapshot,
-            mutate: (scope) => {
-                writeRaw(ensureUnsharedChild(scope.node, leafIdx, scope.sharing));
-                return { op: 'noop' };
-            },
-            op
+        const landed = await commitLeafText(plan.scope, plan.index, plan.write, {
+            snapshotOffset: caretAfter,
+            caret: plan.write.storedOffset(caretAfter),
+            landing: opts.landCaret ? (written) => written.caret : undefined,
+            reveal
         });
+        return landed.wrote;
     }
-    return { commitInlineRange };
+    return { writtenDelta, commitInlineRange };
 }

package/dist/editor-actions/leaf-write.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The two parts of a keystroke only the editor root can do: grouping it with its typing burst in
+ * the undo history, and writing the leaf in place outside a commit. Containers reach both through
+ * `ContainerEditActions`.
+ */
+import type { ContainerEditActions, InPlaceResult, Relanding } from '../action-contracts';
+import type { EditorActionsDeps, UndoController } from './deps';
+export type { InPlaceResult, Relanding };
+/** `typeInLeaf` starts the undo pause timer when `work` finishes, even if it throws. */
+export type LeafTyping = Pick<ContainerEditActions, 'typeInLeaf' | 'writeLeafInPlace'>;
+export declare function createLeafTyping(deps: EditorActionsDeps, controller: UndoController): LeafTyping;

package/dist/editor-actions/leaf-write.js

@@ -0,0 +1,102 @@
+/**
+ * The two parts of a keystroke only the editor root can do: grouping it with its typing burst in
+ * the undo history, and writing the leaf in place outside a commit. Containers reach both through
+ * `ContainerEditActions`.
+ */
+import { documentLineEnding } from '../core/lines';
+import { assertInvariant } from '../assert';
+import { docPathFrom } from '../cursor/coordinate-spaces';
+import { caretTargetFor } from '../selection/caret-target';
+import { settledCaretPosition, updateNodeContent } from '../tree-operations/content-write';
+import { ensureUnsharedPath } from '../tree-operations/unshare';
+import { blockNodeAt, documentBody } from '../tree-operations/node-primitives';
+import { rawOffsetOfLeaf } from '../tree-operations/container-offsets';
+import { rebuildUnsharedChain } from '../tree-operations/chain-rebuild';
+import { foldLandingFor, publishAncestryFolds, publishScopeFold } from './ancestry-folds';
+import { admitsWrite } from './commit/reading-write-gate';
+export function createLeafTyping(deps, controller) {
+    return {
+        typeInLeaf(leafPath, preEditOffset, batchKey, work) {
+            controller.pushUndoSnapshotDebounced(leafPath, preEditOffset, batchKey);
+            // A batch whose pause timer never started never ends on a pause, so the timer starts
+            // even when the keystroke's work throws.
+            return controller.joinTypingBatch(work).finally(() => controller.armUndoPause());
+        },
+        writeLeafInPlace(leafPath, write, caret) {
+            const kindOf = () => blockNodeAt(deps.doc, leafPath)?.kind;
+            // A backstop: the keystroke asks the reading-mode check before it picks this route.
+            if (!admitsWrite(deps.reading, 'updateContent', kindOf))
+                return { wrote: false };
+            const chain = ensureUnsharedPath(deps.doc, leafPath, deps.sharing);
+            // A shorter chain would leave the leaf's container shared with an undo entry, and
+            // writing it would rewrite that entry.
+            assertInvariant('unshared-spine-depth', () => chain.length === leafPath.length
+                ? null
+                : {
+                    code: 'unshared-spine-depth',
+                    message: `writeLeafInPlace: chain depth ${chain.length} != leaf path depth ${leafPath.length}`
+                });
+            if (chain.length !== leafPath.length)
+                return { wrote: false };
+            const depth = leafPath.length;
+            const owner = depth > 1 ? chain[depth - 2] : undefined;
+            // The chain reached the leaf through the owner's children, so below the root they exist.
+            const body = owner
+                ? { children: owner.children, owner, lineEnding: documentLineEnding(deps.doc) }
+                : documentBody(deps.doc);
+            // Read before the write: the ancestors' rebuild locates the leaf's region by these bytes.
+            const leafPreviousRaw = chain[depth - 1].raw;
+            const settled = updateNodeContent(body, leafPath[depth - 1], write, deps.reading.grammar, deps.sharing);
+            publishScopeFold(deps, owner, settled.change);
+            const folds = [];
+            let reclassified = [];
+            // The top level has no ancestors to rebuild, which keeps the keystroke there cheap.
+            if (depth > 1) {
+                reclassified = rebuildUnsharedChain(deps.doc, chain, deps.sharing, folds, deps.reading.grammar, { path: leafPath, leafPreviousRaw });
+                publishAncestryFolds(deps, folds);
+                // Raw written outside a commit reaches the view once Svelte re-reads doc.children.
+                deps.doc.children = [...deps.doc.children];
+            }
+            // The content version bumps after the tree write, in the order a commit uses.
+            deps.bumpContentVersion();
+            const moved = settled.change.op !== 'noop' || folds.length > 0 || reclassified.length > 0;
+            return {
+                wrote: true,
+                relanding: moved
+                    ? relandingAfter(deps, { leafPath, chain, body, caret, settled, folds, reclassified })
+                    : null
+            };
+        }
+    };
+}
+/** Where the caret goes when the write moved it off the leaf's element, first match wins: a
+ *  collapsed ancestor, then one whose kind changed, then the write's own merge. */
+function relandingAfter(deps, written) {
+    const { leafPath, settled, caret } = written;
+    const parentPath = leafPath.slice(0, -1);
+    const leafAt = settledCaretPosition(settled, leafPath.at(-1), caret, written.body.children);
+    const settledPath = [...parentPath, leafAt.index];
+    const byteIn = (level) => rawOffsetOfLeaf(written.chain[level], settledPath.slice(level + 1), leafAt.offset);
+    const fold = written.folds.at(-1);
+    const foldLanding = foldLandingFor(written.folds, parentPath);
+    if (fold && foldLanding) {
+        return resolved(deps, foldLanding.path, foldLanding.offset + (byteIn(fold.depth) ?? 0), 1);
+    }
+    const outermost = written.reclassified.at(-1);
+    const level = outermost ? written.chain.indexOf(outermost.previous) : -1;
+    if (level >= 0)
+        return resolved(deps, leafPath.slice(0, level + 1), byteIn(level) ?? 0, 1);
+    const { change } = settled;
+    const window = change.op === 'replace' ? { at: change.at, count: change.newCount } : null;
+    return resolved(deps, settledPath, leafAt.offset, window?.count ?? 1, window?.at);
+}
+/** The position at `path` resolved to a leaf, with the window of `count` blocks from `at` (the
+ *  path's own index by default) in the list that holds it. */
+function resolved(deps, path, offset, count, at = path[path.length - 1]) {
+    const block = { path: docPathFrom(path), offset };
+    const leaf = caretTargetFor(deps.doc, block);
+    return {
+        caret: leaf ? { path: leaf.leafPath, offset: leaf.offset } : block,
+        window: { list: docPathFrom(path.slice(0, -1)), at, count }
+    };
+}

package/dist/editor-actions/list-context.d.ts

@@ -1,25 +1,24 @@
 /**
- * The ListContext bundle a ListBlock provides to its child ListItemBlocks. Every
- * mutation routes through `commitMultiScope`, whose owned scope views are the only
- * legal write targets — never the pre-commit `deps.scope.node` captures.
+ * The ListContext a ListBlock provides to its child ListItemBlocks. Every edit goes through
+ * `commitMultiScope`, whose copied scope views are the only legal write targets, never the
+ * `deps.scope.node` read before the commit.
  */
 import type { BlockEditActions, FocusActions, ListContext } from '../action-contracts';
-import type { PresentationModeGetter } from '../editor-keys';
-import type { InlineResolverRef } from '../schema/inline-construct-policy';
+import type { LineEnding } from '../core/lines';
+import type { Reading } from '../schema/reading';
 import type { UndoController } from './deps';
 import type { BlockListState } from '../reactivity/block-list-state.svelte';
 import type { NodeScope } from './nested/nested-actions';
 export interface ListContextDeps {
     scope: NodeScope;
+    /** The document's line ending, which the lines an item insert or a list exit creates take. */
+    getLineEnding: () => LineEnding;
     state: BlockListState;
     parentBlockEdit: BlockEditActions;
     parentFocus: FocusActions;
     parentListContext: ListContext | undefined;
     controller: UndoController;
-    /** Live EFFECTIVE mode, for the mid-item split's byte rebalance. Nullable rather than
-     *  optional so the one composing container answers. */
-    getPresentationMode: PresentationModeGetter | undefined;
-    /** The instance's link-reference resolver, required-nullable beside the mode. */
-    linkRef: InlineResolverRef | undefined;
+    /** The editor's reading, for the mid-item split's reparse and marker rebalance. */
+    reading: Reading;
 }
 export declare function createListContext(deps: ListContextDeps): ListContext;