@voithos-labs/aragonite 0.10.1

package/dist/components/blocks/code/CodeBlock.svelte.d.ts

@@ -0,0 +1,23 @@
+import { type StickyColumnDirection } from '../../../block-component';
+import type { NodeView } from '../../../core/node-views';
+import { type CommandId } from '../../../schema/commands';
+type $$ComponentProps = {
+    node: NodeView;
+    index: number;
+    myPath?: number[];
+};
+declare const CodeBlock: import("svelte").Component<$$ComponentProps, {
+    editable: true;
+    focusable: true;
+    focus: (offset: number) => void;
+    parkCaret: (offset: number) => void;
+    focusAtColumn: (x: number, from: StickyColumnDirection) => void;
+    getCursorOffset: () => number | null;
+    getSelectedText: () => string;
+    setSelection: (start: number, end: number) => void;
+    measurePartialRects: (startOffset: number, endOffset: number) => DOMRect[];
+    runCommand: (id: CommandId) => boolean;
+    insertMarkdown: (md: string) => boolean;
+}, "">;
+type CodeBlock = ReturnType<typeof CodeBlock>;
+export default CodeBlock;

package/dist/components/blocks/code/CodeLanguageChip.svelte

@@ -0,0 +1,127 @@
+<script lang="ts">
+	import { tick } from 'svelte';
+	import { CODE_LANGUAGE_FIELD, codeLanguageLabel } from '../../../a11y-strings';
+
+	// The fence-info door for the modes that paint no fence. The draft lives here and only a
+	// commit reaches the tree.
+	let {
+		info,
+		editable,
+		onCommit,
+		onCancel
+	}: {
+		/** The opener's full info string; the button shows its first token. */
+		info: string;
+		/** False in reading mode, which writes no bytes — the chip is then a label. */
+		editable: boolean;
+		/** Only Enter calls this, and it owns the caret's landing afterwards. */
+		onCommit: (info: string) => void;
+		/** Nothing written. Escape asks for the caret back; a blur must not yank it from
+		 *  wherever the user just clicked, so it does not. */
+		onCancel: (returnCaret: boolean) => void;
+	} = $props();
+
+	const language = $derived(info.split(/\s+/)[0] || 'text');
+
+	let editing = $state(false);
+	let draft = $state('');
+	let inputEl: HTMLInputElement | undefined = $state();
+
+	function open(): void {
+		if (!editable) return;
+		draft = info;
+		editing = true;
+		void tick().then(() => {
+			inputEl?.focus();
+			inputEl?.select();
+		});
+	}
+
+	function onFieldKeyDown(e: KeyboardEvent): void {
+		// The field owns its keys while open: no Escape of this state may reach whatever else
+		// listens for one. A composing Enter/Escape is the IME's, never the field's.
+		e.stopPropagation();
+		if (e.isComposing) return;
+		if (e.key === 'Enter') {
+			e.preventDefault();
+			const committed = draft;
+			editing = false;
+			onCommit(committed);
+		} else if (e.key === 'Escape') {
+			e.preventDefault();
+			editing = false;
+			onCancel(true);
+		}
+	}
+
+	function onFieldBlur(): void {
+		if (!editing) return;
+		editing = false;
+		onCancel(false);
+	}
+</script>
+
+<span class="code-lang-chip">
+	{#if editing}
+		<input
+			bind:this={inputEl}
+			bind:value={draft}
+			type="text"
+			spellcheck="false"
+			aria-label={CODE_LANGUAGE_FIELD}
+			onkeydown={onFieldKeyDown}
+			onfocusout={onFieldBlur}
+		/>
+	{:else}
+		<button type="button" aria-label={codeLanguageLabel(language)} onclick={open}>{language}</button
+		>
+	{/if}
+</span>
+
+<style>
+	/* Positioned against the block host, whose box the code box fills, and out of the code
+	   box's own scroller so a horizontal scroll leaves it where it is. */
+	.code-lang-chip {
+		position: absolute;
+		top: 5px;
+		right: 5px;
+		z-index: 1;
+		display: flex;
+		font-family: var(--font-editor, ui-monospace, monospace);
+		font-size: 0.75em;
+		line-height: 1;
+		opacity: 0;
+		pointer-events: none;
+	}
+
+	/* Transient, like the drag handle: the pointer over the block or the caret inside it, plus
+	   the open field, which outlives both. Child and sibling combinators, so an outer container's
+	   hover never reveals a nested block's chip. */
+	:global(.block-host:hover) > .code-lang-chip,
+	:global(.code-block:focus) ~ .code-lang-chip,
+	.code-lang-chip:focus-within {
+		opacity: 1;
+		pointer-events: auto;
+	}
+
+	button,
+	input {
+		padding: 2px 6px;
+		border: 1px solid var(--color-ui-muted, #a4a4a4);
+		border-radius: var(--radius-ui, 3px);
+		background: var(--color-bg-elevated, #2a2a2a);
+		color: var(--color-accent, #567b67);
+		font: inherit;
+		cursor: pointer;
+	}
+
+	button:hover {
+		background: var(--color-ui-faint, rgba(255, 255, 255, 0.07));
+	}
+
+	input {
+		width: 9ch;
+		color: var(--color-text-secondary, #eee);
+		cursor: text;
+	}
+</style>

package/dist/components/blocks/code/CodeLanguageChip.svelte.d.ts

@@ -0,0 +1,14 @@
+type $$ComponentProps = {
+    /** The opener's full info string; the button shows its first token. */
+    info: string;
+    /** False in reading mode, which writes no bytes — the chip is then a label. */
+    editable: boolean;
+    /** Only Enter calls this, and it owns the caret's landing afterwards. */
+    onCommit: (info: string) => void;
+    /** Nothing written. Escape asks for the caret back; a blur must not yank it from
+     *  wherever the user just clicked, so it does not. */
+    onCancel: (returnCaret: boolean) => void;
+};
+declare const CodeLanguageChip: import("svelte").Component<$$ComponentProps, {}, "">;
+type CodeLanguageChip = ReturnType<typeof CodeLanguageChip>;
+export default CodeLanguageChip;

package/dist/components/blocks/code/code-beforeinput.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Pure auto-pair decision for code-block `insertText` events: the component owns
+ * the DOM and CST plumbing, this owns the splice math.
+ */
+export interface AutoPairInput {
+    text: string;
+    selection: {
+        start: number;
+        end: number;
+    };
+    typed: string;
+    /** True when the host block is an unclosed backtick fence — backticks would extend it. */
+    unclosedBacktickFence?: boolean;
+}
+export type AutoPairResult = {
+    kind: 'pair';
+    newText: string;
+    caretOffset: number;
+} | {
+    kind: 'skip';
+    caretOffset: number;
+} | {
+    kind: 'wrap';
+    newText: string;
+    selection: {
+        start: number;
+        end: number;
+    };
+};
+export declare function computeAutoPair(input: AutoPairInput): AutoPairResult | null;

package/dist/components/blocks/code/code-beforeinput.js

@@ -0,0 +1,40 @@
+/**
+ * Pure auto-pair decision for code-block `insertText` events: the component owns
+ * the DOM and CST plumbing, this owns the splice math.
+ */
+import { getCloserFor, shouldAutoClose, shouldSkipClose } from './code-editing';
+// ── Public API ──────────────────────────────────────────────────────────────
+export function computeAutoPair(input) {
+    const { text, selection, typed, unclosedBacktickFence = false } = input;
+    const closer = getCloserFor(typed);
+    const collapsed = selection.start === selection.end;
+    if (!collapsed) {
+        if (closer === null)
+            return null;
+        const wrapped = text.slice(0, selection.start) +
+            typed +
+            text.slice(selection.start, selection.end) +
+            closer +
+            text.slice(selection.end);
+        return {
+            kind: 'wrap',
+            newText: wrapped,
+            selection: { start: selection.start + 1, end: selection.end + 1 }
+        };
+    }
+    const offset = selection.start;
+    if (shouldSkipClose(text, offset, typed)) {
+        return { kind: 'skip', caretOffset: offset + 1 };
+    }
+    if (closer === null)
+        return null;
+    if (typed === '`' && unclosedBacktickFence)
+        return null;
+    if (!shouldAutoClose(text, offset, typed))
+        return null;
+    return {
+        kind: 'pair',
+        newText: text.slice(0, offset) + typed + closer + text.slice(offset),
+        caretOffset: offset + 1
+    };
+}

package/dist/components/blocks/code/code-bootstrap.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Idempotent bootstrap for code-block languages + the fencedCode PasteSurface.
+ * Adding a language = one import + one registerLanguage call.
+ */
+export declare function bootstrapCodeLanguages(): void;
+/** Test-only: reset the booted flag and unregister the paste surface, so a
+ *  re-bootstrap doesn't hit the register-once duplicate throw. */
+export declare function __resetBootForTests(): void;

package/dist/components/blocks/code/code-bootstrap.js

@@ -0,0 +1,54 @@
+/**
+ * Idempotent bootstrap for code-block languages + the fencedCode PasteSurface.
+ * Adding a language = one import + one registerLanguage call.
+ */
+import { registerLanguage } from './code-languages';
+import { registerPasteSurface, __removePasteSurfaceForTests } from '../../../tree-operations/paste-surfaces';
+import { codePasteSurface } from './code-paste-surface';
+import javascript from 'highlight.js/lib/languages/javascript';
+import typescript from 'highlight.js/lib/languages/typescript';
+import python from 'highlight.js/lib/languages/python';
+import rust from 'highlight.js/lib/languages/rust';
+import go from 'highlight.js/lib/languages/go';
+import bash from 'highlight.js/lib/languages/bash';
+import json from 'highlight.js/lib/languages/json';
+import yaml from 'highlight.js/lib/languages/yaml';
+import sql from 'highlight.js/lib/languages/sql';
+import xml from 'highlight.js/lib/languages/xml';
+import css from 'highlight.js/lib/languages/css';
+import java from 'highlight.js/lib/languages/java';
+import c from 'highlight.js/lib/languages/c';
+import cpp from 'highlight.js/lib/languages/cpp';
+import ruby from 'highlight.js/lib/languages/ruby';
+import markdown from 'highlight.js/lib/languages/markdown';
+import diff from 'highlight.js/lib/languages/diff';
+let booted = false;
+export function bootstrapCodeLanguages() {
+    if (booted)
+        return;
+    booted = true;
+    registerLanguage('javascript', javascript, ['js']);
+    registerLanguage('typescript', typescript, ['ts']);
+    registerLanguage('python', python, ['py']);
+    registerLanguage('rust', rust, ['rs']);
+    registerLanguage('go', go);
+    registerLanguage('bash', bash, ['sh', 'shell']);
+    registerLanguage('json', json);
+    registerLanguage('yaml', yaml, ['yml']);
+    registerLanguage('sql', sql);
+    registerLanguage('html', xml, ['htm']); // hljs 'xml' grammar handles HTML
+    registerLanguage('css', css);
+    registerLanguage('java', java);
+    registerLanguage('c', c);
+    registerLanguage('cpp', cpp, ['c++']);
+    registerLanguage('ruby', ruby);
+    registerLanguage('markdown', markdown, ['md']);
+    registerLanguage('diff', diff);
+    registerPasteSurface(codePasteSurface);
+}
+/** Test-only: reset the booted flag and unregister the paste surface, so a
+ *  re-bootstrap doesn't hit the register-once duplicate throw. */
+export function __resetBootForTests() {
+    booted = false;
+    __removePasteSurfaceForTests(codePasteSurface.kind);
+}

package/dist/components/blocks/code/code-editing.d.ts

@@ -0,0 +1,28 @@
+/** Pair tables, leading-whitespace extraction, and stateless predicates for bracket/quote auto-pairing. */
+export declare const BRACKET_PAIRS: Readonly<Record<string, string>>;
+/**
+ * Backtick is safe to pair: terminating a fence needs a bare-line run of
+ * ≥ fenceLength at column 0, which a single typed `` ` `` can never be.
+ */
+export declare const QUOTE_CHARS: ReadonlySet<string>;
+/**
+ * Opening brackets are deliberately excluded: typing `(` when the next char
+ * is `(` should produce nesting, not a skip.
+ */
+export declare const SKIP_CLOSE_CHARS: ReadonlySet<string>;
+export declare function getCloserFor(opener: string): string | null;
+export declare function getLineLeadingWhitespace(text: string, offset: number): string;
+/**
+ * Brackets refuse to pair before an identifier (wrapping existing code, `(foo`);
+ * quotes also refuse after one (the `don't` case).
+ */
+export declare function shouldAutoClose(text: string, offset: number, opener: string): boolean;
+/** Overtype: skip past an existing closer instead of inserting a duplicate. */
+export declare function shouldSkipClose(text: string, offset: number, typed: string): boolean;
+/** True at `(|)`, `[|]`, `{|}`, `"|"`, `'|'`, `` `|` ``. Drives Backspace pair-delete. */
+export declare function isBetweenEmptyPair(text: string, offset: number): boolean;
+/**
+ * Bracket-only variant for Enter's electric indent: `{|}` expands to a
+ * three-line block, `"|"` does not (multi-line string literals are rare).
+ */
+export declare function isBetweenEmptyBracketPair(text: string, offset: number): boolean;

package/dist/components/blocks/code/code-editing.js

@@ -0,0 +1,79 @@
+/** Pair tables, leading-whitespace extraction, and stateless predicates for bracket/quote auto-pairing. */
+// ── Pair tables ─────────────────────────────────────────────────────────────
+export const BRACKET_PAIRS = {
+    '(': ')',
+    '[': ']',
+    '{': '}'
+};
+/**
+ * Backtick is safe to pair: terminating a fence needs a bare-line run of
+ * ≥ fenceLength at column 0, which a single typed `` ` `` can never be.
+ */
+export const QUOTE_CHARS = new Set(["'", '"', '`']);
+/**
+ * Opening brackets are deliberately excluded: typing `(` when the next char
+ * is `(` should produce nesting, not a skip.
+ */
+export const SKIP_CLOSE_CHARS = new Set([
+    ...Object.values(BRACKET_PAIRS),
+    ...QUOTE_CHARS
+]);
+const IDENTIFIER_RE = /[\w$]/;
+export function getCloserFor(opener) {
+    if (opener in BRACKET_PAIRS)
+        return BRACKET_PAIRS[opener];
+    if (QUOTE_CHARS.has(opener))
+        return opener;
+    return null;
+}
+// ── Leading-whitespace extraction (auto-indent) ─────────────────────────────
+export function getLineLeadingWhitespace(text, offset) {
+    const clamped = Math.max(0, Math.min(offset, text.length));
+    const lineStart = clamped === 0 ? 0 : text.lastIndexOf('\n', clamped - 1) + 1;
+    let end = lineStart;
+    while (end < text.length && (text[end] === ' ' || text[end] === '\t'))
+        end++;
+    return text.slice(lineStart, end);
+}
+// ── Auto-pair decisions ─────────────────────────────────────────────────────
+/**
+ * Brackets refuse to pair before an identifier (wrapping existing code, `(foo`);
+ * quotes also refuse after one (the `don't` case).
+ */
+export function shouldAutoClose(text, offset, opener) {
+    const next = text[offset];
+    if (next !== undefined && IDENTIFIER_RE.test(next))
+        return false;
+    if (QUOTE_CHARS.has(opener)) {
+        const prev = text[offset - 1];
+        if (prev !== undefined && IDENTIFIER_RE.test(prev))
+            return false;
+    }
+    return true;
+}
+/** Overtype: skip past an existing closer instead of inserting a duplicate. */
+export function shouldSkipClose(text, offset, typed) {
+    if (!SKIP_CLOSE_CHARS.has(typed))
+        return false;
+    return text[offset] === typed;
+}
+// ── Empty-pair detection (electric indent, backspace pair-delete) ───────────
+/** True at `(|)`, `[|]`, `{|}`, `"|"`, `'|'`, `` `|` ``. Drives Backspace pair-delete. */
+export function isBetweenEmptyPair(text, offset) {
+    if (offset <= 0 || offset >= text.length)
+        return false;
+    const prev = text[offset - 1];
+    const next = text[offset];
+    return getCloserFor(prev) === next;
+}
+/**
+ * Bracket-only variant for Enter's electric indent: `{|}` expands to a
+ * three-line block, `"|"` does not (multi-line string literals are rare).
+ */
+export function isBetweenEmptyBracketPair(text, offset) {
+    if (offset <= 0 || offset >= text.length)
+        return false;
+    const prev = text[offset - 1];
+    const next = text[offset];
+    return prev in BRACKET_PAIRS && BRACKET_PAIRS[prev] === next;
+}

package/dist/components/blocks/code/code-enter.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Pure Enter-at-cursor splice for code blocks. `'normal'` auto-indents from
+ * the current line; `'soft'` (Shift+Enter / mobile `insertLineBreak`) inserts
+ * the line ending alone.
+ */
+export type CodeEnterMode = 'normal' | 'soft';
+export interface CodeEnterInput {
+    display: string;
+    selection: {
+        start: number;
+        end: number;
+    };
+    mode: CodeEnterMode;
+    /** The block's own ending. Required rather than defaulted: a literal `\n` here
+     *  would leave a lone LF inside a CRLF body. */
+    ending: '\n' | '\r\n';
+}
+export interface CodeEnterResult {
+    newText: string;
+    newCursor: number;
+}
+export declare function computeCodeEnter(input: CodeEnterInput): CodeEnterResult;

package/dist/components/blocks/code/code-enter.js

@@ -0,0 +1,19 @@
+/**
+ * Pure Enter-at-cursor splice for code blocks. `'normal'` auto-indents from
+ * the current line; `'soft'` (Shift+Enter / mobile `insertLineBreak`) inserts
+ * the line ending alone.
+ */
+import { getLineLeadingWhitespace } from './code-editing';
+// ── Public API ──────────────────────────────────────────────────────────────
+export function computeCodeEnter(input) {
+    const { display, selection, mode, ending } = input;
+    const { start, end } = selection;
+    // Indent reads from the SELECTION START's line — Enter on a non-collapsed
+    // range deletes the range first, so the surviving line is that one.
+    const indent = mode === 'normal' ? getLineLeadingWhitespace(display, start) : '';
+    const inserted = ending + indent;
+    return {
+        newText: display.slice(0, start) + inserted + display.slice(end),
+        newCursor: start + inserted.length
+    };
+}

package/dist/components/blocks/code/code-fence-boundary.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Pure decisions that keep an edit off the fence lines of a fenced code block: rewriting either
+ * fence leaves an unclosed one that absorbs the rest of the document at the next parse. Editable
+ * content is the body plus the opener's info string. Display-text coordinates throughout.
+ */
+import type { NodeView } from '../../../core/node-views';
+export interface FenceBoundaryInput {
+    node: NodeView;
+    offset: number;
+    /** True when the user pressed Delete (forward) rather than Backspace. */
+    forward: boolean;
+}
+/** Display-text offset range, as the code gestures pass it around. */
+export interface CodeRange {
+    start: number;
+    end: number;
+}
+export type FenceBoundaryResult = {
+    kind: 'allow';
+} | {
+    kind: 'exitPrev';
+} | {
+    kind: 'exitNext';
+};
+/**
+ * Classify a Backspace/Delete against the two body boundaries: Backspace at bodyStart
+ * would delete the opener's terminating `\n`, Delete at bodyEnd the body's — either
+ * re-parses the block in a different shape, so both become a focus-move out instead.
+ * What else a keystroke may rewrite is `crossesFenceBoundary`'s question.
+ */
+export declare function classifyFenceBoundary(input: FenceBoundaryInput): FenceBoundaryResult;
+/**
+ * Clamp an Enter-splice out of both fence lines onto the nearest body edge — a `\n`
+ * inside the opener re-shapes the fence, one inside the closer breaks it apart. Each
+ * fence line's inner edge is left alone: splicing after the info string, or at the
+ * start of the closer line, is already safe.
+ */
+export declare function clampEnterOffsetToBody(node: NodeView, offset: number): number;
+/**
+ * Clamp a whole range onto the body, unconditionally — for gestures that rewrite entire LINES (Tab
+ * indent, Shift+Tab dedent), where a tab on the closer pushes it past GFM's 3-space limit and one
+ * on the opener demotes the block. Arbitrary RANGE gestures use `fenceEditSpan` instead.
+ */
+export declare function clampRangeToBody(node: NodeView, range: CodeRange): CodeRange;
+/**
+ * Does a pending edit reach out of the editable content — the body, plus the opener's info string?
+ * Every other offset on the fence lines is one keystroke from swallowing the following blocks into
+ * the code node. An UNCLOSED fence is the exception: with no closer to orphan, its run is content
+ * too, so demoting the block is how a just-typed ` ``` ` gets undone.
+ */
+export declare function crossesFenceBoundary(node: NodeView, range: CodeRange): boolean;
+/**
+ * The span a ranged edit actually rewrites: the range itself while it stays inside
+ * one content region, its intersection with the body once it reaches structure.
+ */
+export declare function fenceEditSpan(node: NodeView, range: CodeRange): CodeRange;
+/**
+ * Where a caret LANDING may sit — every door that seats a caret on this surface goes
+ * through here. A caret parked on a fence line takes keystrokes the guard refuses:
+ * the landing looks successful and the next character disappears.
+ */
+export declare function clampCaretToBody(node: NodeView, offset: number): number;
+/**
+ * The refusal rule shared by every mutating gesture here: a range that reached structure and kept
+ * no body after the clamp is declined, not re-sited to a body edge the user never pointed at.
+ * Paste consults it directly, since it splices through the paste tree-op.
+ */
+export declare function isStructureOnlyRange(node: NodeView, range: CodeRange): boolean;
+/**
+ * The one in-place range splice — native delete/type-over (via the beforeinput guard)
+ * and cut. Null when there is nothing to rewrite, so no undo entry is spent.
+ */
+export declare function computeFenceRangedEdit(node: NodeView, range: CodeRange, insert: string): FenceRangedEdit | null;
+export interface FenceRangedEdit {
+    newText: string;
+    newCursor: number;
+}