@quillmark/svelte 0.0.0

package/dist/core/address.d.ts

@@ -0,0 +1,56 @@
+import { type Addr } from '@quillmark/wasm';
+/**
+ * A canonical field address: `main.<field>` / `main.body` /
+ * `cards.<kind>[<i>].<field>`, cards keyed by ABSOLUTE document index.
+ *
+ * The grammar `parseDocPath` / `formatDocPath` speak, and the one
+ * `Diagnostic.path`, `ContentHit.field`, `FieldRegion.field` and
+ * `session.regions()` keys already use. An alias over `string`: the boundary
+ * exports the parser and the segment type, not a nominal type, so this names the
+ * grammar at a signature rather than inventing a checked one.
+ */
+export type DocPath = string;
+/**
+ * A place in the document: a field and a caret within it. What the editor reports
+ * when its caret moves and what the preview scrolls to, so the editor→preview hop
+ * is `onCaretMove={preview.focusPosition}` and translates nothing.
+ *
+ * `pos` is USV, the shared content coordinate on both sides of the boundary: a
+ * `ContentHit` is a `Place` with its own extras, and fits wherever one is taken.
+ */
+export interface Place {
+    field: DocPath;
+    /** The caret in USV. */
+    pos: number;
+}
+/**
+ * A field's canonical `DocPath`, or `undefined` when `addr.card` is outside the live
+ * `kinds` array (a stale address: drop it rather than mis-target). A field-less card
+ * addresses its BODY, which is the leaf `{card: i}` names.
+ *
+ * - `{}` → `"main.body"`
+ * - `{field}` → `"main.<field>"`
+ * - `{card: i}` → `"cards.<kind>[i].body"`
+ * - `{card: i, field}` → `"cards.<kind>[i].<field>"`
+ *
+ * `cards[i]` stands in for an unknown or blank kind. The index is the addr's own: no
+ * per-kind counting, since `DocPath` addresses cards by document-array index.
+ */
+export declare function fieldPathForAddr(addr: Addr, kinds: readonly string[]): DocPath | undefined;
+/**
+ * A CARD's own path (`cards.<kind>[i]`), not a leaf's: what a structure op names,
+ * where the change is the card rather than anything inside it. `undefined` for an
+ * index outside `kinds`.
+ */
+export declare function cardPath(index: number, kinds: readonly string[]): DocPath | undefined;
+/**
+ * The inverse: a canonical `DocPath` back to the `Addr` the document verbs take, or
+ * `undefined` for a path that names no single commit address — a nested or
+ * array-element path (`main.references.0`), a field-rooted one, or a malformed one
+ * (which `parseDocPath` throws on). A bare card and a `.body` terminal both land on
+ * the field-less `{card: i}` the body leaf answers to.
+ *
+ * Needs no `kinds`: the path carries the absolute index, and the kind in it is
+ * decoration the `Addr` has no room for.
+ */
+export declare function addrForFieldPath(path: DocPath): Addr | undefined;

package/dist/core/address.js

