@quillmark/svelte 0.16.0 → 0.18.0

package/dist/visual/structure.js

@@ -11,6 +11,11 @@ import { core } from '../core/lifecycle.js';
 export function isContainer(kind) {
     return kind === 'array' || kind === 'object' || kind === 'variant' || kind === 'matrix';
 }
+/** `ui.layout: flat` on a typed dictionary: no frame of its own, its properties
+ *  standing at the depth of the fields around it rather than a rung in. */
+export function flatObject(schema) {
+    return controlKind(schema) === 'object' && schema.ui?.layout === 'flat';
+}
 /**
  * A card's resolved rows keyed by field name: the provenance channel parallel to
  * {@link CardModel.values}. `resolve` returns rows in declaration order; the
@@ -40,6 +45,18 @@ export function resolvedByCardIndex(resolved) {
 export function ghostDefault(row) {
     return row?.source === 'default' ? row.value : undefined;
 }
+/** 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. The engine's coercion, restated, so the suite holds it to `reader.resolve()`. */
+export function renderedBoolean(value) {
+    if (typeof value === 'boolean')
+        return value;
+    if (typeof value === 'number')
+        return value !== 0;
+    if (typeof value === 'string' && /^(true|false)$/i.test(value))
+        return value.toLowerCase() === 'true';
+    return 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
@@ -142,10 +159,10 @@ export function controlKind(f) {
  *  crosses inside untyped container data with no type to read it off, so a literal here
  *  would be a second spelling of a reserved key. No variant may declare it. */
 export const VARIANT_DISCRIMINANT = VARIANT_DISCRIMINANT_KEY;
-/** The tick cell of a matrix member, the second reserved key beside the discriminant.
- *  The boundary synthesizes it on every member and exports no constant for it, so this
- *  is where the package spells it once (canon `SCHEMAS.md` §Matrix). */
-export const MATRIX_HELD = 'held';
+/** The label key of an open matrix's added item, the one cell a roster member never
+ *  stores. The boundary exports no constant for it, so the package spells it once
+ *  (canon `SCHEMAS.md` §Matrix). */
+export const MATRIX_TITLE = 'title';
 /** The roster's members, in declaration order. Own keys only: a schema map is indexed
  *  by a document-supplied id, and `'toString' in members` is true of every roster. */
 export function matrixMembers(roster) {
@@ -157,17 +174,14 @@ export function memberValue(map, id) {
     return map && Object.hasOwn(map, id) ? map[id] : undefined;
 }
 /**
- * Whether a stored member is held. A bare scalar is the tick and a mapping is the member
- * object, whose `held` cell resolves as every absent cell does, to its `default:` of
- * `false` (canon `SCHEMAS.md` §Matrix): an absent key is unheld, a bare `true` is held,
- * and a member object is held only where its `held` cell says so. The spellings the
- * engine coerces to false — `false`, `0`, `"false"`, `null` — read false here; every other
- * present scalar reads held, so a document the engine would refuse still draws the tick
- * its spelling claims.
+ * Whether a stored member is held: by being present. A mapping is held whatever it
+ * carries, `{}` included, and a bare scalar is the tick itself, read as the engine's
+ * coercion reads it: `false`, `0`, `"false"` and `null` unheld, every other present
+ * scalar held, so a spelling the engine would refuse still draws the tick it claims.
  */
 export function matrixHeld(stored) {
     if (typeof stored === 'object' && stored !== null)
-        return (Object.hasOwn(stored, MATRIX_HELD) && tickOf(stored[MATRIX_HELD]));
+        return true;
     return tickOf(stored);
 }
 /** A tick's scalar reading: absent and the engine's false spellings unheld, the rest held. */
@@ -182,20 +196,29 @@ function tickOf(v) {
         return v !== 'false';
     return true;
 }
-/** A member's columns: the member object with its `held` cell taken out, `{}` for the
- *  bare and absent spellings. What the columns subform takes as its value. */
+/** The keys no column may take (`quill::matrix_reserved_column`): an added item's
+ *  label, and the `held` a member never stores. */
+const MATRIX_RESERVED = [MATRIX_TITLE, 'held'];
+/** A member's columns: its mapping without the reserved keys, `{}` for a bare tick or an
+ *  absent member. What the columns subform takes as its value, so an edit writes back
+ *  no `held` a document stored (`validation::held_stored`). */
 export function matrixColumns(stored) {
     if (typeof stored !== 'object' || stored === null || Array.isArray(stored))
         return {};
     const rest = { ...stored };
-    delete rest[MATRIX_HELD];
+    for (const key of MATRIX_RESERVED)
+        delete rest[key];
     return rest;
 }
+/** What a matrix holding nothing commits: the unset field where unset prints nothing
+ *  held, and the authored `{}` where it would print a `default:` or `none` instead. */
+export function matrixEmpty(matrix) {
+    return matrix.default !== undefined || optionalCell(matrix) ? {} : undefined;
+}
 /**
  * The map after one member moves: `next` written under `id`, or the key dropped where
  * `next` is `undefined`; a map left holding nothing is an unset field. Every other
- * member rides through in the spelling the document had, so a stored `cyber_200: true`
- * stays `true` while its neighbour is edited.
+ * member rides through in the spelling the document had.
  */
 export function commitMember(map, id, next) {
     const out = { ...(map ?? {}) };
@@ -206,33 +229,86 @@ export function commitMember(map, id, next) {
     return Object.keys(out).length ? out : undefined;
 }
 /**
- * The member a tick or an edit writes. Held with columns is the member object with an
- * explicit `held: true`; unheld keeps the columns under `held: false`, so tick, type,
- * untick, retick loses nothing; unheld with no columns is `undefined`, the key dropped.
- * Which columns are blank is the engine's rule and not restated here: a column control
- * that clears drops its key (`ObjectField`), so a member emptied by hand arrives with no
- * columns and only then leaves the map.
+ * The held member a tick or an edit writes: its columns, the bare tick `true` where
+ * it answers none, and an added item's `title` beside them. Unticking is removal
+ * ({@link commitMember} with `undefined`), never a write.
  */
-export function memberWrite(held, columns) {
-    if (!held && Object.keys(columns).length === 0)
-        return undefined;
-    return { [MATRIX_HELD]: held, ...columns };
+export function memberWrite(columns, title) {
+    if (title !== undefined)
+        return { [MATRIX_TITLE]: title, ...columns };
+    return Object.keys(columns).length ? columns : true;
 }
-/** The `object` a matrix member desugars to, for the schema walk: `held` beside the
- *  declared columns. Composed here because the boundary serializes the roster alone. */
-export function matrixMemberSchema(matrix) {
-    return {
-        type: 'object',
-        properties: {
-            [MATRIX_HELD]: { type: 'boolean', default: false },
-            ...(matrix.properties ?? {})
-        }
-    };
+/** Whether `id` is spelled as a matrix id: snake_case, the rule the roster's ids and
+ *  an added item's key share. */
+export function matrixId(id) {
+    return /^[a-z][a-z0-9_]*$/.test(id);
 }
 /** Whether `id` is on the roster. */
-export function matrixDeclares(matrix, id) {
+export function onRoster(matrix, id) {
     return matrix.members != null && Object.hasOwn(matrix.members, id);
 }
+/**
+ * Whether a step under the matrix names a member, judged on the schema alone as an
+ * index step is: a roster id, or on an open matrix any key spelled as an id, the added
+ * item it would be. So an unheld member's address resolves.
+ */
+export function matrixDeclares(matrix, id) {
+    return onRoster(matrix, id) || (!!matrix.open && matrixId(id));
+}
+/**
+ * The added items a stored map holds, sorted by id as the plate orders them: on an
+ * open matrix, each key off the roster spelled as an id whose mapping carries a
+ * `title`. Any other key off the roster is the engine's refusal, drawn nowhere and
+ * ridden through.
+ */
+export function addedItems(matrix, map) {
+    if (!matrix.open || !map)
+        return [];
+    const out = [];
+    for (const id of Object.keys(map)) {
+        if (onRoster(matrix, id) || !matrixId(id))
+            continue;
+        const stored = map[id];
+        if (typeof stored !== 'object' || stored === null || Array.isArray(stored))
+            continue;
+        const title = stored[MATRIX_TITLE];
+        if (title == null)
+            continue;
+        out.push({ id, title: String(title) });
+    }
+    return out.sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+}
+/**
+ * The id an item added under `title` takes: the title folded to snake_case, prefixed
+ * where it opens on no letter, and suffixed past every id `taken` names, the roster's
+ * and the document's alike. The id is the wire's and never drawn, so a later retitle
+ * leaves it where it is.
+ */
+export function addedId(title, taken) {
+    const folded = title
+        .normalize('NFKD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '');
+    const base = /^[a-z]/.test(folded) ? folded : `item${folded ? `_${folded}` : ''}`;
+    if (!taken(base))
+        return base;
+    let n = 2;
+    while (taken(`${base}_${n}`))
+        n++;
+    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. */
+export function matrixMemberSchema(matrix, id) {
+    const columns = matrix.properties ?? {};
+    return {
+        type: 'object',
+        properties: onRoster(matrix, id) ? columns : { [MATRIX_TITLE]: { type: 'string' }, ...columns }
+    };
+}
 // ── The schema walk ──────────────────────────────────────────────────────────
 /**
  * The schema at `steps` under `field`, or `undefined` where the schema declares no such
@@ -265,7 +341,7 @@ function stepInto(schema, step) {
                 : undefined;
         case 'matrix':
             return typeof step === 'string' && matrixDeclares(schema, step)
-                ? matrixMemberSchema(schema)
+                ? matrixMemberSchema(schema, step)
                 : undefined;
         case 'variant': {
             if (typeof step !== 'string')
@@ -318,7 +394,7 @@ export function rowSummary(items, row) {
  * The layout an array takes: `'table'` where the array's own `ui.layout` asks for it
  * and every cell of the row is short (a block prose cell declines it, at load width and
  * every width after), else `'list'`. That every column is a leaf is the loader's
- * contract (`quill::table_column_not_flat`); whether a leaf fits a cell is the surface's
+ * contract (`quill::table_column_not_leaf`); whether a leaf fits a cell is the surface's
  * answer (canon `SCHEMAS.md`): a table composes by position, so a row that would stack
  * inside a cell is not one.
  */
@@ -362,9 +438,10 @@ export function commitDiscriminant(value, member) {
 /**
  * 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 and a matrix, since a namespace declares no `default:` at all and
- * `validate` anchors obligation on the leaves under it; and an optional cell, which can
- * declare none, its unanswered render being `none`.
+ * 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' &&
@@ -431,7 +508,8 @@ export function groupSections(fields, order, labelFor) {
     for (const g of order) {
         const fs = fields.filter((f) => f.group === g);
         if (fs.length) {
-            sections.push({ group: g, label: labelFor(g), fields: fs });
+            const head = fs.length === 1 && flatObject(fs[0].schema) ? fs[0] : undefined;
+            sections.push({ group: g, label: labelFor(g), fields: fs, head });
             emitted.add(g);
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@quillmark/svelte",
-	"version": "0.16.0",
+	"version": "0.18.0",
 	"description": "Editor, live-preview and source surfaces over a Quillmark WASM session.",
 	"repository": {
 		"type": "git",
@@ -48,7 +48,10 @@
 			"svelte": "./dist/visual/index.js",
 			"default": "./dist/visual/index.js"
 		},
-		"./preset": "./dist/preset/index.css"
+		"./preset": {
+			"types": "./dist/preset/index.d.ts",
+			"default": "./dist/preset/index.css"
+		}
 	},
 	"files": [
 		"dist",
@@ -57,21 +60,22 @@
 	],
 	"sideEffects": true,
 	"scripts": {
-		"build": "svelte-package",
+		"build": "svelte-package && node scripts/strip-dts-css.mjs",
 		"prepare": "npm run build",
 		"prepack": "rm -rf dist && npm run build",
 		"check:pack": "publint",
 		"test": "vitest run",
 		"test:watch": "vitest",
-		"check": "svelte-check --tsconfig ./tsconfig.json"
+		"check": "svelte-check --tsconfig ./tsconfig.json --fail-on-warnings"
 	},
 	"peerDependencies": {
-		"@quillmark/wasm": ">=0.118.0-0",
-		"svelte": "^5.0.0"
+		"@quillmark/wasm": ">=0.122.0-0",
+		"svelte": "^5.33.0"
 	},
 	"dependencies": {
 		"@internationalized/date": "^3.12.2",
-		"bits-ui": "^2.0.0",
+		"bits-ui": "^2.19.0",
+		"esm-env": "^1.2.2",
 		"prosemirror-commands": "1.7.1",
 		"prosemirror-gapcursor": "1.3.2",
 		"prosemirror-history": "1.5.0",
@@ -84,15 +88,15 @@
 		"prosemirror-view": "1.42.1"
 	},
 	"devDependencies": {
-		"@sveltejs/package": "^2.5.0",
-		"@sveltejs/vite-plugin-svelte": "^6.0.0",
-		"@types/node": "^26.1.1",
-		"jsdom": "^29.1.1",
-		"publint": "^0.3.0",
-		"svelte": "^5.0.0",
-		"svelte-check": "^4.1.0",
-		"typescript": "^5.7.0",
-		"vitest": "^4.1.10"
+		"@sveltejs/package": "^3.0.0",
+		"@sveltejs/vite-plugin-svelte": "^7.3.0",
+		"@types/node": "^24.19.1",
+		"jsdom": "^30.1.0",
+		"publint": "^0.3.25",
+		"svelte": "^5.54.0",
+		"svelte-check": "^4.7.6",
+		"typescript": "^6.0.0",
+		"vitest": "^5.0.0"
 	},
 	"publishConfig": {
 		"access": "public"

package/dist/visual/synced.svelte.d.ts

@@ -1,15 +0,0 @@
-/** A settable local synced to an external projection. Bind `.value` in the
- * template; assign `.value` on input. */
-export interface SyncedLocal<T> {
-    value: T;
-}
-/**
- * Seed a local from `project` and reconcile only an external change into it.
- * `project` reads the reactive source (a prop) and maps it to the local's type:
- * ` => value ?? ''`, ` => (value != null ? String(value) : '')`, etc. The
- * seed is `untrack`ed (the ongoing sync is the `$effect`, not the initializer),
- * and each reconcile is `untrack`ed so an own-edit write never re-triggers it.
- * Reassignment through the `value` setter is a plain local write; only a changed
- * `project` result flows the other way.
- */
-export declare function syncedLocal<T>(project: () => T): SyncedLocal<T>;

package/dist/visual/synced.svelte.js

@@ -1,34 +0,0 @@
-// The controlled-local reconcile shared by the scalar controls (TextField /
-// NumberField / DateField / BooleanField / EnumField). Each seeds a local from a
-// projection of its `value` prop and reconciles only an external change back into
-// the local: own edits stay `untrack`ed, so typing never re-runs the sync and
-// resets the caret. One copy for all five, rather than a character-identical block
-// in each (VISUAL_EDITOR §Surface).
-import { untrack } from 'svelte';
-/**
- * Seed a local from `project` and reconcile only an external change into it.
- * `project` reads the reactive source (a prop) and maps it to the local's type:
- * ` => value ?? ''`, ` => (value != null ? String(value) : '')`, etc. The
- * seed is `untrack`ed (the ongoing sync is the `$effect`, not the initializer),
- * and each reconcile is `untrack`ed so an own-edit write never re-triggers it.
- * Reassignment through the `value` setter is a plain local write; only a changed
- * `project` result flows the other way.
- */
-export function syncedLocal(project) {
-    let local = $state(untrack(project));
-    $effect(() => {
-        const incoming = project();
-        untrack(() => {
-            if (incoming !== local)
-                local = incoming;
-        });
-    });
-    return {
-        get value() {
-            return local;
-        },
-        set value(v) {
-            local = v;
-        }
-    };
-}