@quillmark/svelte 0.27.0 → 0.28.0

package/dist/visual/fonts.d.ts

@@ -0,0 +1,18 @@
+import type { FontFace as LibraryFace } from '@quillmark/wasm';
+import type { Command, EditorState } from 'prosemirror-state';
+/** The families `faces` offer, each once, in the library's order. */
+export declare function familiesOf(faces: readonly LibraryFace[]): string[];
+/**
+ * Register `faces` with `set` and return what takes them back out. A face past the
+ * first in a collection is left out, a CSS face drawing a collection's first alone, so
+ * its family draws in the root face here while the preview sets it. A face the browser
+ * refuses draws the same way, and a page with no Font Loading API registers nothing.
+ */
+export declare function registerFaces(faces: readonly LibraryFace[], set?: FontFaceSet | undefined): () => void;
+/**
+ * The family the selection's text is set in: its name, `''` where it sets none, `null`
+ * where it sets more than one or holds no text.
+ */
+export declare function familyInSelection(state: EditorState): string | null;
+/** Set the selection in `name`, or in the surrounding face where `name` is `''`. */
+export declare function setFamily(name: string): Command;

package/dist/visual/fonts.js

@@ -0,0 +1,59 @@
+/** The families `faces` offer, each once, in the library's order. */
+export function familiesOf(faces) {
+    return [...new Set(faces.map((face) => face.family))];
+}
+/**
+ * Register `faces` with `set` and return what takes them back out. A face past the
+ * first in a collection is left out, a CSS face drawing a collection's first alone, so
+ * its family draws in the root face here while the preview sets it. A face the browser
+ * refuses draws the same way, and a page with no Font Loading API registers nothing.
+ */
+export function registerFaces(faces, set = globalThis.document?.fonts) {
+    if (!set || typeof FontFace === 'undefined')
+        return () => { };
+    const added = [];
+    for (const face of faces) {
+        if (face.index !== 0)
+            continue;
+        const css = new FontFace(face.family, face.data, {
+            weight: String(face.weight),
+            style: face.style
+        });
+        css.loaded.catch(() => set.delete(css));
+        set.add(css);
+        added.push(css);
+    }
+    return () => {
+        for (const css of added)
+            set.delete(css);
+    };
+}
+/**
+ * The family the selection's text is set in: its name, `''` where it sets none, `null`
+ * where it sets more than one or holds no text.
+ */
+export function familyInSelection(state) {
+    const type = state.schema.marks.font_family;
+    const { from, to } = state.selection;
+    const seen = new Set();
+    state.doc.nodesBetween(from, to, (node) => {
+        if (!node.isText)
+            return;
+        seen.add(type ? String(type.isInSet(node.marks)?.attrs.name ?? '') : '');
+    });
+    return seen.size === 1 ? [...seen][0] : null;
+}
+/** Set the selection in `name`, or in the surrounding face where `name` is `''`. */
+export function setFamily(name) {
+    return (state, dispatch) => {
+        const type = state.schema.marks.font_family;
+        const { from, to, empty } = state.selection;
+        if (!type || empty)
+            return false;
+        if (dispatch) {
+            const tr = state.tr.removeMark(from, to, type);
+            dispatch(name ? tr.addMark(from, to, type.create({ name })) : tr);
+        }
+        return true;
+    };
+}

package/dist/visual/icons/nodes.d.ts

@@ -127,11 +127,6 @@ export declare const ICONS: {
     }], readonly ["path", {
         readonly d: "M12 5v14";
     }]];