@@ -0,0 +1,95 @@
+// The one address vocabulary the surfaces speak in public: canonical `DocPath`
+// strings for places, `Addr` for the document verbs. Declared HERE because both
+// `/preview` and `/visual` name a place in their hooks, and a type declared twice
+// structurally is drift with nothing to catch it: `/core` is the module both
+// already import.
+//
+// Slogan: paths for places, indexes for structure ops. `Addr` (`{card?, field?}`,
+// from `@quillmark/wasm`) is the mutator currency; the conversions at the foot of
+// this module are the hop between the two. `fieldPathForAddr` and `addrForFieldPath`
+// are public, because a host given a path by a hook and holding a verb that takes an
+// `Addr` needs them; `cardPath` is the editor's own.
+import { formatDocPath, parseDocPath } from '@quillmark/wasm';
+// ── Addr ↔ DocPath ──────────────────────────────────────────────────────────
+// The one hop between the two vocabularies, both directions, pure and
+// document-free: `kinds` is the kind of each composable card by content index
+// (`doc.cards.map(c => c.kind)`), which is all the card segment needs. The editor
+// mints it off its own derived card tree rather than re-reading `doc.cards`, which
+// serializes every card per read and is not a thing to do per keystroke.
+/**
+ * A field's canonical `DocPath`, or `undefined` when `addr.card` is outside the live
+ * `kinds` array (a stale address: drop it rather than mis-target). A field-less card
+ * addresses its BODY, which is the leaf `{card: i}` names.
+ *
+ * - `{}` → `"main.body"`
+ * - `{field}` → `"main.<field>"`
+ * - `{card: i}` → `"cards.<kind>[i].body"`
+ * - `{card: i, field}` → `"cards.<kind>[i].<field>"`
+ *
+ * `cards[i]` stands in for an unknown or blank kind. The index is the addr's own: no
+ * per-kind counting, since `DocPath` addresses cards by document-array index.
+ */
+export function fieldPathForAddr(addr, kinds) {
+    const head = cardHead(addr.card, kinds);
+    if (!head)
+        return undefined;
+    const tail = addr.field != null ? { seg: 'field', name: addr.field } : { seg: 'body' };
+    return formatDocPath([head, tail]);
+}
+/**
+ * A CARD's own path (`cards.<kind>[i]`), not a leaf's: what a structure op names,
+ * where the change is the card rather than anything inside it. `undefined` for an
+ * index outside `kinds`.
+ */
+export function cardPath(index, kinds) {
+    const head = cardHead(index, kinds);
+    return head ? formatDocPath([head]) : undefined;
+}
+/**
+ * The inverse: a canonical `DocPath` back to the `Addr` the document verbs take, or
+ * `undefined` for a path that names no single commit address — a nested or
+ * array-element path (`main.references.0`), a field-rooted one, or a malformed one
+ * (which `parseDocPath` throws on). A bare card and a `.body` terminal both land on
+ * the field-less `{card: i}` the body leaf answers to.
+ *
+ * Needs no `kinds`: the path carries the absolute index, and the kind in it is
+ * decoration the `Addr` has no room for.
+ */
+export function addrForFieldPath(path) {
+    let segs;
+    try {
+        segs = parseDocPath(path);
+    }
+    catch {
+        return undefined;
+    }
+    const [head, ...rest] = segs;
+    if (!head)
+        return undefined;
+    let addr;
+    if (head.seg === 'main')
+        addr = {};
+    else if (head.seg === 'card')
+        addr = { card: head.index };
+    else
+        return undefined;
+    if (rest.length === 0)
+        return addr;
+    if (rest.length > 1)
+        return undefined;
+    const tail = rest[0];
+    if (tail.seg === 'body')
+        return addr;
+    if (tail.seg === 'field')
+        return { ...addr, field: tail.name };
+    return undefined;
+}
+/** The head segment a card index resolves to, or `undefined` when it is out of the
+ *  live array. `null` kind is the unknown-kind form the grammar spells `cards[i]`. */
+function cardHead(index, kinds) {
+    if (index == null)
+        return { seg: 'main' };
+    if (!Number.isInteger(index) || index < 0 || index >= kinds.length)
+        return undefined;
+    return { seg: 'card', kind: kinds[index] || null, index };
+}

package/dist/core/bloom.d.ts

