@voithos-labs/aragonite 0.10.2 → 0.10.3

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

@@ -5,6 +5,7 @@
 import { registerLanguage } from './code-languages';
 import { registerPasteSurface, __removePasteSurfaceForTests } from '../../../tree-operations/paste-surfaces';
 import { codePasteSurface } from './code-paste-surface';
+import { registerCodeContextActions } from './code-context-actions';
 import javascript from 'highlight.js/lib/languages/javascript';
 import typescript from 'highlight.js/lib/languages/typescript';
 import python from 'highlight.js/lib/languages/python';
@@ -22,6 +23,7 @@ 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';
+import latex from 'highlight.js/lib/languages/latex';
 let booted = false;
 export function bootstrapCodeLanguages() {
     if (booted)
@@ -44,7 +46,9 @@ export function bootstrapCodeLanguages() {
     registerLanguage('ruby', ruby);
     registerLanguage('markdown', markdown, ['md']);
     registerLanguage('diff', diff);
+    registerLanguage('latex', latex, ['tex']);
     registerPasteSurface(codePasteSurface);
+    registerCodeContextActions();
 }
 /** Test-only: reset the booted flag and unregister the paste surface, so a
  *  re-bootstrap doesn't hit the register-once duplicate throw. */

package/dist/components/blocks/code/code-context-actions.d.ts

@@ -0,0 +1 @@
+export declare function registerCodeContextActions(): void;

package/dist/components/blocks/code/code-context-actions.js

@@ -0,0 +1,24 @@
+/**
+ * The code block's context menu: dissolve the fence into plain text. Delete is every block's
+ * default row. Registered once from the code bootstrap.
+ */
+import { registerBlockContextActions } from '../../../schema/context-actions';
+import { sliceFencedCode } from './code-renderer';
+let registered = false;
+export function registerCodeContextActions() {
+    if (registered)
+        return;
+    registered = true;
+    registerBlockContextActions('fencedCode', (node) => [
+        {
+            id: 'code.dissolve',
+            label: 'Dissolve into text',
+            icon: 'type',
+            run: (ctx) => {
+                // The body's lines as prose; the fence lines go. An empty body leaves an empty line.
+                const body = sliceFencedCode(node).body.replace(/\r?\n$/, '');
+                return ctx.replaceRaw(body + '\n');
+            }
+        }
+    ]);
+}

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

@@ -21,4 +21,19 @@ export type FenceExitResult = {
 } | {
     kind: 'none';
 };
+export interface TypedFenceExitInput extends FenceExitInput {
+    /** The one character the pending `insertText` would write. */
+    typed: string;
+}
+/** A typed closer either leaves (taking its own line with it) or is just a byte. */
+export type TypedFenceExitResult = Extract<FenceExitResult, {
+    kind: 'exitWithEdit' | 'none';
+}>;
 export declare function computeFenceExit(input: FenceExitInput): FenceExitResult;
+/**
+ * The block's other exit gesture: a closer typed on the body's empty last line. Every other
+ * editor reads that run as "done here", and the bytes never land — written, they would be a body
+ * line reading as the closer, which the write seam can only answer by growing the fence. A run
+ * anywhere else is content, and that escalation keeps its CommonMark meaning.
+ */
+export declare function computeTypedFenceExit(input: TypedFenceExitInput): TypedFenceExitResult;

package/dist/components/blocks/code/code-fence-exit.js

@@ -29,6 +29,32 @@ export function computeFenceExit(input) {
     }
     return { kind: 'none' };
 }
