@quillmark/svelte 0.16.0 → 0.17.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
@@ -142,10 +147,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 +162,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 +184,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 +217,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 +329,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 +382,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 +426,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 +496,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.17.0",
 	"description": "Editor, live-preview and source surfaces over a Quillmark WASM session.",
 	"repository": {
 		"type": "git",
@@ -66,7 +66,7 @@
 		"check": "svelte-check --tsconfig ./tsconfig.json"
 	},
 	"peerDependencies": {
-		"@quillmark/wasm": ">=0.118.0-0",
+		"@quillmark/wasm": ">=0.121.0-0",
 		"svelte": "^5.0.0"
 	},
 	"dependencies": {