@@ -0,0 +1,37 @@
+/** The resting state a bloom animates from and back to: the wash, held at zero. */
+export declare function primeWash(el: HTMLElement): void;
+/** What one bloom runs: resolved from the scale, and from the viewer's motion
+ *  preference. */
+export interface BloomTiming {
+    duration: number;
+    frames: Keyframe[];
+}
+/**
+ * Resolve the timing off `el`, so the dwell is single-sourced in CSS.
+ *
+ * ONE property, both motion preferences: `--_qm-bloom-dwell` already shortens under
+ * `prefers-reduced-motion` in the derivation, so what is left to `matchMedia` here is
+ * the SHAPE: a hold and a cut carry no ramps, which is a frame list rather than a
+ * number and the one half CSS cannot hand over.
+ *
+ * Read ONCE PER BATCH, not per element: `getComputedStyle` forces a style recalc and
+ * `animate` re-dirties style, so a read inside a loop flushes once per element (~0.15ms
+ * each). The rungs inherit, so every element in a batch resolves the same numbers.
+ */
+export declare function bloomTiming(el: HTMLElement): BloomTiming;
+/**
+ * Bloom the wash on `el` itself: the caller owns the element and has primed it
+ * ({@link primeWash}). Returns the running animation, or `undefined` when there is
+ * nothing left to run: `elapsed` past the decay, or an environment without WAAPI.
+ * Pass `timing` to share one resolve across a batch.
+ */
+export declare function bloom(el: HTMLElement, elapsed?: number, timing?: BloomTiming): Animation | undefined;
+/**
+ * Bloom over `host`'s CONTENT: an inset child, so the wash neither tints the host's
+ * own background nor fades the text under it. `host` must be positioned.
+ *
+ * ONE wash node per host, reused while it lives: two quick landings on the same leaf
+ * must not stack two alphas over it. No `elapsed` seam: the surfaces that use this
+ * (editor leaves) are not rebuilt under the animation the way the preview's boxes are.
+ */
+export declare function bloomInside(host: HTMLElement): void;

package/dist/core/bloom.js