+/**
+ * The block's other exit gesture: a closer typed on the body's empty last line. Every other
+ * editor reads that run as "done here", and the bytes never land — written, they would be a body
+ * line reading as the closer, which the write seam can only answer by growing the fence. A run
+ * anywhere else is content, and that escalation keeps its CommonMark meaning.
+ */
+export function computeTypedFenceExit(input) {
+    const { text, offset, meta, typed } = input;
+    const none = { kind: 'none' };
+    if (!meta.closed || typed !== meta.fenceMarker)
+        return none;
+    // The caret must sit at the end of a line that has one below it: the closer's.
+    const ending = /^\r?\n/.exec(text.slice(offset));
+    if (!ending)
+        return none;
+    const lineStart = text.lastIndexOf('\n', offset - 1) + 1;
+    const run = text.slice(lineStart, offset);
+    if (run !== meta.fenceMarker.repeat(run.length) || run.length + 1 < meta.fenceLength)
+        return none;
+    const below = offset + ending[0].length;
+    if (!matchFenceClose(lineAt(text, below), meta.fenceMarker, meta.fenceLength))
+        return none;
+    // The run's line goes with the exit, as Enter's own empty-line exit takes the blank one.
+    return { kind: 'exitWithEdit', newText: text.slice(0, lineStart) + text.slice(below) };
+}
+// ── Internal ────────────────────────────────────────────────────────────────
 // The one physical line beginning at `start`, without its trailing newline.
 function lineAt(text, start) {
     const end = text.indexOf('\n', start);

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

@@ -11,5 +11,11 @@ export interface LanguageGrammar {
 export declare function registerLanguage(name: string, definition: LanguageFn, aliasList?: readonly string[]): void;
 /** Info strings with trailing attributes (`js {1-3}`) resolve on the first token. */
 export declare function getLanguageGrammar(infoString: string): LanguageGrammar | null;
+/**
+ * Every registered grammar name, plus every alias, sorted — what the language picker
+ * offers. Aliases are listed as their own entries: a user typing `js` should find it
+ * rather than having to know it resolves to `javascript`.
+ */
+export declare function listLanguages(): string[];
 /** Test-only: clear all registered languages. */
 export declare function __resetRegistryForTests(): void;

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

@@ -23,6 +23,17 @@ export function getLanguageGrammar(infoString) {
     const resolvedName = aliases.get(firstToken) ?? firstToken;
     return grammars.get(resolvedName) ?? null;
 }
+/**
+ * Every registered grammar name, plus every alias, sorted — what the language picker
+ * offers. Aliases are listed as their own entries: a user typing `js` should find it
+ * rather than having to know it resolves to `javascript`.
+ */
+export function listLanguages() {
+    const names = new Set(grammars.keys());
+    for (const alias of aliases.keys())
+        names.add(alias);
+    return [...names].sort();
+}
 /** Test-only: clear all registered languages. */
 export function __resetRegistryForTests() {
     grammars.clear();

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

@@ -217,6 +217,17 @@ export function renderCodeBlock(node) {
     const bodyText = separatorNewline ? slice.body.slice(0, -1) : slice.body;
     frag.appendChild(renderOpenerLine(slice, meta.fenceMarker, meta.fenceLength));
     frag.appendChild(tokenizeBody(bodyText, slice.infoString));
+    // An empty last body line ends the body in `\n` with only the (hidden) closer after it.
+    // Chromium paints no caret after a trailing `\n` unless something follows, so it
+    // canonicalises the seat to BEFORE the newline and the next key lands one byte early —
+    // the second line of a code block was untypeable in live mode. A `br` anchors the line
+    // without touching textContent; source mode, where the closer line itself follows, hides
+    // it in CSS.
+    if (separatorNewline && bodyText.endsWith('\n')) {
+        const anchor = document.createElement('br');
+        anchor.dataset.caretAnchor = 'closer';
+        frag.appendChild(anchor);
+    }
     frag.appendChild(renderCloserLine(slice, separatorNewline));
     assertInvariant('rendered-text-fidelity', () => checkRenderedTextFidelity(frag.textContent ?? '', trimTrailingLineEnding(node.raw)));
     return frag;

package/dist/components/blocks/directive/DirectiveContainerBlock.svelte

@@ -42,7 +42,7 @@
 	}
 	.directive-marker {
 		display: block;
-		font-family: var(--font-editor, ui-monospace, monospace);
+		font-family: var(--font-code, ui-monospace, monospace);
 		opacity: var(--syntax-marker-dim, 0.65);
 		user-select: none;
 		-webkit-user-select: none;

package/dist/components/blocks/editable-leaf.d.ts

@@ -1,9 +1,10 @@
 /**
- * The editable-leaf seam a plugin block component builds on: a text-editing block surface with
- * native caret/IME/undo/cross-block-selection parity, in one factory so a plugin never touches an
- * editor context key. Two modes: `plain` commits per keystroke, `render-primary` reveals its
- * source and commits on blur. Call synchronously during init. Contract: plugin-guide § The
- * editable leaf.
+ * The editable-leaf seam a plugin block component builds on: native caret/IME/undo/selection
+ * parity in one factory, so a plugin never touches an editor context key. `plain` commits per
+ * keystroke; `render-primary` reveals its source and commits on blur. A painted source
+ * (`renderSource`) edits only its own DOM: every byte still enters the CST through
+ * `commitReveal`'s one `updateBlockContent`. Call synchronously during init. Contract:
+ * plugin-guide § The editable leaf.
  */
 import type { BlockEditActions } from '../../action-contracts';
 import type { StickyColumnDirection } from '../../block-component';
@@ -37,6 +38,28 @@ export interface EditableLeafDeps {
      * platform treats it as `unknown`; the plugin casts it.
      */
     commandHooks?: () => unknown;
+    /**
+     * Paints the source as DOM instead of one text node — fence lines the mode CSS hides,
+     * highlight tokens. Must keep `fragment.textContent === text` (G1.28); the offset walk sees
+     * through spans, and hidden marker runs behave as they do in a code block.
+     */
+    renderSource?(text: string): DocumentFragment;
+    /**
+     * The surface's text after each edit the leaf applies itself (a painted source's typing,
+     * deleting, Enter). A render-primary host keeping a live preview reads this: the CST sees
+     * the edit only on blur, and a cancelled `beforeinput` fires no `input` event.
+     */
+    onSourceEdit?(text: string): void;
+    /**
+     * A source that is only its own chrome (a `$$$$` with no body line), completed to the shape
+     * a caret can sit in, with where the caret goes. Applied as the source is revealed, so the
+     * block the user just entered is one they can type into and delete; null leaves the bytes
+     * alone. The edit is the reveal's own, committed on blur like any other.
+     */
+    completeBareSource?(text: string): {
+        text: string;
+        caret: number;
+    } | null;
 }
 /**
  * The one-spread source surface: `<div {...leaf.surfaceProps}>` wires every handler and attribute
@@ -51,6 +74,7 @@ export interface EditableLeafSurfaceProps {
     role: 'textbox';
     spellcheck: 'false';
     oninput: () => void;
+    onbeforeinput: (e: InputEvent) => void;
     onkeydown: (e: KeyboardEvent) => void | Promise<void>;
     oncopy: (e: ClipboardEvent) => void;
     oncut: (e: ClipboardEvent) => Promise<void>;
@@ -69,14 +93,21 @@ export interface EditableLeafSurfaceProps {
  * stand down while the source is up, so the spread may sit on a wrapper the fold keeps.
  */
 export interface EditableLeafRenderProps {
-    /** Reveal-on-click (shift-click extends a selection instead). */
+    /** Notes the press; the reveal is the CLICK's (shift-click extends a selection instead). */
     onpointerdown: (e: PointerEvent) => void;
+    /** Reveal on a click that did not drag — a press that moved is a selection, not an entry. */
+    onclick: (e: MouseEvent) => void;
     /** Chord dispatch at this block's kind: the global tier, then its own commands. */
     onkeydown: (e: KeyboardEvent) => void;
 }
 export interface EditableLeaf {
     /** The block's source minus its trailing line ending — the editable text. */
     readonly sourceText: string;
+    /**
+     * Re-run `renderSource` over the surface's CURRENT text with the caret kept, for a host
+     * that repaints as the user types (highlighting goes stale otherwise). No-op without it.
+     */
+    repaintSource(): void;
     /** The one-spread source surface (attributes + handlers + view/park attachments). */
     surfaceProps: EditableLeafSurfaceProps;
     /** render-primary: the one-spread folded surface. */