-    readonly x: readonly [readonly ["path", {
-        readonly d: "M18 6 6 18";
-    }], readonly ["path", {
-        readonly d: "m6 6 12 12";
-    }]];
     readonly 'trash-2': readonly [readonly ["path", {
         readonly d: "M10 11v6";
     }], readonly ["path", {

package/dist/visual/icons/nodes.js

@@ -70,10 +70,6 @@ export const ICONS = {
         ['path', { d: 'M5 12h14' }],
         ['path', { d: 'M12 5v14' }]
     ],
-    x: [
-        ['path', { d: 'M18 6 6 18' }],
-        ['path', { d: 'm6 6 12 12' }]
-    ],
     'trash-2': [
         ['path', { d: 'M10 11v6' }],
         ['path', { d: 'M14 11v6' }],

package/dist/visual/props.d.ts

@@ -1,4 +1,4 @@
-import type { Document, Quill, Addr, Diagnostic } from '@quillmark/wasm';
+import type { Document, Quill, Addr, Diagnostic, FontFace } from '@quillmark/wasm';
 import type { Place } from '../core/address.js';
 import type { EditorErrorHandler } from '../core/errors.js';
 import type { ActiveLeaf, EditorChange } from './signals.js';
@@ -81,6 +81,19 @@ export interface VisualEditorProps {
      * (VISUAL_EDITOR §"Enum policy").
      */
     enumDisallowed?: 'hide' | 'disable';
+    /**
+     * The faces a `font_family` mark may set: `await engine.fontFaces(quill)`, over an
+     * engine built with the host's `fonts`. The format popover offers each family, and
+     * the editor registers each face with the page for as long as it is mounted, so a
+     * run draws in the face the preview sets it in. Absent or empty, no family is
+     * offered, and a family the document already sets still edits and can be cleared.
+     */
+    fonts?: FontFace[];
+    /**
+     * The name the picker shows for a family, keyed by the family the mark saves. A
+     * family missing here shows as itself.
+     */
+    fontLabels?: Readonly<Record<string, string>>;
     /**
      * Every word the surface says, keyed and partial: unset keys take the package's
      * English. Several are accessible names rather than decoration, so this is what

package/dist/visual/strings.d.ts

@@ -81,6 +81,13 @@ export interface VisualStrings extends TableChromeStrings, SlashStrings {
     formatLink: string;
     formatNumberedList: string;
     formatBulletedList: string;
+    /** The font picker's accessible name; drawn only where the host hands the editor a
+     *  font library or the selection sets a family. */
+    formatFont: string;
+    /** The picker's option that sets no family: the text takes the surrounding face. */
+    fontDefault: string;
+    /** What the picker reads over a selection setting more than one family. */
+    fontMixed: string;
     /** The anchor button's accessible name. The popover withholds the button, so
      *  nothing draws this or the title below. */
     formatAnchor: string;

package/dist/visual/strings.js

@@ -60,11 +60,14 @@ export const DEFAULT_VISUAL_STRINGS = {
     formatBold: `Bold (${chord('B')})`,
     formatEmphasis: `Italic (${chord('I')})`,
     formatUnderline: `Underline (${chord('U')})`,
-    formatStrikethrough: 'Strikethrough',
-    formatCode: 'Code',
+    formatStrikethrough: `Strikethrough (${chord('Shift-X')})`,
+    formatCode: `Code (${chord('E')})`,
     formatLink: `Link (${chord('K')})`,
     formatNumberedList: `Numbered list (${chord('Shift-7')})`,
     formatBulletedList: `Bulleted list (${chord('Shift-8')})`,
+    formatFont: 'Font',
+    fontDefault: 'Default font',
+    fontMixed: 'Mixed fonts',
     formatAnchor: 'Anchor',
     formatAnchorTitle: 'Anchor — an identity handle over the selection',
     linkPlaceholder: 'https://…',

package/dist/visual/structure.d.ts

@@ -10,19 +10,15 @@ export interface FieldModel {
     name: string;
     schema: QuillFieldSchema;
     control: ControlKind;
-    /** `ui.group` (undefined = ungrouped). */
     group: string | undefined;
     /** Asks to share a row with adjacent compacts: `ui.compact` when declared, else
      * {@link packsByDefault}. A request, not a guarantee: `placeFields` declines it for
      * the shapes that grow (see `packable`). */
     compact: boolean;
-    /** Display label: `title` when set, else the humanized field name. */
     label: string;
-    /** Schema `description`: authoring help rendered beside the label,
-     * undefined when the field declares none. Chrome-only; never gates. */
+    /** Chrome-only; never gates. */
     description: string | undefined;
-    /** Prose-leaf flags (only meaningful when `control === 'prose'` / array items):
-     * one line (`oneLine`), and the literal codec (`literalText`). */
+    /** Prose-leaf flags: {@link oneLine} and {@link literalText}. */
     inline: boolean;
     plaintext: boolean;
 }
@@ -37,13 +33,9 @@ export interface GroupSection {
      * `object`. Its properties draw flat, the panel being their frame. */
     head?: FieldModel;
 }
-/**
- * One card instance projected for rendering: the schema × payload join result
- * the VisualEditor's `$derived` produces and hands to `<Card>`. Positional
- * identity is carried by `id` (a session key), not by array index.
- */
+/** One card instance projected for rendering. Identity is `id` (a session key), not array index. */
 export interface CardModel {
-    /** Stable session id (`'main'` for the main card). */
+    /** `'main'` for the main card. */
     id: string;
     isMain: boolean;
     kind: string;
@@ -60,7 +52,6 @@ export interface CardModel {
     /** The header an unrenamed card shows ({@link cardTitle} below its rename rung),
      *  which the rename input ghosts (composable cards). */
     titlePlaceholder: string;
-    /** Field name → current stored value (absent fields missing). */
     values: Record<string, unknown>;
     /**
      * Field name → its resolved provenance row (`{ value, source }`), parallel to
@@ -80,43 +71,33 @@ export interface CardModel {
      */
     bodyGhost?: string;
 }
-/**
- * A card's resolved rows keyed by field name: the provenance channel parallel to
- * {@link CardModel.values}. `resolve` returns rows in declaration order; the
- * editor keys them the same way `values` keys its payload walk, so a field's value
- * and its provenance resolve under one name.
- */
+/** A card's resolved rows keyed by field name, parallel to {@link CardModel.values}. */
 export declare function provenanceMap(fields: ResolvedField[]): Record<string, ResolvedField>;
-/** A card's resolved rows: its declared fields, and the `body` sibling `resolve`
- * hangs off each card. */
+/** A card's resolved fields and its `body` sibling. */
 export interface ResolvedCardRows {
     fields: ResolvedField[];
     body: ResolvedField | null;
 }
-/** The empty rows a card with no resolve entry reads: a shared constant so the
- * per-card miss allocates nothing. */
+/** Shared so a per-card miss allocates nothing. */
 export declare const NO_RESOLVED_ROWS: ResolvedCardRows;
 /**
- * Composable cards' resolved rows keyed by document index (`ResolvedCard.index`,
- * not array position, so it holds whatever order the resolve view returns): built
- * once per derive, so the per-card provenance join is O(1). Both channels ride one
- * entry: a card reads its fields and its body from a single lookup. Empty map when
- * `resolved` is absent (a `resolve` failure degrades to no ghosts, never a blank
- * form).
+ * Resolved rows keyed by `ResolvedCard.index`, not array position. Empty when `resolved` is absent:
+ * a `resolve` failure degrades to no ghosts, never a blank form.
  */
 export declare function resolvedByCardIndex(resolved: Resolved | undefined): Map<number, ResolvedCardRows>;
 /** What an unset field shows of its `default:`: the resolved value the render would
  * use (`source === 'default'`), else undefined: an `authored` field shows its value,
  * a `blank` field has no default to show. */
 export declare function ghostDefault(row: ResolvedField | undefined): unknown;
-/** A stored `boolean` cell as the render reads it: a boolean, `true` or `false` in any
- * case, or a number by whether it is non-zero; undefined where the render refuses the
- * value. Quillmark's coercion, restated, so the suite holds it to `reader.resolve()`. */
+/**
+ * A stored `boolean` cell as the render reads it (Quillmark's coercion, held to `reader.resolve()`
+ * by the suite); undefined where the render refuses it.
+ */
 export declare function renderedBoolean(value: unknown): boolean | undefined;
-/** A ghost value's string form, or undefined for null/object (only text ghosts
- * render a placeholder). A scalar's resolved default reads through it; a content
- * field's resolves as `Content`, which a prose leaf reads by its text instead
- * ({@link titleText}). */
+/**
+ * A ghost value's string form, or undefined for null/object. A content field's default resolves as
+ * `Content` and is read by its text ({@link titleText}).
+ */
 export declare function stringifyGhost(ghost: unknown): string | undefined;
 /** What a {@link BodyPlaceholder} is told about the body it words. The card's
  *  identity, not its chrome: `cardId` is what per-card wording keys off, `kind` keys
@@ -153,13 +134,15 @@ export declare function resolveBodyGhost(resolvedDefault: string | undefined, cu
 /** Whether a cell is optional: a `t?` type, which renders `none` unanswered and so
  *  never declares a `default:` (canon `SCHEMAS.md` §"Optional cells"). */
 export declare function optionalCell(f: QuillFieldSchema): boolean;
-/** The type a cell's control reads: the declared one, an optional cell's `?` stripped.
- *  The `?` moves the render floor and nothing else, so every read of a type is this. */
+/**
+ * The declared type with an optional cell's `?` stripped; the `?` moves the render floor and
+ * nothing else.
+ */
 export declare function baseType(f: QuillFieldSchema): QuillFieldType;
 /** Whether a content field is one line: one paragraph, no container, no island. A `text`
  *  or `richtext` field is one line unless it declares `multiline: true`. */
 export declare function oneLine(f: QuillFieldSchema): boolean;
-/** Whether a content field's codec is the literal one, its value text with no marks: `text`. */
+/** Whether a content field's codec is the literal one: `text`. */
 export declare function literalText(f: QuillFieldSchema): boolean;
 /** The character cap a content field's `max:` declares, `undefined` on any other. */
 export declare function textCap(f: QuillFieldSchema | undefined): TextCap | undefined;
@@ -182,8 +165,7 @@ export declare function declaredContent(v: unknown, markdown: boolean): Content
  *  any of them under a name remounts the field, where a kept leaf would commit on the old
  *  schema. */
 export declare function mountKey(name: string, f: QuillFieldSchema): string;
-/** Map a field schema to its control. An array's element control is this over `items`;
- *  a type this build does not know takes the text input. */
+/** An array's element control is this over `items`; an unknown type takes the text input. */
 export declare function controlKind(f: QuillFieldSchema): ControlKind;
 /** The discriminant cell of a variant container, off the boundary's own constant: it
  *  crosses inside untyped container data with no type to read it off, so a literal here
@@ -233,7 +215,6 @@ export declare function memberWrite(columns: Record<string, unknown>, title?: st
 /** Whether `id` is spelled as a matrix id: snake_case, the rule the roster's ids and
  *  an added item's key share. */
 export declare function matrixId(id: string): boolean;
-/** Whether `id` is on the roster. */
 export declare function onRoster(matrix: QuillFieldSchema, id: string): boolean;
 /**
  * Whether a step under the matrix names a member, judged on the schema alone as an
@@ -268,11 +249,11 @@ export declare function matrixMemberSchema(matrix: QuillFieldSchema, id: string)
  * before it asks the mounted tree for it (VISUAL_EDITOR §Surface).
  */
 export declare function schemaAt(field: QuillFieldSchema, steps: readonly PathStep[]): QuillFieldSchema | undefined;
-/** Whether a cell is one line tall by declaration: the shape a table column and a row
- *  summary can hold. A prose cell is one where it is {@link oneLine}. */
+/**
+ * Whether a cell is one line tall by declaration: what a table column and a row summary can hold.
+ */
 export declare function shortCell(sub: QuillFieldSchema): boolean;
-/** A collapsed row's own words ({@link firstShortText}); `undefined` while the row has
- *  nothing to say for itself. */
+/** A collapsed row's own words ({@link firstShortText}). */
 export declare function rowSummary(items: QuillFieldSchema | undefined, row: unknown): string | undefined;
 /** How an `array` draws its elements. */
 export type ArrayLayout = 'list' | 'table';
@@ -302,30 +283,21 @@ export declare function variantCells(schema: QuillFieldSchema, member: string |
  * `undefined`.
  */
 export declare function commitDiscriminant(value: Record<string, unknown> | undefined, member: string | undefined): Record<string, unknown> | undefined;
-/** `foo_bar` → `Foo bar`: the label fallback when a field declares no `title`. */
+/** `foo_bar` → `Foo bar`. */
 export declare function humanize(name: string): string;
 /** Project a card schema's `fields` map (declaration = key order) into models. A
  *  card-level object's `properties` project the same way. */
 export declare function fieldModels(cardSchema: Pick<QuillCardSchema, 'fields'>): FieldModel[];
 /**
- * Group-section order (VISUAL_EDITOR §"Structure mirrors the schema"): the schema's `ui.groups` registry
- * key order when present: `QuillCardUi.groups` is a typed `Record` at the
- * boundary, so this reads it uncast: else the first-appearance order of each
- * field's `ui.group`.
+ * Group-section order (VISUAL_EDITOR §"Structure mirrors the schema"): the `ui.groups` key order,
+ * else first appearance of each field's `ui.group`.
  */
 export declare function groupOrder(cardSchema: QuillCardSchema): string[];
-/**
- * A group's display label: the `ui.groups[g].title` override when the registry
- * declares one, else the humanized id (`memo_for` → "Memo for"): the same
- * id-derives-the-label rule a field's key follows.
- */
+/** A group's `ui.groups[g].title`, else the humanized id. */
 export declare function groupLabel(cardSchema: QuillCardSchema, group: string): string;
 /**
- * Sort field models into ordered group sections. Declared groups first (in
- * `order`), each carrying its fields in declaration order; then any remaining
- * groups (including the ungrouped bucket) in first-appearance order. `labelFor`
- * resolves a group id to its display label: always {@link groupLabel} bound to
- * the card schema, which falls back to {@link humanize} itself.
+ * Declared groups first (in `order`), then any remaining groups, including the ungrouped bucket, in
+ * first-appearance order.
  */
 export declare function groupSections(fields: FieldModel[], order: string[], labelFor: (group: string) => string): GroupSection[];
 /**
@@ -342,18 +314,9 @@ export declare function objectSections(fields: FieldModel[]): GroupSection[];
  */
 export declare function cardSections(cardSchema: QuillCardSchema): GroupSection[];
 /**
- * The group section a card's accordion opens on first mount: the first in
- * order, or `null` when the card declares none. Ungrouped fields render outside
- * the accordion, so only `group != null` sections count.
- *
- * A card opens on fields. All-collapsed paints as a stack of chevrons that name
- * their sections and disclose nothing of what is behind them, and a body leaf is
- * no substitute: on a card carrying both, the fields are what the card is for.
- * The first section is the one `ui.groups` already ranks highest, and it is the
- * same section on every mount: a rule keyed on document state would move the
- * opening under a user as they fill.
- *
- * State is ephemeral session state the Card owns; this only seeds it.
+ * The group section a card's accordion opens on first mount, or `null` when the card declares none.
+ * All-collapsed would disclose nothing of what is behind the chevrons, and a rule keyed on document
+ * state would move the opening under a user as they fill.
  */
 export declare function initialExpandedGroup(sections: GroupSection[]): string | null;
 /** How wide a field sits in its section grid. */
@@ -363,15 +326,9 @@ export interface PlacedField {
     span: FieldSpan;
 }
 /**
- * Assign each field its span in the section grid. Consecutive packable fields are
- * `cell`s the grid auto-places: capacity and wrapping are the container query's
- * business, so a trailing orphan keeps its column width rather than growing to fill.
- * A run of one is stranded — nothing packed beside it, and no row above to align to —
- * so it is `full` like the shapes that declined: a lone narrow track reads as truncated
- * against the width it leaves empty, and sharing was the whole of what asked for it.
- * Everything else is `full`.
- *
- * Pure, and stays pure: no width, no measurement, nothing to re-derive on resize.
+ * Consecutive packable fields are `cell`s the grid auto-places; a trailing orphan keeps its column
+ * width. A run of one is `full`: a lone narrow track reads as truncated against the width it leaves
+ * empty. Everything else is `full`. No width is measured.
  */
 export declare function placeFields(fields: FieldModel[]): PlacedField[];
 /** A card's field values by key, off its payload items. */
@@ -391,12 +348,11 @@ export declare function kindTitle(cardSchema: QuillCardSchema | undefined, kind:
  * renames fall through, so a cleared rename reverts to what the schema says.
  */
 export declare function cardTitle(cardSchema: QuillCardSchema | undefined, kind: string, values: Record<string, unknown>, extTitle: string | undefined): string;
-/** Whether a card kind renders a body leaf: gated by `body.enabled !== false`. */
 export declare function bodyEnabled(cardSchema: QuillCardSchema | undefined): boolean;
-/** A monotonic per-session id source. Ids are opaque strings, stable for the
- * session; a fresh array for N existing instances is `seq.take(N)`, and an id
- * resolves to its current index by `ids.indexOf(id)` (-1 once the instance is
- * gone): read at the mutation boundary, never cached. */
+/**
+ * A monotonic per-session id source of opaque strings. An id resolves to its index by
+ * `ids.indexOf(id)` at the mutation boundary, never cached.
+ */
 export declare class IdSeq {
     #private;
     next(): string;