@@ -0,0 +1,116 @@
+// The correlation bloom: a soft accent wash that rises over a target and decays to
+// nothing. The editor↔preview address is an EVENT, not a state: the preview claims
+// to be the rendered output, so it carries no resting ink, and a highlight that
+// outlives the hop that caused it is ink the document did not ask for. Both
+// directions land here: the preview's field boxes bloom themselves (they are already
+// empty rects over the page), an editor leaf blooms a transient child over its
+// surface.
+//
+// OPACITY is the animated property, never the colour. The wash's alpha is a peak
+// fixed by `--_qm-accent-wash`, so interpolating 0→1→0 keeps the scale in CSS where
+// `color-mix` resolves, instead of in keyframe values a script would have to
+// pre-resolve and re-resolve on a theme change.
+//
+// `elapsed` is what lets a bloom survive the element that carries it. `overlay.ts`
+// rebuilds every box on refresh and the playground recompiles 120ms after each
+// keystroke burst, so a bloom re-STARTED per rebuild would re-bloom continuously
+// while the user writes; a rebuilt node resumes at the offset the old one reached.
+/** Marks a transient wash node: the wash is decoration, never a hit target. */
+const BLOOM_CLASS = 'qm-bloom';
+const WASH = 'var(--_qm-accent-wash)';
+/** The dwell used when the derivation is out of reach (an unstyled root, or jsdom,
+ *  where `getComputedStyle` reports custom properties as empty). A fallback is the
+ *  absence of the scale, not a copy of it. */
+const FALLBACK_MS = 1100;
+// Rise fast, hold, then leave slowly: a highlighter's decay, not a linear fade. A
+// keyframe's easing governs the segment that STARTS at it. Under reduced motion the
+// ramps are dropped entirely: the wash holds at full for a beat and cuts, which
+// still answers "here" with nothing to track.
+const FRAMES = [
+    { opacity: 0, offset: 0, easing: 'ease-out' },
+    { opacity: 1, offset: 0.08 },
+    { opacity: 1, offset: 0.3, easing: 'ease-in' },
+    { opacity: 0, offset: 1 }
+];
+const FRAMES_REDUCED = [{ opacity: 1 }, { opacity: 1 }];
+/** The resting state a bloom animates from and back to: the wash, held at zero. */
+export function primeWash(el) {
+    Object.assign(el.style, { background: WASH, opacity: '0' });
+}
+/**
+ * Resolve the timing off `el`, so the dwell is single-sourced in CSS.
+ *
+ * ONE property, both motion preferences: `--_qm-bloom-dwell` already shortens under
+ * `prefers-reduced-motion` in the derivation, so what is left to `matchMedia` here is
+ * the SHAPE: a hold and a cut carry no ramps, which is a frame list rather than a
+ * number and the one half CSS cannot hand over.
+ *
+ * Read ONCE PER BATCH, not per element: `getComputedStyle` forces a style recalc and
+ * `animate` re-dirties style, so a read inside a loop flushes once per element (~0.15ms
+ * each). The rungs inherit, so every element in a batch resolves the same numbers.
+ */
+export function bloomTiming(el) {
+    const reduced = typeof matchMedia === 'function' && matchMedia('(prefers-reduced-motion: reduce)').matches;
+    const raw = getComputedStyle(el).getPropertyValue('--_qm-bloom-dwell').trim();
+    const n = Number.parseFloat(raw);
+    const duration = !Number.isFinite(n) ? FALLBACK_MS : raw.endsWith('ms') ? n : n * 1000;
+    return { duration, frames: reduced ? FRAMES_REDUCED : FRAMES };
+}
+/**
+ * Bloom the wash on `el` itself: the caller owns the element and has primed it
+ * ({@link primeWash}). Returns the running animation, or `undefined` when there is
+ * nothing left to run: `elapsed` past the decay, or an environment without WAAPI.
+ * Pass `timing` to share one resolve across a batch.
+ */
+export function bloom(el, elapsed = 0, timing) {
+    if (typeof el.animate !== 'function')
+        return undefined;
+    const { duration, frames } = timing ?? bloomTiming(el);
+    if (elapsed >= duration)
+        return undefined;
+    const anim = el.animate(frames, { duration });
+    if (elapsed > 0)
+        anim.currentTime = elapsed;
+    return anim;
+}
+/**
+ * Bloom over `host`'s CONTENT: an inset child, so the wash neither tints the host's
+ * own background nor fades the text under it. `host` must be positioned.
+ *
+ * ONE wash node per host, reused while it lives: two quick landings on the same leaf
+ * must not stack two alphas over it. No `elapsed` seam: the surfaces that use this
+ * (editor leaves) are not rebuilt under the animation the way the preview's boxes are.
+ */
+export function bloomInside(host) {
+    let el = host.querySelector(`:scope > .${BLOOM_CLASS}`);
+    if (el) {
+        // Drop the in-flight run's handlers before cancelling: its `oncancel` would
+        // otherwise remove the node the new run is about to animate.
+        for (const a of el.getAnimations()) {
+            a.onfinish = null;
+            a.oncancel = null;
+            a.cancel();
+        }
+    }
+    else {
+        el = document.createElement('div');
+        el.className = BLOOM_CLASS;
+        Object.assign(el.style, {
+            position: 'absolute',
+            inset: '0',
+            pointerEvents: 'none',
+            borderRadius: 'inherit'
+        });
+        primeWash(el);
+        host.appendChild(el);
+    }
+    const node = el;
+    const anim = bloom(node);
+    if (!anim) {
+        node.remove();
+        return;
+    }
+    const drop = () => node.remove();
+    anim.onfinish = drop;
+    anim.oncancel = drop;
+}

package/dist/core/codec/anchor.d.ts

@@ -0,0 +1,19 @@
+import type { EditorView } from 'prosemirror-view';
+/** A floating-ui `Measurable` over a PM range, carrying the `contextElement`
+ *  `autoUpdate` tracks in the range's place. */
+export interface RangeAnchor {
+    contextElement: Element;
+    getBoundingClientRect: () => DOMRect;
+}
+/**
+ * A virtual anchor over one PM range, measured when asked rather than when made.
+ *
+ * The measure is TOTAL. `coordsAtPos` reads layout, and layout can be gone: a
+ * position the document has since invalidated, a leaf inside a collapsed section, a
+ * view torn down between a scroll firing and the measure running. `autoUpdate` calls
+ * this at moments none of its callers choose, so an unmeasurable anchor returns the
+ * last rect that measured rather than throwing out of floating-ui's positioning pass.
+ *
+ * `from === to` is a caret, which is what the slash menu hangs off.
+ */
+export declare function rangeAnchor(view: EditorView, from: number, to: number): RangeAnchor;

package/dist/core/codec/anchor.js

