@quillmark/svelte 0.18.0 → 0.20.0

package/dist/visual/leaves.d.ts

@@ -1,5 +1,5 @@
 import type { PathStep } from '@quillmark/wasm';
-import type { FieldController } from '../core/codec/index.js';
+import type { FieldController, LeafViews } from '../core/codec/index.js';
 /**
  * What a landing at depth hands back: the box the arrival wash blooms in, now or once
  * the row it had to open has rendered. A row two closed boxes down does not exist
@@ -60,8 +60,34 @@ export interface LeafRegistry {
     control(key: string): FieldControl | undefined;
     /** The codec seam at `key`, `undefined` for a form control. */
     prose(key: string): FieldController | undefined;
+    /** A by-value prose leaf under the field at `key`, by its views, on its focus. */
+    focusValue(key: string, leaf: LeafViews): void;
+    /** Dropped only by the leaf it names, so a leaf leaving takes no sibling's entry. */
+    releaseValue(key: string, leaf: LeafViews): void;
+    /** The by-value leaf focused last under `key`. */
+    value(key: string): LeafViews | undefined;
     /** Drop everything: the surface going away as a whole, where a leaf's cleanup
      *  order relative to the parent's is Svelte's business. */
     clear(): void;
 }
 export declare function createLeafRegistry(): LeafRegistry;
+/**
+ * The active prose leaf as the formatting popover reaches it: the views a selection is
+ * read from and a mark toggled at, and the controller where the leaf is a field's. A
+ * by-value leaf has none, its anchors being dropped on the parent's value write, so the
+ * anchor verbs the controller carries have nothing to act on there.
+ */
+export interface ActiveProse {
+    views: LeafViews;
+    controller?: FieldController;
+}
+/** The by-value lane with a field's key bound: what a leaf under that field announces
+ *  itself through, knowing no key of its own. */
+export interface ValueLeafSeat {
+    focus(leaf: LeafViews): void;
+    release(leaf: LeafViews): void;
+}
+/** Seat every by-value leaf under the calling field, at any depth of its containers. */
+export declare function seatValueLeaves(seat: ValueLeafSeat): void;
+/** The seat under a mounted field; `undefined` off-tree. */
+export declare function valueLeafSeat(): ValueLeafSeat | undefined;

package/dist/visual/leaves.js

