@voithos-labs/aragonite 0.10.2 → 0.10.4

package/dist/components/blocks/text/TextEditableBlock.svelte

@@ -33,19 +33,21 @@
 	} from '../../../schema/inline-construct-policy';
 	import {
 		cycleHeading,
+		demoteEmptyAtxHeading,
 		demoteToParagraph,
 		insertHardBreak,
 		insertLiteralTab,
 		type TextEditResult
 	} from './text-keydown';
 	import { tryGetBlockKindDescriptor } from '../../../schema/block-kind-descriptor';
-	import { blockNodeAt } from '../../../tree-operations/node-ops';
+	import { blockNodeAt } from '../../../tree-operations/node-primitives';
 	import { createTextClipboard } from './text-clipboard';
 	import { createTextRender } from './text-render';
 	import { createWidgetInteraction } from './widget-interaction';
-	import { createEdgePolicyDispatch } from './edge-policy-dispatch';
+	import { createEdgePolicyDispatch, keepsBlockKind } from './edge-policy-dispatch';
 	import { hidesStructuralSuffix } from './hidden-suffix';
 	import { applyLiveRangeEdit, resolveSelectionEdit } from './live-selection-edit';
+	import { applyDelimiterAutoPair } from './delimiter-autopair';
 	import { createCompositionSeat } from './composition-seat';
 	import { createConstructReveal } from './construct-reveal';
 	import { assertInvariant } from '../../../assert';
@@ -56,7 +58,11 @@
 		handleSharedKeydown,
 		handleSharedBeforeInput
 	} from '../../../selection/shared-keydown';
-	import { createEditableSurface, consumePendingRestore } from '../editable-surface';
+	import {
+		createEditableSurface,
+		consumePendingRestore,
+		withKeydownVerdict
+	} from '../editable-surface';
 	import { wireSurfaceContexts, useParkFocusOnUnmount } from '../surface-wiring.svelte';
 	import {
 		domTextOffsetAtNode,
@@ -76,6 +82,7 @@
 	import { createAmbientCursorIO } from '../../../ambient/ambient-cursor';
 	import { type CommandId } from '../../../schema/commands';
 	import { reorderRunCommand } from '../../../editor-actions/reorder-action';
+	import { planTypedCompletion } from '../../../editor-actions/enter-completion';
 	import {
 		perfEnabled,
 		recordBlockRender,
@@ -111,6 +118,12 @@
 	const ambientPrefixText = $derived(
 		typeof ambientPrefix === 'string' ? ambientPrefix : ambientPrefix.text
 	);
+	// The hanging indent is the prefix's painted width: its text width by default, or what a
+	// prefix painting itself as chrome (the task box) declares.
+	const ambientIndent = $derived(
+		(typeof ambientPrefix === 'string' ? undefined : ambientPrefix.indent) ??
+			`${ambientPrefixText.length}ch`
+	);
 
 	const wiring = wireSurfaceContexts();
 	const {
@@ -361,6 +374,7 @@
 			widgetInteraction.enterWidget(widget, fromTrailingEdge),
 		isReading: () => readOnly,
 		getEdgeAffinity: () => edgeAffinity.get(),
+		noteOutside: edgeAffinity.noteExtreme,
 		pendingMarks,
 		installedAs: 'block'
 	});
@@ -668,9 +682,9 @@
 			// Only while this block still owns focus: a blur-commit also arms a pending
 			// offset, and restoring would yank the selection back into the blurred block.
 			// The clear runs regardless, so a skipped restore is dropped, never re-armed.
-			const applied = consumePendingRestore(el ?? null, pendingCursorOffset, (offset) =>
-				cursor.setRaw(asRawOffset(offset))
-			);
+			const applied = consumePendingRestore(el ?? null, pendingCursorOffset, (offset) => {
+				if (!widgetInteraction.revealInterior(offset)) cursor.setRaw(asRawOffset(offset));
+			});
 			tracePendingCursorConsume(pendingCursorOffset, applied);
 			pendingCursorOffset = null;
 		}
@@ -815,6 +829,8 @@
 		if (wiring.dispatchChord(e, { kind: node.kind, runCommand })) return;
 	}
 
