@quillmark/svelte 0.21.0 → 0.22.0

package/dist/visual/structure.d.ts

@@ -11,22 +11,17 @@ export interface FieldModel {
     control: ControlKind;
     /** `ui.group` (undefined = ungrouped). */
     group: string | undefined;
-    /** `ui.compact`: asks to share a row with adjacent compacts. A request, not a
-     * guarantee: `placeFields` declines it for the shapes that grow (see `packable`). */
+    /** 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. */
     description: string | undefined;
-    /**
-     * Required-ness: {@link obliged}. Drives a persistent label `*`; a field never
-     * carries both it and a ghosted `default:`, that default being the whole of what
-     * retires the obligation. Persistent (schema-derived, survives filling). Label
-     * chrome only; never gates.
-     */
-    required: boolean;
-    /** Prose-leaf flags (only meaningful when `control === 'prose'` / array items). */
+    /** Prose-leaf flags (only meaningful when `control === 'prose'` / array items):
+     * one line (`oneLine`), and the literal codec (`literalText`). */
     inline: boolean;
     plaintext: boolean;
 }
@@ -161,6 +156,11 @@ 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. */
 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`. */
+export declare function literalText(f: QuillFieldSchema): boolean;
 /**
  * A scalar `default:` as the text an unset control holds, where it prints: as
  * declared, `undefined` for none, a blank or a non-scalar. A default of spaces prints
@@ -169,19 +169,18 @@ export declare function baseType(f: QuillFieldSchema): QuillFieldType;
 export declare function printedText(v: unknown): string | undefined;
 /**
  * A declared content literal as the `Content` it holds: a `richtext` one's markdown
- * imported, a `plaintext` one's text taken literally, one paragraph whose later lines
+ * imported, a `text` one's text taken literally, one paragraph whose later lines
  * continue it, as the literal codec reads a stored one. What a cell's static
  * `default:` stands in its leaf as, where no resolved row reaches it. `undefined` for
  * a blank or a non-scalar.
  */
 export declare function declaredContent(v: unknown, markdown: boolean): Content | undefined;
 /** A field's `{#each}` key: its name and what a mounted leaf reads once, its type and
- *  `inline` and its elements'. A retype or a quill swap that changes any of them under a
- *  name remounts the field, where a kept leaf would commit on the old schema. */
+ *  {@link oneLine} and its elements'. A retype or a quill swap that changes 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 (precedence: prose › enum › text › …).
- * An array's element control is this over `items`: a missing `items` is a text
- * element. */
+/** 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. */
 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
@@ -254,8 +253,8 @@ export declare function addedItems(matrix: QuillFieldSchema, map: Record<string,
  */
 export declare function addedId(title: string, taken: (id: string) => boolean): string;
 /** The `object` a matrix member is, for the schema walk: the declared columns, and an
- *  added item's `title` beside them. Composed here because the boundary serializes the
- *  roster and the columns alone. */
+ *  added item's `title`, a one-line `text` cell, beside them. Composed here because the
+ *  boundary serializes the roster and the columns alone. */
 export declare function matrixMemberSchema(matrix: QuillFieldSchema, id: string): QuillFieldSchema;
 /**
  * The schema at `steps` under `field`, or `undefined` where the schema declares no such
@@ -267,8 +266,7 @@ export declare function matrixMemberSchema(matrix: QuillFieldSchema, id: string)
  */
 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 declares `inline`, `richtext` or
- *  `plaintext` alike. */
+ *  summary can hold. A prose cell is one where it is {@link oneLine}. */
 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. */
@@ -301,19 +299,11 @@ 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;
-/**
- * Whether the schema obliges a cell: `default:`'s absence, which is the whole of the
- * obligation (DOCUMENT_MODEL). Exempt are the cells whose absence of one says nothing:
- * a typed dictionary, since a namespace declares no `default:` at all and `validate`
- * anchors obligation on the leaves under it; a matrix, whose blank is nothing held, a
- * whole answer; and an optional cell, which can declare none, its unanswered render
- * being `none`.
- */
-export declare function obliged(schema: QuillFieldSchema): boolean;
 /** `foo_bar` → `Foo bar`: the label fallback when a field declares no `title`. */
 export declare function humanize(name: string): string;
-/** Project a card schema's `fields` map (declaration = key order) into models. */
-export declare function fieldModels(cardSchema: QuillCardSchema): FieldModel[];
+/** 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

package/dist/visual/structure.js

@@ -84,6 +84,15 @@ export function optionalCell(f) {
 export function baseType(f) {
     return (optionalCell(f) ? f.type.slice(0, -1) : f.type);
 }
+/** 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 function oneLine(f) {
+    return f.multiline !== true;
+}
+/** Whether a content field's codec is the literal one, its value text with no marks: `text`. */
+export function literalText(f) {
+    return baseType(f) === 'text';
+}
 /**
  * A scalar `default:` as the text an unset control holds, where it prints: as
  * declared, `undefined` for none, a blank or a non-scalar. A default of spaces prints
@@ -95,7 +104,7 @@ export function printedText(v) {
 }
 /**
  * A declared content literal as the `Content` it holds: a `richtext` one's markdown
- * imported, a `plaintext` one's text taken literally, one paragraph whose later lines
+ * imported, a `text` one's text taken literally, one paragraph whose later lines
  * continue it, as the literal codec reads a stored one. What a cell's static
  * `default:` stands in its leaf as, where no resolved row reaches it. `undefined` for
  * a blank or a non-scalar.
@@ -118,25 +127,23 @@ export function declaredContent(v, markdown) {
     };
 }
 /** A field's `{#each}` key: its name and what a mounted leaf reads once, its type and
- *  `inline` and its elements'. A retype or a quill swap that changes any of them under a
- *  name remounts the field, where a kept leaf would commit on the old schema. */
+ *  {@link oneLine} and its elements'. A retype or a quill swap that changes any of them
+ *  under a name remounts the field, where a kept leaf would commit on the old schema. */
 export function mountKey(name, f) {
-    return `${name}\u0000${f.type}\u0000${f.inline === true}\u0000${f.items?.type ?? ''}\u0000${f.items?.inline === true}`;
+    const items = f.items;
+    return `${name}\u0000${f.type}\u0000${oneLine(f)}\u0000${items?.type ?? ''}\u0000${items ? oneLine(items) : ''}`;
 }
-/** Map a field schema to its control (precedence: prose › enum › text › …).
- * An array's element control is this over `items`: a missing `items` is a text
- * element. */
+/** 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. */
 export function controlKind(f) {
     switch (baseType(f)) {
         case 'richtext':
-        case 'plaintext':
+        case 'text':
             return 'prose';
         case 'enum':
             // `variants:` is the one key that changes a field's resting shape (canon
             // `SCHEMAS.md`): with it the field rests as a container, without it a bare string.
             return f.variants ? 'variant' : 'enum';
-        case 'string':
-            return 'text';
         case 'number':
         case 'integer':
             return 'number';
@@ -300,13 +307,13 @@ export function addedId(title, taken) {
     return `${base}_${n}`;
 }
 /** The `object` a matrix member is, for the schema walk: the declared columns, and an
- *  added item's `title` beside them. Composed here because the boundary serializes the
- *  roster and the columns alone. */
+ *  added item's `title`, a one-line `text` cell, beside them. Composed here because the
+ *  boundary serializes the roster and the columns alone. */
 export function matrixMemberSchema(matrix, id) {
     const columns = matrix.properties ?? {};
     return {
         type: 'object',
-        properties: onRoster(matrix, id) ? columns : { [MATRIX_TITLE]: { type: 'string' }, ...columns }
+        properties: onRoster(matrix, id) ? columns : { [MATRIX_TITLE]: { type: 'text' }, ...columns }
     };
 }
 // ── The schema walk ──────────────────────────────────────────────────────────
@@ -330,7 +337,7 @@ export function schemaAt(field, steps) {
 /** What an array declaring no `items` holds, the walk's copy of the element control
  *  {@link controlKind} names for one: a text element, so an index into such an array is
  *  a place and not a refusal. */
-const UNDECLARED_ELEMENT = { type: 'string' };
+const UNDECLARED_ELEMENT = { type: 'text' };
 function stepInto(schema, step) {
     switch (controlKind(schema)) {
         case 'array':
@@ -361,17 +368,16 @@ function stepInto(schema, step) {
 }
 // ── Row summaries and layouts ────────────────────────────────────────────────
 /** 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 declares `inline`, `richtext` or
- *  `plaintext` alike. */
+ *  summary can hold. A prose cell is one where it is {@link oneLine}. */
 export function shortCell(sub) {
     const kind = controlKind(sub);
     if (kind === 'prose')
-        return !!sub.inline;
+        return oneLine(sub);
     return (kind === 'text' || kind === 'enum' || kind === 'number' || kind === 'boolean' || kind === 'date');
 }
 /**
- * The first short text cell's words — the first `string`, or inline `richtext` /
- * `plaintext`, in declaration order — read through {@link titleText}; `undefined` where
+ * The first short text cell's words — the first one-line `text` or `richtext`, in
+ * declaration order — read through {@link titleText}; `undefined` where
  * there is no such cell or it is empty. The cell is picked by the schema alone, so an
  * instance is named by one cell whatever the others hold. What names an instance from
  * its own values: a collapsed row, and a card whose kind declares no `title`.
@@ -435,39 +441,36 @@ export function commitDiscriminant(value, member) {
     delete next[VARIANT_DISCRIMINANT];
     return Object.keys(next).length ? next : undefined;
 }
-/**
- * Whether the schema obliges a cell: `default:`'s absence, which is the whole of the
- * obligation (DOCUMENT_MODEL). Exempt are the cells whose absence of one says nothing:
- * a typed dictionary, since a namespace declares no `default:` at all and `validate`
- * anchors obligation on the leaves under it; a matrix, whose blank is nothing held, a
- * whole answer; and an optional cell, which can declare none, its unanswered render
- * being `none`.
- */
-export function obliged(schema) {
-    return (schema.type !== 'object' &&
-        schema.type !== 'matrix' &&
-        !optionalCell(schema) &&
-        schema.default === undefined);
-}
 /** `foo_bar` → `Foo bar`: the label fallback when a field declares no `title`. */
 export function humanize(name) {
     const spaced = name.replace(/_/g, ' ').trim();
     return spaced ? spaced[0].toUpperCase() + spaced.slice(1) : spaced;
 }
-/** Project a card schema's `fields` map (declaration = key order) into models. */
+/**
+ * Whether a field asks to share a row when its `ui.compact` is undeclared: a control
+ * whose type bounds its width. Text never does, its type saying nothing of whether a
+ * value is a rank or a subject line, so a short text field asks with `compact: true`.
+ */
+function packsByDefault(control) {
+    return control === 'date' || control === 'enum' || control === 'number' || control === 'boolean';
+}
+/** Project a card schema's `fields` map (declaration = key order) into models. A
+ *  card-level object's `properties` project the same way. */
 export function fieldModels(cardSchema) {
-    return Object.entries(cardSchema.fields).map(([name, schema]) => ({
-        name,
-        schema,
-        control: controlKind(schema),
-        group: schema.ui?.group,
-        compact: !!schema.ui?.compact,
-        label: schema.title ?? humanize(name),
-        description: schema.description,
-        required: obliged(schema),
-        inline: !!schema.inline,
-        plaintext: baseType(schema) === 'plaintext'
-    }));
+    return Object.entries(cardSchema.fields).map(([name, schema]) => {
+        const control = controlKind(schema);
+        return {
+            name,
+            schema,
+            control,
+            group: schema.ui?.group,
+            compact: schema.ui?.compact ?? packsByDefault(control),
+            label: schema.title ?? humanize(name),
+            description: schema.description,
+            inline: oneLine(schema),
+            plaintext: literalText(schema)
+        };
+    });
 }
 /**
  * Group-section order (VISUAL_EDITOR §"Structure mirrors the schema"): the schema's `ui.groups` registry
@@ -543,12 +546,12 @@ export function initialExpandedGroup(sections) {
     return sections.find((s) => s.group != null)?.group ?? null;
 }
 /**
- * Whether a field can share a row. `ui.compact` asks; a shape declines when the
+ * Whether a field can share a row. `compact` asks; a shape declines when the
  * document sets its height, because a row is as tall as its tallest cell and the cell
- * beside it does not grow in step: an object nests a whole field set, block richtext
- * (`inline` absent) holds paragraphs, and an array holds however many elements the
- * document carries. Any of them stands its neighbour in a column of whitespace. An
- * inline prose leaf is one line tall and packs like any scalar.
+ * beside it does not grow in step: an object nests a whole field set, a multiline prose
+ * leaf holds paragraphs or lines, and an array holds however many elements the
+ * document carries. Any of them stands its neighbour in a column of whitespace. A
+ * one-line prose leaf packs like any scalar.
  *
  * A variant declines for the same reason one step further in: its height is the live
  * world's cell count, so it is set by a pick rather than only by the document, and a

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@quillmark/svelte",
-	"version": "0.21.0",
+	"version": "0.22.0",
 	"description": "Editor, live-preview and source surfaces over a Quillmark WASM session.",
 	"repository": {
 		"type": "git",
@@ -23,7 +23,7 @@
 	"author": "Quillmark Contributors",
 	"type": "module",
 	"engines": {
-		"node": ">=24"
+		"node": ">=22"
 	},
 	"svelte": "./dist/index.js",
 	"types": "./dist/index.d.ts",
@@ -69,7 +69,7 @@
 		"check": "svelte-check --tsconfig ./tsconfig.json --fail-on-warnings"
 	},
 	"peerDependencies": {
-		"@quillmark/wasm": ">=0.125.0-0",
+		"@quillmark/wasm": ">=0.126.0-0",
 		"svelte": "^5.33.0"
 	},
 	"dependencies": {