@@ -0,0 +1,36 @@
+/**
+ * A virtual anchor over one PM range, measured when asked rather than when made.
+ *
+ * The measure is TOTAL. `coordsAtPos` reads layout, and layout can be gone: a
+ * position the document has since invalidated, a leaf inside a collapsed section, a
+ * view torn down between a scroll firing and the measure running. `autoUpdate` calls
+ * this at moments none of its callers choose, so an unmeasurable anchor returns the
+ * last rect that measured rather than throwing out of floating-ui's positioning pass.
+ *
+ * `from === to` is a caret, which is what the slash menu hangs off.
+ */
+export function rangeAnchor(view, from, to) {
+    // Plain numbers, not a `DOMRect`: this runs at construction, and the codec's suite
+    // is a `node` environment with no DOM in it. The `DOMRect` is minted in the measure,
+    // which is a layout read and browser-only by construction.
+    let last = { left: 0, top: 0, right: 0, bottom: 0 };
+    return {
+        contextElement: view.dom,
+        getBoundingClientRect: () => {
+            try {
+                const a = view.coordsAtPos(from);
+                const b = view.coordsAtPos(to);
+                last = {
+                    left: Math.min(a.left, b.left),
+                    top: Math.min(a.top, b.top),
+                    right: Math.max(a.right, b.right),
+                    bottom: Math.max(a.bottom, b.bottom)
+                };
+            }
+            catch {
+                // unmeasurable: keep the last good rect
+            }
+            return new DOMRect(last.left, last.top, last.right - last.left, last.bottom - last.top);
+        }
+    };
+}

package/dist/core/codec/code.d.ts

@@ -0,0 +1,12 @@
+import type { Schema } from 'prosemirror-model';
+import { type Command } from 'prosemirror-state';
+/**
+ * The `code_block` link of the body's key chains: `{}` for the inline/plaintext
+ * schemas, which declare no code node.
+ *
+ * `Enter` is upstream's `newlineInCode`, and it is load-bearing rather than
+ * cosmetic: inside a `list_item > code_block` the list link's `splitListItem`
+ * otherwise splits the ITEM in two, each half holding a code block. Every command
+ * here declines outside a code block, so the list links keep the keys elsewhere.
+ */
+export declare function codeKeymap(schema: Schema): Record<string, Command>;

package/dist/core/codec/code.js