+	const onKeyDownTraced = withKeydownVerdict(onKeyDown);
+
 	/**
 	 * A native ranged edit inside ONE block, in a mode that paints no delimiter: the engine would
 	 * write the runs the range crossed literally, so the edit goes through the join seam instead.
@@ -837,9 +853,33 @@
 		);
 	}
 
+	// The write takes the ranged edit's road above, so the surface repaints once with the caret
+	// inside the pair. During a reveal the caret indexes the DOM text, which has outrun `node.raw`.
+	function handleDelimiterAutoPair(e: InputEvent): boolean {
+		return applyDelimiterAutoPair(e, {
+			text: () => (widgetInteraction.isRevealing() ? readRawText() : getDisplayText()),
+			content: () => getContentRange(node),
+			caret: () => cursor.getRaw(),
+			hasSelection: () => cursor.getRawSelection() !== null,
+			isRevealing: widgetInteraction.isRevealing,
+			foldReveal: () => widgetInteraction.foldRevealBeforeMutation(),
+			markersPaint: () => paintsFocusedMarkers(presentationMode),
+			setCaret: (offset) => cursor.setRaw(asRawOffset(offset)),
+			seatOutside: edgeAffinity.noteExtreme,
+			completesLine: (caret) => planTypedCompletion(node, caret) !== null,
+			keepsBlockKind: (text) => keepsBlockKind(node, text),
+			write: (text, caretBefore, caretAfter) => {
+				const raw = text + trailingLineEnding(node.raw);
+				void blockEdit.updateBlockContent(index, raw, caretBefore, caretAfter);
+				setPendingCursorOffset(caretAfter, 'delimiter-autopair');
+			}
+		});
+	}
+
 	async function onBeforeInput(e: InputEvent): Promise<void> {
 		if (await handleSharedBeforeInput(e, sharedCtx)) return;
 		if (handleLiveSelectionEdit(e)) return;
+		if (handleDelimiterAutoPair(e)) return;
 		// Soft-keyboard/IME insertLineBreak slipped past onKeyDown — swallow; Shift+Enter there owns hard breaks.
 		if (e.inputType === 'insertLineBreak') {
 			e.preventDefault();
@@ -868,6 +908,13 @@
 		// Persist a revealed source edit before the caret is gone.
 		widgetInteraction.commitRevealOnBlur();
 		lastSnapTargetOffset = null;
+		demoteEmptyHeadingOnBlur();
+	}
+
+	function demoteEmptyHeadingOnBlur(): void {
+		if (readOnly || node.kind !== 'heading' || editableSurface.isDetached()) return;
+		const demoted = demoteEmptyAtxHeading(node.raw, getContentRange(node));
+		if (demoted) void blockEdit.updateBlockContent(index, demoted.newRaw, 0);
 	}
 
 	function onClick(e: MouseEvent): void {
@@ -933,10 +980,10 @@
 	contenteditable={readOnly ? 'false' : 'true'}
 	aria-readonly={readOnly ? 'true' : undefined}
 	role="textbox"
-	style:text-indent={ambientPrefixText ? `-${ambientLength}ch` : null}
-	style:padding-left={ambientPrefixText ? `${ambientLength}ch` : null}
+	style:text-indent={ambientPrefixText ? `-${ambientIndent}` : null}
+	style:padding-left={ambientPrefixText ? ambientIndent : null}
 	oninput={onInput}
-	onkeydown={onKeyDown}
+	onkeydown={onKeyDownTraced}
 	onbeforeinput={onBeforeInput}
 	oncopy={clipboardHandlers.onCopy}
 	oncut={clipboardHandlers.onCut}
@@ -986,7 +1033,7 @@
 	}
 
 	.text-editable-block.raw-block {
-		font-family: var(--font-editor, ui-monospace, monospace);
+		font-family: var(--font-code, ui-monospace, monospace);
 		font-size: 0.9em;
 		opacity: 0.85;
 	}
@@ -998,7 +1045,7 @@
 	}
 
 	.text-editable-block :global(.inline-code-content) {
-		font-family: var(--font-editor, ui-monospace, monospace);
+		font-family: var(--font-code, ui-monospace, monospace);
 		font-size: 0.9em;
 		background: var(--color-bg-secondary, rgba(128, 128, 128, 0.12));
 		border-radius: 3px;

package/dist/components/blocks/text/click-snap-guard.d.ts

@@ -2,6 +2,9 @@
 /** Caret in a real text node the reader can see: the native caret renders there, so the
  *  synthetic indicator stands down. Hidden marker text renders nothing, so it does not count. */
 export declare function caretIsInTextContent(el: HTMLElement, sel: Selection | null): boolean;