@@ -1,6 +1,32 @@
+// The leaf registry: what a landing verb resolves a `DocPath` to, and the seam the
+// mounted tree registers itself into (VISUAL_EDITOR §"Focus and the preview bridge").
+//
+// Two lanes behind one lookup. Every mounted field registers a {@link FieldControl} —
+// take the caret, and a box to bloom — which is the whole of what a reveal and a
+// focus need, and the whole of what a form control has. A prose leaf registers its
+// `FieldController` instead: a superset, carrying the codec seam (a caret at a USV
+// offset, the formatting popover's observation) that no `<input>` answers. So
+// `control` covers every field and `prose` covers the leaves that have one, and the
+// verbs ask for the half they use: `focusField` never needs the codec, and
+// `getActiveLeaf` returns nothing for a focused text input rather than raising a
+// formatting toolbar over one.
+//
+// A by-value prose leaf (`ProseValue`) is in neither lane: it is not addressable, and
+// every element of an array and every cell of a row shares its field's key. It
+// announces its views on focus into a third lane under that key, which holds the one
+// focused last and is the popover's alone: `getActiveLeaf` falls back to it where the
+// active field registered no controller, and a landing never reads it.
+//
+// A registry rather than a DOM query, for the reason `Card.revealLeaf` is a call: a
+// control's focus is its own (a PM view restores a selection, a date field lands on
+// its first segment, an array lands on its first element or its add affordance), so
+// the surface holds the answers it already gives a label click instead of re-deriving
+// them from markup.
+import { getContext, setContext } from 'svelte';
 export function createLeafRegistry() {
     const controls = new Map();
     const proses = new Map();
+    const values = new Map();
     return {
         registerProse(key, controller) {
             proses.set(key, controller);
@@ -23,9 +49,29 @@ export function createLeafRegistry() {
         prose(key) {
             return proses.get(key);
         },
+        focusValue(key, leaf) {
+            values.set(key, leaf);
+        },
+        releaseValue(key, leaf) {
+            if (values.get(key) === leaf)
+                values.delete(key);
+        },
+        value(key) {
+            return values.get(key);
+        },
         clear() {
             controls.clear();
             proses.clear();
+            values.clear();
         }
     };
 }
+const SEAT = Symbol('qm-value-leaf');
+/** Seat every by-value leaf under the calling field, at any depth of its containers. */
+export function seatValueLeaves(seat) {
+    setContext(SEAT, seat);
+}
+/** The seat under a mounted field; `undefined` off-tree. */
+export function valueLeafSeat() {
+    return getContext(SEAT);
+}

package/dist/visual/strings.d.ts

@@ -50,12 +50,6 @@ export interface VisualStrings extends TableChromeStrings, SlashStrings {
     /** An open matrix's add box at rest, naming the list it adds to: `Add to Staff…`. The box
      *  draws its own `+`. `list` is empty for a matrix mounted with no label. */
     matrixAdd: (list: string) => string;
-    /** The add box's last option, which adds what was typed as an item of this list. */
-    matrixAddNew: (title: string) => string;
-    /** Beside a result from another list: the list it would be ticked in. */
-    matrixIn: (list: string) => string;
-    /** Beside a result already held: picking it lands on it and ticks nothing. */
-    matrixHeldTag: string;
     /** An added item's title input, named for the list it stands in and its 1-based
      *  place among the added items; also what an untitled item is called. */
     matrixItemTitle: (list: string, index: number) => string;
@@ -69,8 +63,9 @@ export interface VisualStrings extends TableChromeStrings, SlashStrings {
     /** What an unset optional cell (`t?`) ghosts at rest: the `none` it prints
      *  unanswered, in the product's words. */
     optionalGhost: string;
-    /** Under a prose leaf holding more structure than it can edit (paragraphs, a list,
-     *  an island in a one-line cell), which it draws read-only rather than flatten. */
+    /** Under a prose leaf holding more structure than it can edit (paragraphs, a list or
+     *  an island in a one-line leaf, an island in any subform cell), which it draws
+     *  read-only rather than lose. */
     proseHeld: string;
     formatGroup: string;
     formatBold: string;

package/dist/visual/strings.js

@@ -38,9 +38,6 @@ export const DEFAULT_VISUAL_STRINGS = {
     enumUnsetTag: 'default',
     matrixHeld: (held, total) => `${held} of ${total} held`,
     matrixAdd: (list) => (list ? `Add to ${list}…` : 'Add…'),
-    matrixAddNew: (title) => `Add “${title}”`,
-    matrixIn: (list) => `in ${list}`,
-    matrixHeldTag: 'held',
     matrixItemTitle: (list, index) => `${list ? `${list} item` : 'Item'} ${index}`,
     matrixRemove: (title) => `Remove ${title}`,
     dateToday: 'Today',

package/dist/visual/structure.js

@@ -105,7 +105,7 @@ export function declaredContent(v, markdown) {
     if (text === undefined)
         return undefined;
     if (markdown)
-        return core().importMarkdown(text);
+        return core().importMarkdown(text).content;
     return {
         text,
         lines: text

package/dist/visual/tips.js

@@ -39,7 +39,7 @@ export function tipsChannel(raw) {
 export function renderTip(markdown, onError) {
     const { importMarkdown } = core();
     try {
-        return renderContent(importMarkdown(markdown), inlineSchema);
+        return renderContent(importMarkdown(markdown).content, inlineSchema);
     }
     catch (e) {
         reportError(onError, {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@quillmark/svelte",
-	"version": "0.18.0",
+	"version": "0.20.0",
 	"description": "Editor, live-preview and source surfaces over a Quillmark WASM session.",
 	"repository": {
 		"type": "git",
@@ -69,7 +69,7 @@
 		"check": "svelte-check --tsconfig ./tsconfig.json --fail-on-warnings"
 	},
 	"peerDependencies": {
-		"@quillmark/wasm": ">=0.122.0-0",
+		"@quillmark/wasm": ">=0.124.0-0",
 		"svelte": "^5.33.0"
 	},
 	"dependencies": {