@voithos-labs/aragonite 0.10.4 → 0.10.7

package/dist/selection/cross-block/pointer.js

@@ -1,30 +1,23 @@
-/**
- * Pointer half of the cross-block dispatcher: shift-click extension and pointer-drag entry. See
- * dispatch.ts for the composer that wires this together with the keydown half.
- */
+/** The pointer half of cross-block dispatch: shift-click extension and starting a drag-select. */
 import { handleShiftClick } from '../keyboard-extend';
 import { findBlockPathForElement } from '../path-lookup';
-import { clearNativeSelection } from '../native-bridge';
-import { offsetFromViewportPoint } from '../../cursor/point-offset';
+import { applyCollapsedCaret, clearNativeSelection } from '../native-bridge';
+import { isInPaddingRow, offsetFromViewportPoint } from '../../cursor/point-offset';
 import { installDragListener } from '../drag-pointer';
 import { devWarn } from '../../dev-warn';
+import { isWholeBlockInputProxy } from '../../editor-actions/whole-block-focus-surface';
 export function createCrossBlockPointer(ctx) {
     return {
-        handlePointerDown: (e) => handlePointerDown(ctx, e)
+        handlePointerDown: (e, press) => handlePointerDown(ctx, e, press)
     };
 }
-/**
- * Shared pointerdown preamble for any block that intercepts cross-block input. Resets
- * sticky-column and the select-all counter, and on a non-shift press clears any active
- * cross-block selection so a fresh drag doesn't extend the prior range. The native sibling of
- * `caret-doors.ts`, so it ends the gap caret too.
- */
-export function resetForPointerDown(selection, stickyColumn, edgeAffinity, isShift) {
-    stickyColumn.reset();
-    edgeAffinity.reset();
+/** The pointerdown reset every cross-block-aware block shares, the pointer counterpart of
+ *  `caret-doors.ts`: a plain click ends any range, so a fresh drag starts its own. */
+export function resetForPointerDown(selection, caretMemory, isShift) {
+    caretMemory.forget();
     selection.resetSelectAllCount();
-    // Unconditional, unlike the range arm: the gap is collapsed-only, so a shift-press has no
-    // range to grow from it. Silent when no gap is live.
+    // Unconditional, unlike the range branch: a gap caret is always collapsed, so a shift-click
+    // has no range to grow from it. Silent when no gap caret is live.
     selection.clearGapCaret();
     if (!isShift && selection.isCrossBlock) {
         selection.clear();
@@ -32,30 +25,35 @@ export function resetForPointerDown(selection, stickyColumn, edgeAffinity, isShi
     }
 }
 // ── Pointer ────────────────────────────────────────────────────────────────
-function handlePointerDown(ctx, e) {
+function handlePointerDown(ctx, e, press = {}) {
     const el = ctx.getEl();
     if (!el)
         return false;
     const { selection } = ctx;
     const myPath = ctx.getMyPath();
-    resetForPointerDown(selection, ctx.stickyColumn, ctx.edgeAffinity, e.shiftKey);
+    resetForPointerDown(selection, ctx.caretMemory, e.shiftKey);
+    const padding = armPaddingPress(el, myPath, e);
     if (e.shiftKey) {
         const prevActive = document.activeElement;
         const prevFocusEl = prevActive instanceof HTMLElement && prevActive !== el
             ? prevActive.closest('[contenteditable]')
             : null;
         const prevFocusPath = findBlockPathForElement(prevActive);
-        const handled = handleShiftClick(selection, el, myPath, e.clientX, e.clientY, prevFocusEl, prevFocusPath);
+        const handled = handleShiftClick(selection, el, myPath, e.clientX, e.clientY, prevFocusEl, prevFocusPath, ctx.selectedWidget);
         if (handled) {
             e.preventDefault();
             return true;
         }
     }
     if (!e.shiftKey) {
+        if (press.ownDrag) {
+            press.ownDrag(padding);
+            return false;
+        }
         const root = ctx.getEditorRoot();
         if (!root)
             return false;
-        const offset = offsetFromViewportPoint(el, e.clientX, e.clientY);
+        const offset = press.anchorOffset ?? padding?.offset ?? offsetFromViewportPoint(el, e.clientX, e.clientY);
         if (offset === null)
             return false;
         // SelectionState normalizes table endpoints on cross-block entry, so the raw block path
@@ -68,13 +66,64 @@ function handlePointerDown(ctx, e) {
         }
         installDragListener({
             editorRoot: root,
-            // The root is the hit-test boundary; what SCROLLS may be an ancestor in
-            // host-scroll mode, so the two resolve separately.
+            // The root is the hit-test boundary; what scrolls may be an ancestor in host-scroll
+            // mode, so the two resolve separately.
             scrollContainer: ctx.getScrollHost() ?? root,
             selection,
             getBlockElByPath: ctx.getBlockElByPath,
-            lifetimeSignal
+            lifetimeSignal,
+            paintSameBlock: () => press.paintSameBlock === true || padding?.placed() === true
         }, anchorPoint, e);
     }
     return false;
 }
+const armedPresses = new WeakMap();
+// Mac and Linux place a press above the first line or below the last at that line's start or
+// end. The mousedown is cancelled, not the pointerdown, which would swallow a double click's.
+function armPaddingPress(el, path, e) {
+    armedPresses.get(el)?.abort();
+    if (e.button !== 0 || !e.isPrimary || e.shiftKey || !el.isContentEditable)
+        return null;
+    if (!isInPaddingRow(el, e.clientX, e.clientY))
+        return null;
+    const offset = offsetFromViewportPoint(el, e.clientX, e.clientY);
+    if (offset === null)
+        return null;
+    const armed = new AbortController();
+    armedPresses.set(el, armed);
+    let placed = false;
+    const place = (down) => {
+        armed.abort();
+        // A later click of a run is the multi-click gesture's, which reads the same probe.
+        if (down.button !== 0 || down.detail > 1)
+            return;
+        down.preventDefault();
+        el.focus({ preventScroll: true });
+        applyCollapsedCaret(el, { path, offset });
+        placed = true;
+    };
+    el.addEventListener('mousedown', place, { signal: armed.signal });
+    return { offset, placed: () => placed };
+}
+/** A right-click places a collapsed caret where a primary click would, before a menu reads it.
+ *  Bound in the capture phase at the editor root, so it runs ahead of every block's own menu. */
+export function placeContextPress(selection, e) {
+    if (e.button !== 2 || selection.isCrossBlock)
+        return;
+    const surface = editingHostOf(e.target);
+    if (!surface || !isInPaddingRow(surface, e.clientX, e.clientY))
+        return;
+    // A right-click inside a range keeps it for the menu, as the browser does.
+    if (!(window.getSelection()?.isCollapsed ?? true))
+        return;
+    const offset = offsetFromViewportPoint(surface, e.clientX, e.clientY);
+    const path = findBlockPathForElement(surface);
+    if (offset !== null && path)
+        applyCollapsedCaret(surface, { path, offset });
+}
+function editingHostOf(target) {
+    let el = target instanceof HTMLElement && target.isContentEditable ? target : null;
+    while (el?.parentElement?.isContentEditable)
+        el = el.parentElement;
+    return el && !isWholeBlockInputProxy(el) ? el : null;
+}

package/dist/selection/cross-block/type-replace.d.ts

@@ -1,10 +1,8 @@
 /**
- * Cross-block type-replace: the user typed a character with a cross-block selection active.
- * Delete the range, splice the character into the surviving leaf's raw, re-parse so a marker at
- * offset 0 re-derives the kind (parity with the single-block type path). Routed through
- * commitMultiScope so a kind change mints a fresh node, ids/refs stay synced, and the op is
- * `updateContent`. A range holding its block whole has no surviving leaf and takes the
- * replace arm at the foot of the file instead.
+ * Typing a character over a cross-block range: delete the range, splice the character into the
+ * surviving leaf and reparse it, so a marker typed at offset 0 changes the kind as single-block
+ * typing does. A range holding one block whole leaves no surviving leaf, so the character
+ * replaces that block instead.
  */
 import type { CrossBlockDispatchContext } from './dispatch';
 import type { CrossBlockMutationContext } from './ops';

package/dist/selection/cross-block/type-replace.js

@@ -1,168 +1,85 @@
 /**
- * Cross-block type-replace: the user typed a character with a cross-block selection active.
- * Delete the range, splice the character into the surviving leaf's raw, re-parse so a marker at
- * offset 0 re-derives the kind (parity with the single-block type path). Routed through
- * commitMultiScope so a kind change mints a fresh node, ids/refs stay synced, and the op is
- * `updateContent`. A range holding its block whole has no surviving leaf and takes the
- * replace arm at the foot of the file instead.
+ * Typing a character over a cross-block range: delete the range, splice the character into the
+ * surviving leaf and reparse it, so a marker typed at offset 0 changes the kind as single-block
+ * typing does. A range holding one block whole leaves no surviving leaf, so the character
+ * replaces that block instead.
  */
-import { performCrossBlockDelete } from './ops';
+import { documentLineEnding } from '../../core/lines';
+import { performCrossBlockDelete, rangeUndoStep } from './ops';
 import { charOffsetOf } from '../primitives';
 import { blockCoveredWhole } from '../covered-block';
+import { coverRange, rangeCoverage } from '../range-coverage';
 import { CURSOR_END } from '../../block-component';
-import { replaceBlockAtParent } from '../../tree-operations/paste/replace-block-at-parent';
 import { parseReplacement } from '../../tree-operations/paste/replacement-parse';
-import { blockNodeAt, normalizeBodyWrite, writeOwnRaw } from '../../tree-operations/node-primitives';
-import { updateNodeContent, settledCaretTarget } from '../../tree-operations/content-write';
+import { slotReaderAt } from '../../tree-operations/list/task-paragraph';
+import { blockNodeAt } from '../../tree-operations/node-primitives';
 import { focusCollapsedCaret } from '../native-bridge';
-import { ensureUnsharedChild, ensureUnsharedNode, ensureUnsharedPath } from '../../tree-operations/unshare';
-import { rebuildUnsharedChain } from '../../tree-operations/chain-rebuild';
-import { stampStructuralChange } from '../../tree-operations/structural-change';
-import { getStateForNode } from '../../reactivity/state-registry';
-import { docPathFrom } from '../../cursor/coordinate-spaces';
-import { devWarn } from '../../dev-warn';
+import { caretTargetFor } from '../caret-target';
 export async function handleCrossBlockTypeReplace(ctx, mutCtx, typed) {
-    // A range holding its block whole leaves no leaf to splice into, so the character replaces the
-    // block in its own slot. An empty insertion has nothing to stand there and takes the delete.
-    const covered = typed
-        ? blockCoveredWhole(ctx.getDoc(), ctx.selection.anchor, ctx.selection.focus)
-        : null;
+    // A block held whole leaves no leaf to splice into, so the character takes its place; an
+    // empty insertion takes the delete, and a table held whole still clears into its cells.
+    const { anchor, focus } = ctx.selection;
+    const doc = ctx.getDoc();
+    const coverage = typed && anchor && focus ? rangeCoverage(doc, coverRange(doc, anchor, focus)) : null;
+    const covered = coverage && !coverage.grid ? blockCoveredWhole(coverage) : null;
     if (covered) {
         await replaceCoveredBlockWithText(ctx, mutCtx, typed, covered);
         return;
     }
-    const caret = await performCrossBlockDelete(mutCtx, { skipCaretRestore: true });
+    // One entry for the delete and the character.
+    await rangeUndoStep(mutCtx, () => deleteThenType(ctx, mutCtx, typed));
+}
+async function deleteThenType(ctx, mutCtx, typed) {
+    const caret = await performCrossBlockDelete(mutCtx, 'keyless', { skipCaretRestore: true });
     if (!caret)
         return;
     // All caret placements below target caret.path's top-level block; mount it once here so each
     // (the post-tick landing included) finds a live element.
     await ctx.revealPath(caret.path);
-    if (!typed) {
-        focusCollapsedCaret(ctx.getBlockElByPath, caret);
-        return;
-    }
-    const doc = ctx.getDoc();
-    const targetNode = blockNodeAt(doc, caret.path);
+    const targetNode = typed ? blockNodeAt(ctx.getDoc(), caret.path) : null;
     if (!targetNode) {
         focusCollapsedCaret(ctx.getBlockElByPath, caret);
         return;
     }
-    // `updateContent`, not `input`: symmetric with the single-block path's KIND-CHANGING branch
-    // (block-edit.ts updateBlockContent). Only that path's kind-stable branch emits the debounced
-    // `input`, which consumers read as "kind held" (components/lrd-map-gate.ts runs post-commit
-    // and cannot recover a destroyed kind). snapshot: 'skip' keeps the char in the delete's unit.
-    const scope = resolveTypedCharScope(ctx, caret.path);
-    if (!scope) {
-        focusCollapsedCaret(ctx.getBlockElByPath, caret);
-        return;
-    }
-    // resolveTypedCharScope returns the leaf's IMMEDIATE parent: every mounted container registers
-    // a BlockListState, and the document root stands in for a top-level leaf. The guard below is
-    // the enforcement belt — an unregistered ancestor would make `scope` a grandparent and splice
-    // the wrong slot, so that case degrades to a raw-only splice instead.
+    // The typed character goes through the write every keystroke takes, so a marker typed at offset
+    // 0 re-derives the kind and the container's rule escapes what it must.
     const leafIndex = caret.path[caret.path.length - 1];
-    const scopeIsImmediateParent = scope.path.length === caret.path.length - 1;
-    let settled = { change: { op: 'noop' }, textStart: 0 };
-    await ctx.controller.commitMultiScope({
-        scopes: [scope],
-        snapshot: 'skip',
-        mutate: ([scopeView]) => {
-            const sharing = scopeView.sharing;
-            const charOffset = charOffsetOf(caret, 'cross-block-type-replace:slice');
-            if (!scopeIsImmediateParent) {
-                devWarn('cross-block-type-replace', `scope [${scope.path.join(',')}] is not the immediate parent of leaf [${caret.path.join(',')}]; splicing raw without kind re-derivation`);
-                const chain = ensureUnsharedPath(doc, caret.path, sharing);
-                const owned = chain[chain.length - 1] ?? ensureUnsharedNode(targetNode, sharing);
-                // Degraded, but still a body write: this arm splices raw with no reparse, so the
-                // container's rule and the leaf's own are all that stand between a typed `>` or
-                // backtick and a terminator line.
-                writeOwnRaw(owned, normalizeBodyWrite(chain[chain.length - 2]?.kind, owned.raw.slice(0, charOffset) + typed + owned.raw.slice(charOffset)), ctx.grammar);
-                rebuildUnsharedChain(doc, chain, sharing, null, ctx.grammar);
-                return [{ op: 'noop' }];
-            }
-            // Re-parse the spliced leaf inside the commit so a marker at offset 0 re-derives the
-            // kind (updateNodeContent mints a fresh node on a kind change). A single character
-            // never introduces a blank line, so the multi-block replacement arm is unreachable.
-            const owned = ensureUnsharedChild(scopeView.node, leafIndex, sharing);
-            const newText = owned.raw.slice(0, charOffset) + typed + owned.raw.slice(charOffset);
-            settled = updateNodeContent({ children: scopeView.children, ownerKind: scopeView.node.kind, owner: scopeView.node }, leafIndex, newText, ctx.grammar, sharing);
-            stampStructuralChange(scopeView.children, settled.change, sharing);
-            return [settled.change];
-        },
-        op: {
-            kind: 'updateContent',
-            // `op` is evaluated ahead of `mutate` and the splice only inserts, so the post-commit
-            // length is already fixed. Read for the event detail alone.
-            detail: { length: targetNode.raw.length + typed.length },
-            eventPath: docPathFrom(caret.path)
-        },
-        afterTick: async () => {
-            // A settle that absorbed the join above left the predecessor holding the typed bytes,
-            // so the leaf slot the delete resolved is no longer where the caret belongs.
-            const siblings = scopeChildrenOf(ctx, scope.path);
-            const target = settledCaretTarget(settled, leafIndex, caret.offset + typed.length, siblings);
-            const path = [...caret.path.slice(0, -1), target.index];
-            // The reveal above mounted the slot the delete resolved; a fold can land the caret on
-            // one the render window never held.
-            if (target.index !== leafIndex)
-                await ctx.revealPath(path);
-            focusCollapsedCaret(ctx.getBlockElByPath, { path, offset: target.offset });
+    const charOffset = charOffsetOf(caret, 'cross-block-type-replace:slice');
+    const text = targetNode.raw.slice(0, charOffset) + typed + targetNode.raw.slice(charOffset);
+    const written = await ctx.pasteCoordinator.commitLeafText(caret.path, text, {
+        caret: charOffset + typed.length,
+        snapshotOffset: caret.offset,
+        afterTick: async (landed) => {
+            const at = [...landed.caret.path];
+            // A fix-up that merged the leaf into the block above left that block holding the typed
+            // bytes, somewhere the mount above may never have drawn.
+            if (at[at.length - 1] !== leafIndex)
+                await ctx.revealPath(at);
+            const leaf = caretTargetFor(ctx.getDoc(), landed.caret);
+            focusCollapsedCaret(ctx.getBlockElByPath, leaf
+                ? { path: [...leaf.leafPath], offset: leaf.offset }
+                : { path: at, offset: landed.caret.offset });
         }
     });
+    if (!written.wrote)
+        focusCollapsedCaret(ctx.getBlockElByPath, caret);
 }
-/**
- * Replace the covered block with the parse of the typed character, at the block's parent
- * position: the same door the covered-block paste takes, so both gestures splice at one scope
- * and land one undo entry. Re-parsed rather than spliced, so a marker typed over the block
- * derives its kind exactly as the single-block type path does.
- */
+/** Parses the typed character in place of the covered block, through the same call the
+ *  covered-block paste makes, so a marker typed over the block derives its kind as typing does. */
 async function replaceCoveredBlockWithText(ctx, mutCtx, typed, blockPath) {
     const doc = ctx.getDoc();
     const covered = blockNodeAt(doc, blockPath);
     if (!covered)
         return;
-    const parsed = parseReplacement(covered, typed, ctx.grammar);
+    const read = slotReaderAt(doc, blockPath, ctx.reading.grammar);
+    const parsed = parseReplacement(covered, typed, documentLineEnding(doc), read);
     if (!parsed)
         return;
-    mutCtx.pushUndoSnapshot();
-    ctx.selection.collapse();
-    await replaceBlockAtParent({
-        doc,
-        blockPath,
-        replacement: parsed.replacement,
-        controller: ctx.pasteCoordinator,
-        undoEntry: 'join',
-        focusReplacementIndex: parsed.replacement.length - 1,
-        focusOffset: CURSOR_END,
-        source: 'cross-block-covered-block',
-        ...(ctx.grammar ? { grammar: ctx.grammar } : {})
+    // Opened before the collapse, so the entry holds the range rather than the caret it leaves.
+    await rangeUndoStep(mutCtx, async () => {
+        ctx.selection.collapse();
+        await ctx.pasteCoordinator.replaceBlock(blockPath, parsed.replacement, { replacementIndex: parsed.replacement.length - 1, offset: CURSOR_END }, 
+        // The range's undo step records the selection, so this offset is never read.
+        { source: 'cross-block-covered-block', snapshotOffset: 0 });
     });
 }
-/** The scope's children, re-read after the commit: the ceremony replaces the node it published. */
-function scopeChildrenOf(ctx, scopePath) {
-    const doc = ctx.getDoc();
-    if (scopePath.length === 0)
-        return doc.children;
-    return blockNodeAt(doc, scopePath)?.children ?? [];
-}
-/**
- * The smallest commit scope covering the typed-char target: doc scope for a top-level leaf,
- * nearest container ancestor with a registered BlockListState otherwise. Null when none is
- * mounted, and the caller falls back to a direct caret restore.
- */
-function resolveTypedCharScope(ctx, leafPath) {
-    if (leafPath.length === 1) {
-        return ctx.controller.getDocScope();
-    }
-    const doc = ctx.getDoc();
-    for (let depth = leafPath.length - 1; depth >= 1; depth--) {
-        const ancestorPath = leafPath.slice(0, depth);
-        const ancestor = blockNodeAt(doc, ancestorPath);
-        if (!ancestor)
-            continue;
-        const state = getStateForNode(ancestor);
-        if (state)
-            return { node: ancestor, state, path: ancestorPath };
-    }
-    return null;
-}

package/dist/selection/dead-space-caret.d.ts

@@ -1,52 +1,41 @@
 /**
- * Caret placement from a viewport point: the dead-space click (padding beside a block, the area
- * below the last one) and the public `placeCaretAtPoint`, which shares the walk under the gesture
- * guards. A y belonging to no band may name an eligible gap boundary; otherwise the point clamps
- * into the nearest mounted block's box (`nearest-block.ts`) and resolves there, no kind named.
- * Only what is mounted is measured, so "below the last block" resolves against the CST (VR-6).
+ * Places the caret from a viewport point, for a click in the editor's dead space (the padding
+ * beside a block, the area below the last one) and the public `placeCaretAtPoint` alike. A point
+ * between two blocks may become a gap caret; otherwise it clamps into the nearest mounted block
+ * and descends to the child level with it. Only mounted blocks are measured.
  */
 import { type BlockComponent } from '../block-component';
 import { type GapStopScope } from './gap-caret';
-import type { SelectionEndpoint } from './primitives';
+import type { CaretPosition, SelectionEndpoint } from './primitives';
+import type { LandingOutcome } from './caret-landing';
 export interface DeadSpaceCaretDeps {
     getBlockComponent(path: number[]): BlockComponent | null;
-    /**
-     * The shared pointerdown preamble (`cross-block/pointer.ts`), pre-bound to a non-shift press:
-     * a dead-space click must end a live cross-block range exactly as a click on a block does.
-     */
+    /** The pointerdown reset for a plain click: a dead-space click must end a live cross-block
+     *  range exactly as a click on a block does. */
     resetSelectionForClick(): void;
-    /** The gap-caret arrival's reads; a point landing between two root bands parks there. */
+    /** What a gap caret needs; a point between two root-level blocks lands there. */
     gapScope: GapStopScope;
     /** The document's own last top-level index, from the CST. The last mounted band is the
      *  document's last block only while nothing is windowed out below it. */
     lastBlockIndex(): number;
-    /** Reveal (mount) a top-level block and hand back its component — the same road undo's
-     *  restore uses. */
-    revealBlock(index: number): Promise<BlockComponent | null>;
+    /** The caret landing's `land`: mounts the block and puts the caret there as an arrival. */
+    land(pos: CaretPosition): Promise<LandingOutcome>;
 }
 export interface DeadSpaceCaret {
     /** `root` is the element the installing effect captured, not a live binding. */
     notePress(root: HTMLElement, event: MouseEvent): void;
-    /** Returns whether the click was claimed; false leaves every existing click semantic alone. */
+    /** Returns whether the click was handled; false leaves the click to its usual handlers. */
     handleClick(root: HTMLElement, event: MouseEvent): boolean;
-    /**
-     * The landing walk with no gesture discrimination in front of it, for a caller that has
-     * already decided to answer the point — the public `placeCaretAtPoint`. Shared rather than
-     * reimplemented, so the two can never resolve one point differently. True means the point
-     * was claimed; a point past a windowed-out tail claims it and lands after the reveal.
-     */
+    /** The placement without the click checks, shared with the public `placeCaretAtPoint` so the
+     *  two never resolve a point differently; a point below an unmounted tail lands on mount. */
     placeAtPoint(root: HTMLElement, x: number, y: number): boolean;
-    /** Whether a press target is the editor's dead space (the root, or a block list inside it). */
+    /** Whether a click target is the editor's dead space (the root, or a block list inside it). */
     isDeadSpaceTarget(root: HTMLElement, target: EventTarget | null): boolean;
-    /**
-     * The endpoint a drag STARTING in dead space (or on a block's rendered face) anchors at: the
-     * landing a click there would take, without taking it. A character surface anchors at that
-     * offset; a rendered leaf (an equation) anchors as a WHOLE block, so the range takes it entire
-     * whichever way the drag goes. A coordinate-addressed kind (a table) anchors nothing.
-     */
+    /** Where a click at the point would land, as a drag anchor: a text offset, or the whole block
+     *  (a table, an equation) so the range takes all of it whichever way the drag goes. */
     anchorAtPoint(root: HTMLElement, x: number, y: number): SelectionEndpoint | null;
-    /** The path of the block a press names, the point clamped into the nearest band: what the
-     *  click ladder selects in for a press on the margin or a block's own box. */
+    /** The path of the block nearest a click, the point clamped into its box: what a click on
+     *  the margin or on a block's own box selects in. */
     blockPathNearPoint(root: HTMLElement, x: number, y: number): number[] | null;
 }
 export declare function createDeadSpaceCaret(deps: DeadSpaceCaretDeps): DeadSpaceCaret;