+/** A ranged selection this surface holds — the click ladder's rungs, a shift-click, a
+ *  drag-select. It is the gesture's own paint, so a click-time caret seat stands down for it. */
+export declare function surfaceHoldsRange(el: HTMLElement, sel: Selection | null): boolean;
 /** Ctrl/meta/alt held — a platform command, never an edit of the byte beside the caret. */
 export declare function hasModifier(e: KeyboardEvent): boolean;
 /** A typed character: no modifier chord, one code point. A chord is a command instead. */

package/dist/components/blocks/text/click-snap-guard.js

@@ -9,6 +9,14 @@ export function caretIsInTextContent(el, sel) {
     const node = sel.getRangeAt(0).startContainer;
     return node.nodeType === Node.TEXT_NODE && el.contains(node) && !isHiddenMarkerText(node, el);
 }
+/** A ranged selection this surface holds — the click ladder's rungs, a shift-click, a
+ *  drag-select. It is the gesture's own paint, so a click-time caret seat stands down for it. */
+export function surfaceHoldsRange(el, sel) {
+    if (!sel || sel.isCollapsed || sel.rangeCount === 0)
+        return false;
+    const range = sel.getRangeAt(0);
+    return el.contains(range.startContainer) || el.contains(range.endContainer);
+}
 /** Ctrl/meta/alt held — a platform command, never an edit of the byte beside the caret. */
 export function hasModifier(e) {
     return e.ctrlKey || e.metaKey || e.altKey;

package/dist/components/blocks/text/delimiter-autopair.d.ts

@@ -0,0 +1,71 @@
+/**
+ * A typed inline delimiter closes itself: a lone `$`, backtick, `*`, `_` or `~~` would pair with
+ * whatever matching run comes later on the line, so the keystroke lands its twin after the caret.
+ * Typing the closer over the twin steps past it, a closer typed by hand seats the next byte
+ * outside, and the empty pair drops its twin when the first body byte makes it no construct.
+ * `applyDelimiterAutoPair` is the one `beforeinput` arm every prose surface runs (G4.65).
+ */
+import { type ContentRange } from '../../../core/inline';
+export type AutoPairEdit = {
+    kind: 'write';
+    text: string;
+    caret: number;
+}
+/** The typed byte completed a construct's closer; what follows belongs outside it. */
+ | {
+    kind: 'close';
+    text: string;
+    caret: number;
+}
+/** Nothing written: the caret passes the twin. Over a construct's closer that run may be
+ *  unpainted, and then only the SIDE moves, which the surface records as an edge affinity. */
+ | {
+    kind: 'step-over';
+    caret: number;
+    overConstruct: boolean;
+};
+/**
+ * What a single typed byte does at a collapsed caret, or null to leave the engine its insert.
+ * `content` bounds the inline scan (a heading's `# ` is not prose); the caret must lie inside it.
+ * `keepsBlockKind` says whether a written line still reloads as this block: a grown `****` is a
+ * thematic break and `~~~~` a fence, so such a pair steps past a twin instead, or declines.
+ */
+export declare function resolveDelimiterAutoPair(text: string, content: ContentRange, caret: number, typed: string, keepsBlockKind?: (text: string) => boolean): AutoPairEdit | null;
+/**
+ * Inside a revealed source (`$ab|$`) the twin is the live closer, and typing it means "done":
+ * the caret steps past it and the caller folds the reveal, so the formula renders at once.
+ */
+export declare function stepsOverRevealedCloser(text: string, caret: number, typed: string): boolean;
+/** Backspace at an empty pair takes both runs, between them (`**|**`) or right after them
+ *  (`$$|`), as it does in any IDE. Exactly a pair of equal runs, one or two bytes each: a longer
+ *  run is a fence or a literal the user built by hand. */
+export declare function resolveEmptyPairBackspace(text: string, caret: number): AutoPairEdit | null;
+/** What a prose surface lends the arm. Reactive reads are thunks, so nothing here goes stale. */
+export interface AutoPairSurface {
+    /** The bytes the caret indexes: the display text, or the revealed DOM text during a reveal. */
+    text(): string;
+    content(): ContentRange;
+    caret(): number | null;
+    hasSelection(): boolean;
+    isRevealing(): boolean;
+    foldReveal(): {
+        settled: Promise<void>;
+    } | null;
+    /** Whether the closer a step-over passes is on screen; unpainted, only the side moves. */
+    markersPaint(): boolean;
+    setCaret(offset: number): void;
+    /** The arrival the seat reads next: past the construct's delimiters. */
+    seatOutside(): void;
+    /** One CST write plus the caret it parks. */
+    write(text: string, caretBefore: number, caretAfter: number): void;
+    /** A step-over that leaves the line one an on-type completer claims (`$$`), which only a
+     *  content write consults. */
+    completesLine?(caret: number): boolean;
+    /** The resolver's block-kind guard, for a surface whose line can become another block. */
+    keepsBlockKind?(text: string): boolean;
+}
+/**
+ * The `beforeinput` arm. True when the press was this seam's: the event is cancelled and the
+ * surface has written, moved or re-seated the caret.
+ */
+export declare function applyDelimiterAutoPair(e: InputEvent, surface: AutoPairSurface): boolean;

package/dist/components/blocks/text/delimiter-autopair.js

@@ -0,0 +1,216 @@
+/**
+ * A typed inline delimiter closes itself: a lone `$`, backtick, `*`, `_` or `~~` would pair with
+ * whatever matching run comes later on the line, so the keystroke lands its twin after the caret.
+ * Typing the closer over the twin steps past it, a closer typed by hand seats the next byte
+ * outside, and the empty pair drops its twin when the first body byte makes it no construct.
+ * `applyDelimiterAutoPair` is the one `beforeinput` arm every prose surface runs (G4.65).
+ */
+import { constructContentRange, inlineDescendants, parseInline } from '../../../core/inline';
+import { isAutoPairTrigger } from '../../../core/inline/scan/plugin-syntax';
+const STEP = { single: true, inside: 'step-over' };
+const BUILTIN = {
+    '`': STEP,
+    '*': { single: true, inside: 'grow', notAfterWord: true },
+    _: { single: true, inside: 'grow', notAfterWord: true },
+    // `~5 minutes` would strike the 5 (GFM takes a single tilde), so only `~~` pairs.
+    '~': { single: false, inside: 'grow' }
+};
+const isWordByte = (ch) => ch !== undefined && /[\p{L}\p{N}]/u.test(ch);
+function policyOf(ch) {
+    return BUILTIN[ch] ?? (isAutoPairTrigger(ch) ? STEP : null);
+}
+// ── The resolver ─────────────────────────────────────────────────────────────
+/**
+ * What a single typed byte does at a collapsed caret, or null to leave the engine its insert.
+ * `content` bounds the inline scan (a heading's `# ` is not prose); the caret must lie inside it.
+ * `keepsBlockKind` says whether a written line still reloads as this block: a grown `****` is a
+ * thematic break and `~~~~` a fence, so such a pair steps past a twin instead, or declines.
+ */
+export function resolveDelimiterAutoPair(text, content, caret, typed, keepsBlockKind = () => true) {
+    if (typed.length !== 1 || caret < content.start || caret > content.end)
+        return null;
+    const before = text[caret - 1];
+    const after = text[caret];
+    const policy = policyOf(typed);
+    if (!policy)
+        return collapseEmptyPair(text, content, caret, typed);
+    if (after === typed && closingRunAt(text, content, caret, typed)) {
+        return { kind: 'step-over', caret: caret + 1, overConstruct: true };
+    }
+    const paired = text.slice(0, caret) + typed + text.slice(caret);
+    if (closerEndsAt(paired, content, caret + 1, typed)) {
+        return { kind: 'close', text: paired, caret: caret + 1 };
+    }
+    const pair = (next) => {
+        if (keepsBlockKind(next))
+            return write(next, caret + 1);
+        return after === typed ? { kind: 'step-over', caret: caret + 1, overConstruct: false } : null;
+    };
+    if (after === typed) {
+        if (before === typed) {
+            if (policy.inside === 'step-over') {
+                return { kind: 'step-over', caret: caret + 1, overConstruct: false };
+            }
+            return pair(text.slice(0, caret) + typed + typed + text.slice(caret));
+        }
+        // A byte in front of another run's opener is spelling something out, not opening a span.
+        return null;
+    }
+    if (before === typed && !closerEndsAt(text, content, caret, typed)) {
+        // `~|` plus `~`: the double run this delimiter pairs on, as long as it IS a lone run.
+        const single = text[caret - 2] !== typed;
+        if (policy.inside === 'grow' && single) {
+            return pair(text.slice(0, caret) + typed.repeat(3) + text.slice(caret));
+        }
+        return null;
+    }
+    if (!policy.single || (policy.notAfterWord && isWordByte(before)))
+        return null;
+    return pair(text.slice(0, caret) + typed + typed + text.slice(caret));
+}
+/**
+ * Inside a revealed source (`$ab|$`) the twin is the live closer, and typing it means "done":
+ * the caret steps past it and the caller folds the reveal, so the formula renders at once.
+ */
+export function stepsOverRevealedCloser(text, caret, typed) {
+    return typed.length === 1 && policyOf(typed) !== null && text[caret] === typed;
+}
+/** Backspace at an empty pair takes both runs, between them (`**|**`) or right after them
+ *  (`$$|`), as it does in any IDE. Exactly a pair of equal runs, one or two bytes each: a longer
+ *  run is a fence or a literal the user built by hand. */
+export function resolveEmptyPairBackspace(text, caret) {
+    const pair = emptyPairEnding(text, caret) ?? emptyPairAround(text, caret);
+    if (!pair)
+        return null;
+    return write(text.slice(0, pair.start) + text.slice(pair.end), pair.start);
+}
+const write = (text, caret) => ({ kind: 'write', text, caret });
+/**
+ * The `beforeinput` arm. True when the press was this seam's: the event is cancelled and the
+ * surface has written, moved or re-seated the caret.
+ */
+export function applyDelimiterAutoPair(e, surface) {
+    const typing = e.inputType === 'insertText';
+    if (!typing && e.inputType !== 'deleteContentBackward')
+        return false;
+    if (e.isComposing || surface.hasSelection())
+        return false;
+    const caret = surface.caret();
+    if (caret === null)
+        return false;
+    const text = surface.text();
+    if (surface.isRevealing()) {
+        if (!typing || !stepsOverRevealedCloser(text, caret, e.data ?? ''))
+            return false;
+        e.preventDefault();
+        surface.setCaret(caret + 1);
+        void surface.foldReveal()?.settled;
+        return true;
+    }
+    const edit = typing
+        ? resolveDelimiterAutoPair(text, surface.content(), caret, e.data ?? '', surface.keepsBlockKind)
+        : resolveEmptyPairBackspace(text, caret);
+    if (!edit)
+        return false;
+    e.preventDefault();
+    switch (edit.kind) {
+        case 'step-over':
+            if (edit.overConstruct && !surface.markersPaint())
+                surface.seatOutside();
+            else if (surface.completesLine?.(edit.caret))
+                surface.write(text, caret, edit.caret);
+            else
+                surface.setCaret(edit.caret);
+            return true;
+        case 'close':
+            surface.write(edit.text, caret, edit.caret);
+            surface.seatOutside();
+            return true;
+        case 'write':
+            surface.write(edit.text, caret, edit.caret);
+            return true;
+    }
+}
+// ── Runs ─────────────────────────────────────────────────────────────────────
+/** Length of the run of `ch` ending just before `at` (0 when `text[at - 1]` is not `ch`). */
+function runBefore(text, at, ch) {
+    let n = 0;
+    while (text[at - 1 - n] === ch)
+        n++;
+    return n;
+}
+function runAfter(text, at, ch) {
+    let n = 0;
+    while (text[at + n] === ch)
+        n++;
+    return n;
+}
+// `X..X|X..X`: equal runs of a pair delimiter, one or two bytes, with nothing of it either side.
+function emptyPairAround(text, caret) {
+    const d = text[caret - 1];
+    if (d === undefined || !policyOf(d))
+        return null;
+    const k = runBefore(text, caret, d);
+    if (k > 2 || runAfter(text, caret, d) !== k)
+        return null;
+    return { start: caret - k, end: caret + k };
+}
+// `XX|`: a stepped-over empty pair with the caret after it. Only the delimiters that step (the
+// emphasis family grows instead, and its `**|` is a double opener with content ahead).
+function emptyPairEnding(text, caret) {
+    const d = text[caret - 1];
+    if (d === undefined || policyOf(d)?.inside !== 'step-over' || text[caret] === d)
+        return null;
+    if (runBefore(text, caret, d) !== 2)
+        return null;
+    return { start: caret - 2, end: caret };
+}
+// ── Constructs ───────────────────────────────────────────────────────────────
+// `X|X` plus the typed byte: keep the twin run only if the pair then parses as a construct.
+function collapseEmptyPair(text, content, caret, typed) {
+    const d = text[caret - 1];
+    if (d === undefined || !policyOf(d))
+        return null;
+    const k = runBefore(text, caret, d);
+    if (k > 2 || runAfter(text, caret, d) !== k)
+        return null;
+    const paired = text.slice(0, caret) + typed + text.slice(caret);
+    const shifted = { start: content.start, end: content.end + 1 };
+    if (constructAt(paired, shifted, caret - k, caret + 1 + k))
+        return null;
+    return write(text.slice(0, caret) + typed + text.slice(caret + k), caret + 1);
+}
+// The caret sits inside or at the start of the closing run of a construct this delimiter both
+// opens and closes, so the byte under it is that construct's own closer.
+function closingRunAt(text, content, caret, typed) {
+    for (const node of inlineDescendants(parseInline(text, content.start, content.end))) {
+        if (node.kind === 'text' || text[node.start] !== typed || node.end <= caret)
+            continue;
+        let closer = node.end;
+        while (closer > caret && text[closer - 1] === typed)
+            closer--;
+        if (closer <= caret)
+            return true;
+    }
+    return false;
+}
+// A construct of `typed`'s family ends exactly at `end`, its last byte in the closing run. The
+// scan's bound grows past the content by the byte a caller has just inserted.
+function closerEndsAt(text, content, end, typed) {
+    const bound = Math.max(content.end, end);
+    for (const node of inlineDescendants(parseInline(text, content.start, bound))) {
+        if (node.kind === 'text' || node.end !== end || text[end - 1] !== typed)
+            continue;
+        const inner = constructContentRange(node);
+        if (!inner || inner.end < end)
+            return true;
+    }
+    return false;
+}
+function constructAt(text, content, start, end) {
+    for (const node of inlineDescendants(parseInline(text, content.start, content.end))) {
+        if (node.kind !== 'text' && node.start === start && node.end === end)
+            return true;
+    }
+    return false;
+}

package/dist/components/blocks/text/edge-policy-dispatch.d.ts

@@ -13,6 +13,8 @@ import { type RawOffset } from '../../../cursor/coordinate-spaces';
 import type { EdgeAffinity } from '../../../cursor/edge-affinity';
 import type { PendingMarksState } from '../../../cursor/pending-marks';
 import { type EdgeDeletionSurface } from './construct-edge-delete';
+/** Whether `line` still reloads as `node`'s kind, the auto-pair resolver's guard. */
+export declare function keepsBlockKind(node: NodeView, line: string): boolean;
 /** The subset of the inline-widget vocabulary the internal island policies reuse,
  *  expressed in the same terms without leaking into the public API. */
 export type EdgePolicy = Pick<InlineWidgetEditingPolicy, 'onEdge' | 'deleteGranularity'>;
@@ -70,6 +72,8 @@ export interface EdgePolicyDispatchDeps {
     isReading: () => boolean;
     /** The arrival side the typing seat consults; null when no arrival claimed one. */
     getEdgeAffinity: () => EdgeAffinity | null;
+    /** A seated delimiter that completed a construct leaves the caret meaning outside it. */
+    noteOutside?: () => void;
     /** The constructs a collapsed-caret toggle promised the next insertion. Read AND spent
      *  here: the first byte after the chord is the one insertion they were pending for. */
     pendingMarks: PendingMarksState;