@voithos-labs/aragonite 0.10.3 → 0.10.4

package/dist/selection/multi-click.js

@@ -0,0 +1,203 @@
+/**
+ * The click ladder past the caret: the second press of a run selects the word under it, the
+ * third the surface's content, and a drag from either extends at that granularity. Owned from
+ * the second press, so the browser paints nothing of its own: its word rule is per platform,
+ * its walk enters atomic islands, and a marker here never joins a word.
+ */
+import { ambientLengthOf } from '../ambient/ambient-dom';
+import { asDomTextOffset, asRawOffset, toClampedRawOffset, toDomTextOffset } from '../cursor/coordinate-spaces';
+import { caretOffsetAtPoint } from '../cursor/point-offset';
+import { containerDomTextLength, maskedWalkText } from '../cursor/widget-offset';
+import { isWholeBlockInputProxy } from '../editor-actions/whole-block-focus-surface';
+import { installDragListener } from './drag-pointer';
+import { applySingleBlockRange, applySurfaceContentRange } from './native-bridge';
+import { blockNearPoint } from './nearest-block';
+// ── The word rule ────────────────────────────────────────────────────────────
+let segmenter;
+function wordSegmenter() {
+    if (segmenter === undefined) {
+        segmenter =
+            typeof Intl.Segmenter === 'function'
+                ? new Intl.Segmenter(undefined, { granularity: 'word' })
+                : null;
+    }
+    return segmenter;
+}
+/**
+ * [start, end) of the segment at `offset` in `text`: the word ending there when it is one, else
+ * the segment starting there (whitespace or punctuation, as the engine would take). Null on
+ * empty text, or on a platform with no segmenter.
+ */
+export function wordSpanAt(text, offset) {
+    const seg = wordSegmenter();
+    if (!seg || text.length === 0)
+        return null;
+    const segments = seg.segment(text);
+    const at = Math.max(0, Math.min(offset, text.length));
+    const left = at > 0 ? segments.containing(at - 1) : undefined;
+    const right = at < text.length ? segments.containing(at) : undefined;
+    if (left && right && left.index === right.index)
+        return spanOf(left);
+    if (left?.isWordLike)
+        return spanOf(left);
+    const pick = right ?? left;
+    return pick ? spanOf(pick) : null;
+}
+function spanOf(segment) {
+    return { start: segment.index, end: segment.index + segment.segment.length };
+}
+/** The raw span `granularity` takes around a raw offset in `surface`; null where the word rule
+ *  has nothing to read. */
+export function spanAround(surface, granularity, rawOffset) {
+    const ambient = ambientLengthOf(surface);
+    if (granularity === 'block') {
+        return { start: 0, end: toClampedRawOffset(containerDomTextLength(surface), ambient) };
+    }
+    const walk = toDomTextOffset(asRawOffset(rawOffset), ambient);
+    const span = wordSpanAt(maskedWalkText(surface), walk);
+    if (!span)
+        return null;
+    return {
+        start: toClampedRawOffset(asDomTextOffset(span.start), ambient),
+        end: toClampedRawOffset(asDomTextOffset(span.end), ambient)
+    };
+}
+/** The rung a press's click count reaches; the run stays at the block rung past three. */
+export function granularityForClickCount(clickCount) {
+    if (clickCount === 2)
+        return 'word';
+    return clickCount >= 3 ? 'block' : null;
+}
+/**
+ * Root listeners for the ladder. The count rides the mousedown (a pointer event carries none),
+ * and the drag rides the pointerdown of the same press, so both are heard. The mousedown is
+ * cancelled, never the pointerdown (that would silence the click), and so is the mouseup: the
+ * browser's release seats a caret at a press that landed off a glyph, over the range just painted.
+ */
+export function installMultiClickSelect(deps) {
+    let lastPointerDown = null;
+    let claimed = false;
+    const onPointerDown = (e) => {
+        lastPointerDown = e;
+    };
+    const onMouseUp = (e) => {
+        if (claimed)
+            e.preventDefault();
+    };
+    const onMouseDown = (e) => {
+        claimed = false;
+        const granularity = granularityForClickCount(e.detail);
+        if (!granularity || e.button !== 0 || e.shiftKey || e.ctrlKey || e.metaKey || e.altKey)
+            return;
+        if (pressesInlineWidget(e.target))
+            return;
+        const press = pressedSurface(deps, e);
+        if (!press)
+            return;
+        const anchorSpan = selectAtPoint(press.surface, granularity, e.clientX, e.clientY);
+        if (!anchorSpan)
+            return;
+        e.preventDefault();
+        claimed = true;
+        const anchor = press.anchor ?? blockNearPoint(deps.editorRoot, e.clientX, e.clientY)?.endpointHere();
+        if (!anchor || !lastPointerDown)
+            return;
+        installDragListener({
+            editorRoot: deps.editorRoot,
+            scrollContainer: deps.getScrollContainer(),
+            selection: deps.selection,
+            getBlockElByPath: deps.getBlockElByPath,
+            lifetimeSignal: deps.lifetimeSignal,
+            granularity: createGranularity(deps.getBlockElByPath, press.surface, granularity, anchorSpan)
+        }, anchor, lastPointerDown);
+    };
+    deps.editorRoot.addEventListener('pointerdown', onPointerDown);
+    deps.editorRoot.addEventListener('mousedown', onMouseDown);
+    deps.editorRoot.addEventListener('mouseup', onMouseUp);
+    return () => {
+        deps.editorRoot.removeEventListener('pointerdown', onPointerDown);
+        deps.editorRoot.removeEventListener('mousedown', onMouseDown);
+        deps.editorRoot.removeEventListener('mouseup', onMouseUp);
+    };
+}
+/** The surface a press selects in: the editable under it, else the nearest block's, the way a
+ *  single click in the margin lands there. A block with no text surface is nobody's word. */
+function pressedSurface(deps, e) {
+    // Up through an island inside the editable (a list's `- ` prefix) to the surface itself.
+    const own = surfaceOf(e.target);
+    if (own)
+        return isWholeBlockInputProxy(own) ? null : { surface: own, anchor: null };
+    const path = deps.marginBlockAt(e.target, e.clientX, e.clientY);
+    const block = path && deps.getBlockElByPath(path);
+    if (!block)
+        return null;
+    // A container's own box (a quote's gutter) selects in the leaf nearest the press, the way a
+    // click beside a line lands in that line.
+    const surface = block.contentEditable === 'true' ? block : nearestSurfaceIn(block, e.clientY);
+    const surfacePath = surface && pathOfSurface(surface);
+    const offset = surface && caretOffsetAtPoint(surface, e.clientX, e.clientY);
+    if (!surface)
+        return null;
+    return { surface, anchor: surfacePath && offset !== null ? { path: surfacePath, offset } : null };
+}
+function nearestSurfaceIn(block, clientY) {
+    let best = null;
+    let bestDistance = Infinity;
+    for (const el of block.querySelectorAll('[contenteditable="true"]')) {
+        const rect = el.getBoundingClientRect();
+        const distance = clientY < rect.top ? rect.top - clientY : Math.max(0, clientY - rect.bottom);
+        if (distance < bestDistance) {
+            best = el;
+            bestDistance = distance;
+        }
+    }
+    return best;
+}
+/** The path of the block a surface is the content of; null for a surface addressed some other
+ *  way (a table's cell), whose drag is not a char-point drag. */
+function pathOfSurface(surface) {
+    const host = surface.closest('[data-block-path]');
+    const raw = host?.getAttribute('data-block-path');
+    if (!raw || !host?.contains(surface))
+        return null;
+    const path = JSON.parse(raw);
+    return host.querySelector('[contenteditable="true"]') === surface ? path : null;
+}
+/** Paint the rung's span at the press and answer it, in raw offsets. */
+function selectAtPoint(surface, granularity, clientX, clientY) {
+    if (granularity === 'block') {
+        applySurfaceContentRange(surface);
+        return spanAround(surface, 'block', 0);
+    }
+    const offset = caretOffsetAtPoint(surface, clientX, clientY);
+    const span = offset === null ? null : spanAround(surface, 'word', offset);
+    if (!span || span.start === span.end)
+        return null;
+    applySingleBlockRange(surface, span.start, span.end);
+    return span;
+}
+function createGranularity(getBlockElByPath, surface, granularity, anchorSpan) {
+    return {
+        surface,
+        anchorSpan,
+        spanAround: (offset) => spanAround(surface, granularity, offset) ?? { start: offset, end: offset },
+        expandFocus: (point, side) => {
+            const el = point.cellCoordinate ? null : getBlockElByPath(point.path);
+            const span = el && spanAround(el, granularity, point.offset);
+            if (!span)
+                return point;
+            return { path: point.path.slice(), offset: side === 'after' ? span.end : span.start };
+        }
+    };
+}
+/** A press on an inline widget is that widget's own gesture (a footnote's double-click takes
+ *  its whole token), so the ladder leaves it alone. */
+function pressesInlineWidget(target) {
+    return target instanceof Element && target.closest('[data-inline-widget]') !== null;
+}
+function surfaceOf(target) {
+    let el = target instanceof HTMLElement ? target : null;
+    while (el && el.contentEditable !== 'true')
+        el = el.parentElement;
+    return el;
+}