@@ -0,0 +1,118 @@
+import { TextSelection } from 'prosemirror-state';
+import { newlineInCode } from 'prosemirror-commands';
+/** One indent level. */
+const UNIT = '  ';
+/** The enclosing code block's content start and text, or `null` when the selection
+ * is not wholly inside one: a selection that escapes the block is a document-level
+ * range, where the structural links keep their meaning. */
+function codeBlockAt(state) {
+    const { $from, $to } = state.selection;
+    if (!$from.parent.type.spec.code)
+        return null;
+    if ($from.parent !== $to.parent)
+        return null;
+    return { start: $from.start(), text: $from.parent.textContent };
+}
+/**
+ * Start offsets of the lines the range `[f, t)` covers, in document order.
+ *
+ * A line whose start IS `t` is excluded on a non-empty range: a selection ending at
+ * a line start does not reach into that line, the editor convention (else selecting
+ * whole lines by dragging to the next line's start indents one line too many).
+ */
+function coveredLineStarts(text, f, t) {
+    const last = t > f ? t - 1 : t;
+    const starts = [];
+    let s = 0;
+    for (const line of text.split('\n')) {
+        if (s <= last && s + line.length >= f)
+            starts.push(s);
+        s += line.length + 1;
+    }
+    return starts;
+}
+/** Width of the indent one outdent removes at line offset `s`: a leading tab, else
+ * up to one unit of leading spaces (both forms, whatever Tab inserts). `0` when the
+ * line carries no indent. */
+function outdentWidth(text, s) {
+    if (text[s] === '\t')
+        return 1;
+    let n = 0;
+    while (n < UNIT.length && text[s + n] === ' ')
+        n++;
+    return n;
+}
+/**
+ * Tab in a code block: insert one indent unit, or indent every covered line when the
+ * selection spans a newline. A single-line selection is REPLACED by the unit: Tab
+ * types, the way any other key does.
+ */
+const indentInCode = (state, dispatch) => {
+    const block = codeBlockAt(state);
+    if (!block)
+        return false;
+    const { from, to } = state.selection;
+    const f = from - block.start;
+    const t = to - block.start;
+    if (!dispatch)
+        return true;
+    const tr = state.tr;
+    if (!block.text.slice(f, t).includes('\n')) {
+        tr.insertText(UNIT, from, to);
+    }
+    else {
+        const starts = coveredLineStarts(block.text, f, t);
+        // Back to front: an earlier insert would shift every later offset.
+        for (const s of [...starts].reverse())
+            tr.insertText(UNIT, block.start + s);
+        // Keep the covered lines covered. Mapping alone would push the head past
+        // the indent it just inserted at the first line's start.
+        tr.setSelection(TextSelection.create(tr.doc, block.start + starts[0], tr.mapping.map(to)));
+    }
+    dispatch(tr.scrollIntoView());
+    return true;
+};
+/**
+ * Shift-Tab in a code block: remove one indent level from every covered line.
+ *
+ * Declines when no covered line carries an indent, so the key is NOT swallowed: it
+ * falls through to the list link and then out of the leaf, which is the body's
+ * keyboard exit from inside a code block (VISUAL_EDITOR §Chrome).
+ */
+const outdentInCode = (state, dispatch) => {
+    const block = codeBlockAt(state);
+    if (!block)
+        return false;
+    const { from, to } = state.selection;
+    const cuts = coveredLineStarts(block.text, from - block.start, to - block.start)
+        .map((s) => ({ s, width: outdentWidth(block.text, s) }))
+        .filter((c) => c.width > 0);
+    if (!cuts.length)
+        return false;
+    if (dispatch) {
+        const tr = state.tr;
+        for (const c of cuts.reverse()) {
+            tr.delete(block.start + c.s, block.start + c.s + c.width);
+        }
+        dispatch(tr.scrollIntoView());
+    }
+    return true;
+};
+/**
+ * The `code_block` link of the body's key chains: `{}` for the inline/plaintext
+ * schemas, which declare no code node.
+ *
+ * `Enter` is upstream's `newlineInCode`, and it is load-bearing rather than
+ * cosmetic: inside a `list_item > code_block` the list link's `splitListItem`
+ * otherwise splits the ITEM in two, each half holding a code block. Every command
+ * here declines outside a code block, so the list links keep the keys elsewhere.
+ */
+export function codeKeymap(schema) {
+    if (!schema.nodes.code_block)
+        return {};
+    return {
+        Tab: indentInCode,
+        'Shift-Tab': outdentInCode,
+        Enter: newlineInCode
+    };
+}

package/dist/core/codec/decode.d.ts

@@ -0,0 +1,24 @@
+import { type Node as PMNode, type Schema } from 'prosemirror-model';
+import type { Content } from '@quillmark/wasm';
+/** Code points of `s` (USV units): the iteration granularity the content speaks. */
+export declare function codePoints(s: string): string[];
+/** USV length of `s` (code points, not UTF-16 units). */
+export declare function usvLength(s: string): number;
+interface DecodeOpts {
+    /** Strip all marks (a `plaintext` field). */
+    plaintext?: boolean;
+}
+/**
+ * A `Content` as READ-ONLY DOM: decode under `schema`, then the nodes' own `toDOM`.
+ * The rendering half of the codec's job with no editing attached (no PM view, no
+ * plugins, no `contenteditable`) for chrome that must show content in the same
+ * mark vocabulary a leaf edits it in (the tips card). A second renderer over the
+ * same content would drift from `decode`; this cannot.
+ *
+ * `DOMSerializer.fromSchema` memoizes on the schema, so repeat calls build no
+ * serializer.
+ */
+export declare function renderContent(rt: Content, schema: Schema, opts?: DecodeOpts): Node;
+/** Decode a `Content` to a PM document under `schema`. */
+export declare function decode(rt: Content, schema: Schema, opts?: DecodeOpts): PMNode;
+export {};