package/dist/selection/native-bridge.d.ts

@@ -25,6 +25,9 @@ export declare function applyCollapsedCaret(blockEl: HTMLElement, point: Selecti
  * Returns whether an element was found; a missing target is a no-op.
  */
 export declare function focusCollapsedCaret(getBlockElByPath: (path: number[]) => HTMLElement | null, point: SelectionPoint): boolean;
+/** Select a surface's content whole, past its ambient prefix: the first-press Ctrl+A range and
+ *  the triple-click one. */
+export declare function applySurfaceContentRange(el: HTMLElement): void;
 export declare function applySingleBlockRange(blockEl: HTMLElement, startOffset: number, endOffset: number): void;
 export declare function clearNativeSelection(): void;
 /**

package/dist/selection/native-bridge.js

@@ -4,9 +4,10 @@
  * DOM→raw conversion subtracts the length of a leading ambient marker span, whose textContent
  * counts toward DOM offsets but not raw.
  */
-import { asRawOffset, toClampedRawOffset, toDomTextOffset } from '../cursor/coordinate-spaces';
+import { asDomTextOffset, asRawOffset, toClampedRawOffset, toDomTextOffset } from '../cursor/coordinate-spaces';
+import { createRangeFromOffsets } from '../cursor/content-offsets';
 import { clampToLandableRaw, createRangeAtDomTextOffsets, domTextOffsetAtNode } from '../cursor/widget-offset';
-import { ambientLengthOf, placeCaretAfterAmbientSpan } from '../ambient/ambient-dom';
+import { ambientLengthOf, ambientSpanOf, placeCaretAfterAmbientSpan } from '../ambient/ambient-dom';
 // ── Read native → SelectionPoint ────────────────────────────────────────────
 /**
  * Read the collapsed caret inside `blockEl` into a raw-semantic SelectionPoint.
@@ -64,12 +65,40 @@ export function focusCollapsedCaret(getBlockElByPath, point) {
     blockEl.focus();
     return true;
 }
+/** Select a surface's content whole, past its ambient prefix: the first-press Ctrl+A range and
+ *  the triple-click one. */
+export function applySurfaceContentRange(el) {
+    const ambient = ambientSpanOf(el);
+    const ambientLen = ambient?.textContent?.length ?? 0;
+    const textLen = el.textContent?.length ?? 0;
+    if (ambient && textLen > ambientLen) {
+        if (!placeCaretAfterAmbientSpan(el))
+            return;
+        // textLen counts the full textContent (marker included) — a DomTextOffset by construction.
+        const endRange = createRangeFromOffsets(el, asDomTextOffset(textLen), asDomTextOffset(textLen));
+        if (endRange) {
+            window.getSelection()?.extend(endRange.endContainer, endRange.endOffset);
+        }
+        return;
+    }
+    const range = document.createRange();
+    range.selectNodeContents(el);
+    const sel = window.getSelection();
+    sel?.removeAllRanges();
+    sel?.addRange(range);
+}
 export function applySingleBlockRange(blockEl, startOffset, endOffset) {
     const ambient = ambientLengthOf(blockEl);
     const range = createRangeAtDomTextOffsets(blockEl, toDomTextOffset(asRawOffset(startOffset), ambient), toDomTextOffset(asRawOffset(endOffset), ambient));
     if (!range)
         return;
     const sel = window.getSelection();
+    // A start at raw 0 under an ambient marker goes AFTER the island, as a caret does: Chromium
+    // drops a range that opens inside its contenteditable="false".
+    if (ambient > 0 && startOffset <= 0 && placeCaretAfterAmbientSpan(blockEl)) {
+        sel?.extend(range.endContainer, range.endOffset);
+        return;
+    }
     sel?.removeAllRanges();
     sel?.addRange(range);
 }

package/dist/selection/path-lookup.d.ts

@@ -27,6 +27,14 @@ export declare function findBlockPathForElement(el: Element | null): number[] |
  * cell grid; addresses the grid by selector contract (`data-table-row-idx`, `role="cell"`).
  */
 export declare function findCellPathForElement(el: Element | null): number[] | null;
-/** The path of the editing SURFACE `el` sits in — the enclosing cell where there is one, else
- *  the enclosing block. The pairing {@link findCellPathForElement} says every producer owes. */
+/** The editing SURFACE `el` sits in: the enclosing cell where there is one, else the enclosing
+ *  block, and which of the two answered — a caller whose bytes live at a different scope for a
+ *  cell reads the flag rather than re-deriving the pairing. */
+export interface EditingSurface {
+    path: number[];
+    inCell: boolean;
+}
+/** The pairing {@link findCellPathForElement} says every producer owes, in one place. */
+export declare function findSurfaceForElement(el: Element | null): EditingSurface | null;
+/** {@link findSurfaceForElement} for a caller that needs only the path. */
 export declare function findSurfacePathForElement(el: Element | null): number[] | null;

package/dist/selection/path-lookup.js

@@ -125,8 +125,15 @@ export function findCellPathForElement(el) {
         return null;
     return [...tablePath, rowIdx, colIdx];
 }
-/** The path of the editing SURFACE `el` sits in — the enclosing cell where there is one, else
- *  the enclosing block. The pairing {@link findCellPathForElement} says every producer owes. */
+/** The pairing {@link findCellPathForElement} says every producer owes, in one place. */
+export function findSurfaceForElement(el) {
+    const cellPath = findCellPathForElement(el);
+    if (cellPath)
+        return { path: cellPath, inCell: true };
+    const blockPath = findBlockPathForElement(el);
+    return blockPath ? { path: blockPath, inCell: false } : null;
+}
+/** {@link findSurfaceForElement} for a caller that needs only the path. */
 export function findSurfacePathForElement(el) {
-    return findCellPathForElement(el) ?? findBlockPathForElement(el);
+    return findSurfaceForElement(el)?.path ?? null;
 }

package/dist/selection/pointer-gesture.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The door a widget declares over an element whose pointer drags belong to its own gesture (a
+ * diagram's pan, a canvas's brush): the editor's pointer arms decline a press inside it, so the
+ * gesture never doubles as a block range. A declaration, not a `stopPropagation`: pointer events
+ * are delegated at the app root, so a component's own handler runs after the editor's.
+ */
+/** Declared on the gesture surface itself; any descendant press counts. */
+export declare const POINTER_GESTURE_ATTR = "data-pointer-gesture";
+export declare function claimsPointerGesture(target: EventTarget | null): boolean;

package/dist/selection/pointer-gesture.js

@@ -0,0 +1,11 @@
+/**
+ * The door a widget declares over an element whose pointer drags belong to its own gesture (a
+ * diagram's pan, a canvas's brush): the editor's pointer arms decline a press inside it, so the
+ * gesture never doubles as a block range. A declaration, not a `stopPropagation`: pointer events
+ * are delegated at the app root, so a component's own handler runs after the editor's.
+ */
+/** Declared on the gesture surface itself; any descendant press counts. */
+export const POINTER_GESTURE_ATTR = 'data-pointer-gesture';
+export function claimsPointerGesture(target) {
+    return target instanceof Element && target.closest(`[${POINTER_GESTURE_ATTR}]`) !== null;
+}

package/dist/selection/primitives.d.ts

@@ -73,3 +73,10 @@ export type BlockSelectionClass = 'outside' | 'start' | 'middle' | 'end' | 'sing
  * tells the caller to delegate to the browser instead of painting.
  */
 export declare function classifyBlockForSelection(path: number[], selection: EditorSelection): BlockSelectionClass;
+/**
+ * Whether this block paints the range over its whole box: the range holds its entire subtree and
+ * no ancestor's box already covers it, or it is the whole unit a single-block range holds. Chrome
+ * a container derives from its markers (a GitHub alert's badge) has no child host to paint it, so
+ * the covering block takes the box in one piece and its children paint nothing.
+ */
+export declare function blockPaintsWholeBox(path: readonly number[], selection: EditorSelection, wholeUnitPath: readonly number[] | null): boolean;

package/dist/selection/primitives.js

@@ -3,7 +3,7 @@
  * classification, the delete-commit snapshot rule. No DOM, no state. Path-level predicates
  * live in `./path-math`.
  */
-import { comparePaths, isPathBetween, pathHasPrefix } from './path-math';
+import { comparePaths, isPathBetween, isStrictAncestorOf, pathHasPrefix, pathsEqual } from './path-math';
 import { asCellIndex, asRawOffset, docPathFrom } from '../cursor/coordinate-spaces';
 import { devWarn } from '../dev-warn';
 export function isWholeBlockEndpoint(endpoint) {
@@ -89,3 +89,21 @@ export function classifyBlockForSelection(path, selection) {
         return 'middle';
     return 'outside';
 }
+/**
+ * Whether this block paints the range over its whole box: the range holds its entire subtree and
+ * no ancestor's box already covers it, or it is the whole unit a single-block range holds. Chrome
+ * a container derives from its markers (a GitHub alert's badge) has no child host to paint it, so
+ * the covering block takes the box in one piece and its children paint nothing.
+ */
+export function blockPaintsWholeBox(path, selection, wholeUnitPath) {
+    if (wholeUnitPath)
+        return pathsEqual(path, wholeUnitPath);
+    const { start, end } = normalize(selection);
+    return (holdsSubtree(path, start.path, end.path) &&
+        !holdsSubtree(path.slice(0, -1), start.path, end.path));
+}
+/** The range holds this block's whole subtree: inside it in document order, and not an ancestor
+ *  of the end endpoint, whose own descendants the range cuts through. */
+function holdsSubtree(path, start, end) {
+    return isPathBetween(path, start, end) && !isStrictAncestorOf(path, end);
+}

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

@@ -31,3 +31,7 @@ export interface RangeDeleteResult {
  * post-unshare references. Caller pre-normalizes and keeps endpoints on focusable blocks.
  */
 export declare function rangeDelete(doc: Document, start: SelectionPoint, end: SelectionPoint, sharing: SharingState, grammar: GrammarView | undefined, presentationMode: PresentationMode | undefined, linkRef: InlineResolverRef | undefined): RangeDeleteResult;
+/** The container prefix the survivor renders under, so the join seam can read its candidate back
+ *  through it (live-mode.md § 4.5). An ambient marker rides the container's FIRST child only, the
+ *  way `BlockList` forwards it, and a list item is the one built-in container that paints one. */
+export declare function containerAmbientPrefix(doc: Document, path: readonly number[]): string;

package/dist/selection/range-delete.js

@@ -138,7 +138,7 @@ export function rangeDelete(doc, start, end, sharing, grammar, presentationMode,
 /** The container prefix the survivor renders under, so the join seam can read its candidate back
  *  through it (live-mode.md § 4.5). An ambient marker rides the container's FIRST child only, the
  *  way `BlockList` forwards it, and a list item is the one built-in container that paints one. */
-function containerAmbientPrefix(doc, path) {
+export function containerAmbientPrefix(doc, path) {
     if (path.length < 2 || path[path.length - 1] !== 0)
         return '';
     const parent = blockNodeAt(doc, path.slice(0, -1));

package/dist/selection/selection-drop.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Dragging a selection and dropping it. The browser's own version is two native edits committed
+ * apart — `deleteByDrag` on the source, `insertFromDrop` on the target — so undo takes two presses
+ * over a document that lost bytes in between, and inside one block the source commit rebuilds the
+ * surface under the drop. Owned here instead: one snapshot over two raw writes, which splice
+ * nothing, so no path moves under the second.
+ */
+import type { Document } from '../core/nodes';
+import type { GrammarView } from '../schema/block-openers';
+import type { LinkReferenceResolverRef, PresentationModeGetter } from '../editor-keys';
+import type { PluginActivation } from '../schema/plugin-activation';
+import type { CommitController } from '../action-contracts';
+import type { PasteCommitCoordinator } from '../tree-operations/paste/paste-deps';
+import { type EditorEvents } from '../editor-events';
+export interface SelectionDropDeps {
+    editorRoot: HTMLElement;
+    getDoc(): Document;
+    controller: CommitController;
+    coordinator: PasteCommitCoordinator;
+    getPresentationMode: PresentationModeGetter | undefined;
+    linkRef: LinkReferenceResolverRef | undefined;
+    grammar: GrammarView | undefined;
+    activePlugins: PluginActivation | undefined;
+    /** The instance event surface: a ceremony that throws mid-move has nowhere else to report. */
+    events: EditorEvents;
+    isReadOnly(): boolean;
+}
+export declare function installSelectionDrop(deps: SelectionDropDeps): () => void;
+/** Where a splice of `delta` blocks at `at` inside `parent` leaves `target`: what the drop's
+ *  second write addresses once the first one's reparse changed its slot's block count. */
+export declare function shiftPathAfterSplice(target: number[], parent: number[], at: number, delta: number): number[];
+/** Where a drop at `offset` lands once `[start, end)` left the same block, `shrunkBy` bytes
+ *  shorter than the range was wide once the join seam cleaned up. Null inside the range. */
+export declare function dropOffsetAfterCut(offset: number, start: number, end: number, shrunkBy: number): number | null;