@quillmark/svelte 0.5.0 → 0.6.0

package/dist/visual/diagnostics.d.ts

@@ -1,9 +1,9 @@
 import type { Diagnostic } from '@quillmark/wasm';
 /** A field's routing address, and `/core`'s `Addr` structurally: an `Addr` is a
- * positional `FieldKey`, so `addrForFieldPath` is the path→key walk and routing
- * carries no second copy of the grammar. `card` is `undefined` for the main card; a
- * composable card slot is a stable session id (the editor's own bookkeeping) once
- * resolved, or an absolute document-array index straight off a parsed `DocPath`
+ * positional `FieldKey`, so `nearestAddrForFieldPath` is the path→key walk and
+ * routing carries no second copy of the grammar. `card` is `undefined` for the main
+ * card; a composable card slot is a stable session id (the editor's own bookkeeping)
+ * once resolved, or an absolute document-array index straight off a parsed `DocPath`
  * (resolve via {@link resolveCardKey} before merging with id-keyed sources). `field`
  * `undefined` addresses the body (the field-less leaf). */
 export interface FieldKey {
@@ -27,32 +27,23 @@ export interface RoutedDiagnostic {
     key: FieldKey;
     diagnostic: Diagnostic;
 }
-/**
- * Whether a validation diagnostic is the surface's to show under a control
- * (VISUAL_EDITOR §Diagnostics). Obligation is not: the label's `*` already states
- * it, from the same schema, for the same cells, and it states it whether or not the
- * cell has been answered — so the warning is a second copy of a mark on screen, once
- * per obliged field, on every document nobody has finished. That is every obliged
- * field of a fresh seed, which is what a consumer's first mount is.
- *
- * Withheld from the boundary's own validation lane only. A consumer's `diagnostics`
- * prop passes whole: what a host hands the surface, the host asked to see. And
- * nothing is suppressed at the source — `quill.validate(doc)` is the completeness
- * read, unchanged and still the host's to make.
- */
-export declare function inlineShown(d: Diagnostic): boolean;
 /**
  * Route a path-keyed producer's raw `Diagnostic[]` (validate / external) to the
- * editor's stable-id keying: the one door producers #1/#3 take, `addrForFieldPath`
- * and `resolveCardKey` in a single pass. An entry drops rather than mis-routes when
- * it carries no `path`, when the path names no single commit address (a nested /
- * array-element one), or when its absolute card index is out of the live `cardIds`.
+ * editor's stable-id keying: the one door producers #1/#3 take,
+ * `nearestAddrForFieldPath` and `resolveCardKey` in a single pass. Warnings do not
+ * draw (VISUAL_EDITOR §Diagnostics): obligation, completeness, a render note — none
+ * of them is a value the field cannot hold. An anchor deeper than a commit address
+ * (`main.contact.email`, `main.keywords[0]`) draws at the nearest field holding it,
+ * whose subform or repeater draws that leaf. An entry drops rather than mis-routes
+ * when it carries no `path`, when no prefix of the path is addressable, or when its
+ * absolute card index is out of the live `cardIds`.
+ * Completeness stays a read the host makes on `quill.validate(doc)`.
  */
 export declare function routeAndResolve(diagnostics: Diagnostic[] | undefined, cardIds: readonly string[]): RoutedDiagnostic[];
 /**
  * Merge N routed groups into `Map<fieldKeyToString(key), Diagnostic[]>`.
  * Dedupes an identical `(severity, message)` pair landing on the same key from
- * more than one group (e.g. the same warning present in both `validate()` and
- * an external feed); within a key, errors sort before warnings.
+ * more than one group (e.g. the same error present in both `validate()` and
+ * an external feed). Producer order within a key.
  */
 export declare function mergeDiagnostics(...groups: RoutedDiagnostic[][]): Map<string, Diagnostic[]>;

package/dist/visual/diagnostics.js

@@ -1,4 +1,4 @@
-import { addrForFieldPath } from '../core/address.js';
+import { nearestAddrForFieldPath } from '../core/address.js';
 /** Canonical string key for a `FieldKey`: the routing `Map`'s key space. */
 export function fieldKeyToString(k) {
     return `${k.card ?? 'main'}:${k.field ?? '$body'}`;
@@ -18,48 +18,35 @@ export function resolveCardKey(key, cardIds) {
     const id = key.card >= 0 && key.card < cardIds.length ? cardIds[key.card] : undefined;
     return id != null ? { card: id, field: key.field } : undefined;
 }
-/**
- * Whether a validation diagnostic is the surface's to show under a control
- * (VISUAL_EDITOR §Diagnostics). Obligation is not: the label's `*` already states
- * it, from the same schema, for the same cells, and it states it whether or not the
- * cell has been answered — so the warning is a second copy of a mark on screen, once
- * per obliged field, on every document nobody has finished. That is every obliged
- * field of a fresh seed, which is what a consumer's first mount is.
- *
- * Withheld from the boundary's own validation lane only. A consumer's `diagnostics`
- * prop passes whole: what a host hands the surface, the host asked to see. And
- * nothing is suppressed at the source — `quill.validate(doc)` is the completeness
- * read, unchanged and still the host's to make.
- */
-export function inlineShown(d) {
-    return d.code !== 'validation::must_fill';
-}
 /**
  * Route a path-keyed producer's raw `Diagnostic[]` (validate / external) to the
- * editor's stable-id keying: the one door producers #1/#3 take, `addrForFieldPath`
- * and `resolveCardKey` in a single pass. An entry drops rather than mis-routes when
- * it carries no `path`, when the path names no single commit address (a nested /
- * array-element one), or when its absolute card index is out of the live `cardIds`.
+ * editor's stable-id keying: the one door producers #1/#3 take,
+ * `nearestAddrForFieldPath` and `resolveCardKey` in a single pass. Warnings do not
+ * draw (VISUAL_EDITOR §Diagnostics): obligation, completeness, a render note — none
+ * of them is a value the field cannot hold. An anchor deeper than a commit address
+ * (`main.contact.email`, `main.keywords[0]`) draws at the nearest field holding it,
+ * whose subform or repeater draws that leaf. An entry drops rather than mis-routes
+ * when it carries no `path`, when no prefix of the path is addressable, or when its
+ * absolute card index is out of the live `cardIds`.
+ * Completeness stays a read the host makes on `quill.validate(doc)`.
  */
 export function routeAndResolve(diagnostics, cardIds) {
     const out = [];
     for (const d of diagnostics ?? []) {
-        if (!d.path)
+        if (d.severity !== 'error' || !d.path)
             continue;
-        const key = addrForFieldPath(d.path);
+        const key = nearestAddrForFieldPath(d.path);
         const resolved = key && resolveCardKey(key, cardIds);
         if (resolved)
             out.push({ key: resolved, diagnostic: d });
     }
     return out;
 }
-/** Severity ordering: errors sort before warnings within a field's list (never dropped, just ranked: VISUAL_EDITOR §Diagnostics "nothing gates" extends to nothing hides). */
-const SEVERITY_RANK = { error: 0, warning: 1 };
 /**
  * Merge N routed groups into `Map<fieldKeyToString(key), Diagnostic[]>`.
  * Dedupes an identical `(severity, message)` pair landing on the same key from
- * more than one group (e.g. the same warning present in both `validate()` and
- * an external feed); within a key, errors sort before warnings.
+ * more than one group (e.g. the same error present in both `validate()` and
+ * an external feed). Producer order within a key.
  */
 export function mergeDiagnostics(...groups) {
     const byKey = new Map();
@@ -80,8 +67,5 @@ export function mergeDiagnostics(...groups) {
                 byKey.set(k, [diagnostic]);
         }
     }
-    for (const arr of byKey.values()) {
-        arr.sort((a, b) => SEVERITY_RANK[a.severity] - SEVERITY_RANK[b.severity]);
-    }
     return byKey;
 }

package/dist/visual/domid.d.ts

@@ -8,6 +8,19 @@ export interface FieldDomIds {
     description: string;
 }
 export declare function fieldDomIds(uid: string, leafKey: string): FieldDomIds;
+/**
+ * A subform property's three names, derived from the field's own control id. A
+ * property is not a field — it has no leaf key, `Addr` reaching a root and one field
+ * and no deeper — so it borrows its parent's id space rather than minting a second:
+ * the same escape, one `-p-` segment down. That is what lets a property's label be a
+ * real `<label for>` like every other label on the surface, instead of a `<span>`
+ * folding its text into the control's composed name.
+ *
+ * The `-p-` infix cannot collide with a sibling field's id: an id is the escaped
+ * `card:field` and `-` only ever introduces an escape, so `-p-` decodes as nothing a
+ * key can spell.
+ */
+export declare function propertyDomIds(controlId: string, key: string): FieldDomIds;
 /**
  * A group panel's own id: what its header's `aria-controls` names, and the only
  * name in the DOM that is a card's rather than a field's. `card` follows the leaf

package/dist/visual/domid.js

@@ -21,6 +21,22 @@ export function fieldDomIds(uid, leafKey) {
     const base = `qm-${uid}-${escapeId(leafKey)}`;
     return { control: base, label: `${base}-label`, description: `${base}-desc` };
 }
+/**
+ * A subform property's three names, derived from the field's own control id. A
+ * property is not a field — it has no leaf key, `Addr` reaching a root and one field
+ * and no deeper — so it borrows its parent's id space rather than minting a second:
+ * the same escape, one `-p-` segment down. That is what lets a property's label be a
+ * real `<label for>` like every other label on the surface, instead of a `<span>`
+ * folding its text into the control's composed name.
+ *
+ * The `-p-` infix cannot collide with a sibling field's id: an id is the escaped
+ * `card:field` and `-` only ever introduces an escape, so `-p-` decodes as nothing a
+ * key can spell.
+ */
+export function propertyDomIds(controlId, key) {
+    const base = `${controlId}-p-${escapeId(key)}`;
+    return { control: base, label: `${base}-label`, description: `${base}-desc` };
+}
 /**
  * A group panel's own id: what its header's `aria-controls` names, and the only
  * name in the DOM that is a card's rather than a field's. `card` follows the leaf

package/dist/visual/leaves.d.ts

@@ -10,15 +10,17 @@ import type { FieldController } from '../core/codec/index.js';
 export interface FieldControl {
     focus(): void;
     /**
-     * Focus element `index` of a control that has elements, resolving the index to the
-     * element's session id at the call; {@link focus}'s own answer for an index past
-     * the live list. Absent on every control without elements.
+     * Land in element `index` of a control that has elements, at USV `pos` where the
+     * row's control can take one; resolving the index to the element's session id at
+     * the call, with {@link focus}'s own answer for an index past the live list. Absent
+     * on every control without elements.
      *
-     * The granularity rides the call because the registry stays parent-keyed: a
-     * per-element key is positional, in a registry whose doctrine is dodging
-     * positional churn.
+     * A landing, not a focus: an absent `pos` is the placement rung, exactly as on
+     * `Landing`, and what a `pos` means is the row control's, the same way focusing is.
+     * The place rides the call because the registry stays parent-keyed: a per-element
+     * key is positional, in a registry whose doctrine is dodging positional churn.
      */
-    focusElement?(index: number): void;
+    focusElement?(index: number, pos?: number): void;
     readonly el: HTMLElement;
 }
 /**

package/dist/visual/links.d.ts

@@ -7,8 +7,11 @@ import type { Command, EditorState } from 'prosemirror-state';
  * userinfo — a wrong destination this normalization would itself have minted.
  *
  * A rooted value is left alone, being the spelling that asks for the embedding
- * page, and so is anything already carrying a scheme. `''` for a blank value, which
- * is nothing to apply.
+ * page, and so is anything already carrying a scheme the link mark renders.
+ *
+ * `''` for a blank value and for a scheme the mark renders inert, both being nothing
+ * to apply: `setLink` declines an empty href, so the refusal lands at the prompt's
+ * own exit rather than storing a link that draws as plain text.
  */
 export declare function normalizeHref(raw: string): string;
 /**

package/dist/visual/links.js

@@ -1,3 +1,4 @@
+import { rendersHref } from '../core/codec/index.js';
 /** A scheme: a letter, then letters, digits, `+`, `-` or `.`, then `:` (RFC 3986). */
 const SCHEME = /^[a-z][a-z0-9+.-]*:/i;
 /** Rooted at the page rather than at a host: an absolute path, a query, a fragment,
@@ -13,12 +14,17 @@ const ADDRESS = /^[^\s/@]+@[^\s/@]+$/;
  * userinfo — a wrong destination this normalization would itself have minted.
  *
  * A rooted value is left alone, being the spelling that asks for the embedding
- * page, and so is anything already carrying a scheme. `''` for a blank value, which
- * is nothing to apply.
+ * page, and so is anything already carrying a scheme the link mark renders.
+ *
+ * `''` for a blank value and for a scheme the mark renders inert, both being nothing
+ * to apply: `setLink` declines an empty href, so the refusal lands at the prompt's
+ * own exit rather than storing a link that draws as plain text.
  */
 export function normalizeHref(raw) {
     const value = raw.trim();
-    if (!value || SCHEME.test(value) || ROOTED.test(value))
+    if (!value || !rendersHref(value))
+        return '';
+    if (SCHEME.test(value) || ROOTED.test(value))
         return value;
     return ADDRESS.test(value) ? `mailto:${value}` : `https://${value}`;
 }

package/dist/visual/props.d.ts

@@ -61,7 +61,7 @@ export interface VisualEditorProps {
     onError?: EditorErrorHandler;
     /**
      * External diagnostics, routed by `.path` and merged with `quill.validate`
-     * and local commit errors (VISUAL_EDITOR §Diagnostics).
+     * and local commit errors (VISUAL_EDITOR §Diagnostics). Warnings do not draw.
      */
     diagnostics?: Diagnostic[];
     /**

package/dist/visual/strings.d.ts

@@ -21,6 +21,21 @@ export interface VisualStrings extends TableChromeStrings, SlashStrings {
     addCard: string;
     arrayAdd: string;
     arrayRemove: string;
+    /** The tag on the unset sentinel's row, which is what tells it from the member it
+     *  ghosts ({@link EnumField}). */
+    enumUnsetTag: string;
+    /**
+     * What stands where a subform declines to recurse (a nested prose / array /
+     * object property), and where to edit that property instead. The whole sentence,
+     * since a translator orders the kind within it.
+     */
+    nestedUnsupported: (kind: string) => string;
+    /**
+     * A collapsed array element whose first text property is empty: the label and the
+     * 1-based index, which is what its accessible name already says. Parametric, so
+     * word order stays the translator's.
+     */
+    elementUntitled: (label: string, index: number) => string;
     /** The required marker's accessible name; the glyph itself is a `*`. */
     fieldRequired: string;
     formatGroup: string;
@@ -66,12 +81,12 @@ export interface VisualStrings extends TableChromeStrings, SlashStrings {
  * interpolates, keyed by name. What it can re-word tracks what that type carries per
  * lane (VISUAL_EDITOR §Diagnostics for why each lands where it does):
  *
- * - **`validation::enum_violation`, `type_mismatch`, `format_violation`,
- *   `must_fill`**: the constraint re-words from the quill's schema at `path`, the
- *   offending value from `args` (`value` / `sourceToken` / `actual`, the engine
- *   testifying to what it saw) and never from the document at `path`: validation
- *   runs post-coercion, so the validator read a value the document does not hold and
- *   a sentence built from `path` names a spelling the user never typed.
+ * - **`validation::enum_violation`, `type_mismatch`, `format_violation`**: the
+ *   constraint re-words from the quill's schema at `path`, the offending value from
+ *   `args` (`value` / `sourceToken` / `actual`, the engine testifying to what it
+ *   saw) and never from the document at `path`: validation runs post-coercion, so
+ *   the validator read a value the document does not hold and a sentence built from
+ *   `path` names a spelling the user never typed.
  * - **`edit::field_coercion_failed`**: re-words from the app's own control state, the
  *   refused value being in neither document (unchanged on throw) nor schema.
  * - **`parse::yaml_error_with_location`, `invalid_structure`**: does not re-word. No

package/dist/visual/strings.js

@@ -30,6 +30,9 @@ export const DEFAULT_VISUAL_STRINGS = {
     addCard: '+ Add Card',
     arrayAdd: '+ Add',
     arrayRemove: 'Remove',
+    enumUnsetTag: 'default',
+    nestedUnsupported: (kind) => `A nested ${kind} — edit this field in the source view.`,
+    elementUntitled: (label, index) => `${label} ${index}`,
     fieldRequired: 'required',
     formatGroup: 'Formatting',
     formatBold: 'Bold (Mod-B)',

package/dist/visual/structure.d.ts

@@ -1,6 +1,6 @@
 import type { QuillCardSchema, QuillFieldSchema, ResolvedField, Resolved } from '@quillmark/wasm';
 /** The control a field type maps to (VISUAL_EDITOR §"Structure mirrors the schema"). */
-export type ControlKind = 'prose' | 'text' | 'enum' | 'number' | 'boolean' | 'date' | 'array' | 'object';
+export type ControlKind = 'prose' | 'text' | 'enum' | 'variant' | 'number' | 'boolean' | 'date' | 'array' | 'object';
 /** One field, projected: its schema, the control it renders as, and its layout hints. */
 export interface FieldModel {
     name: string;
@@ -17,12 +17,10 @@ export interface FieldModel {
      * undefined when the field declares none. Chrome-only; never gates. */
     description: string | undefined;
     /**
-     * Required-ness: the schema's `must_fill` obligation, which derives from
-     * `default:`'s absence when the field declares none (DOCUMENT_MODEL). Drives a
-     * persistent label `*`; a field can carry both it and a ghosted `default:`,
-     * since the two axes are independent. Persistent (schema-derived, survives
-     * filling); the `must_fill` `validate` warning remains the unmet-ness signal.
-     * Label chrome only; never gates.
+     * 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). */
@@ -150,6 +148,33 @@ export declare function resolveBodyGhost(resolvedDefault: string | undefined, cu
  * An array's element control is this over `items`: a missing `items` is a text
  * element. */
 export declare function controlKind(f: QuillFieldSchema): ControlKind;
+/** The discriminant cell of a variant container (`VARIANT_DISCRIMINANT_KEY` upstream,
+ *  which the boundary does not export). Reserved: no variant may declare it. */
+export declare const VARIANT_DISCRIMINANT = "value";
+/**
+ * Which world's cells to draw: the authored discriminant when the container carries
+ * one, else the ghosted default's member — an unset field renders its `default:`, so a
+ * defaulted world whose cells were hidden would print answers the form never asked
+ * for. The blank owns no world, and neither does a member declaring no cells.
+ */
+export declare function variantMember(value: Record<string, unknown> | undefined, ghostMember: string | undefined): string | undefined;
+/** The cells a member declares, or `undefined` where that world has none. */
+export declare function variantCells(schema: QuillFieldSchema, member: string | undefined): Record<string, QuillFieldSchema> | undefined;
+/**
+ * The container a discriminant pick commits, and the discriminant cell alone the unset
+ * sentinel clears: sibling cells are **kept** either way, since the boundary carries an
+ * answer its world does not select rather than dropping it (VISUAL_EDITOR §"Enum
+ * variants"). A container left holding nothing is an unset field, which commits
+ * `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). A typed dictionary is exempt — a namespace declares no
+ * `default:` at all, and `validate` anchors obligation on the leaves under it, so
+ * reading one off the container would mark every subform required.
+ */
+export declare function obliged(schema: QuillFieldSchema): boolean;
 /** `foo_bar` → `Foo bar`: the label fallback when a field declares no `ui.title`. */
 export declare function humanize(name: string): string;
 /** Project a card schema's `fields` map (declaration = key order) into models. */

package/dist/visual/structure.js

@@ -55,7 +55,9 @@ export function controlKind(f) {
         case 'plaintext':
             return 'prose';
         case 'enum':
-            return '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':
@@ -74,6 +76,46 @@ export function controlKind(f) {
             return 'text';
     }
 }
+/** The discriminant cell of a variant container (`VARIANT_DISCRIMINANT_KEY` upstream,
+ *  which the boundary does not export). Reserved: no variant may declare it. */
+export const VARIANT_DISCRIMINANT = 'value';
+/**
+ * Which world's cells to draw: the authored discriminant when the container carries
+ * one, else the ghosted default's member — an unset field renders its `default:`, so a
+ * defaulted world whose cells were hidden would print answers the form never asked
+ * for. The blank owns no world, and neither does a member declaring no cells.
+ */
+export function variantMember(value, ghostMember) {
+    const authored = value?.[VARIANT_DISCRIMINANT];
+    return (typeof authored === 'string' ? authored : ghostMember) || undefined;
+}
+/** The cells a member declares, or `undefined` where that world has none. */
+export function variantCells(schema, member) {
+    return member ? schema.variants?.[member] : undefined;
+}
+/**
+ * The container a discriminant pick commits, and the discriminant cell alone the unset
+ * sentinel clears: sibling cells are **kept** either way, since the boundary carries an
+ * answer its world does not select rather than dropping it (VISUAL_EDITOR §"Enum
+ * variants"). A container left holding nothing is an unset field, which commits
+ * `undefined`.
+ */
+export function commitDiscriminant(value, member) {
+    const next = { ...(value ?? {}) };
+    if (member !== undefined)
+        return { ...next, [VARIANT_DISCRIMINANT]: 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). A typed dictionary is exempt — a namespace declares no
+ * `default:` at all, and `validate` anchors obligation on the leaves under it, so
+ * reading one off the container would mark every subform required.
+ */
+export function obliged(schema) {
+    return schema.type !== 'object' && schema.default === undefined;
+}
 /** `foo_bar` → `Foo bar`: the label fallback when a field declares no `ui.title`. */
 export function humanize(name) {
     const spaced = name.replace(/_/g, ' ').trim();
@@ -89,7 +131,7 @@ export function fieldModels(cardSchema) {
         compact: !!schema.ui?.compact,
         label: schema.ui?.title ?? humanize(name),
         description: schema.description,
-        required: schema.must_fill ?? schema.default === undefined,
+        required: obliged(schema),
         inline: !!schema.inline,
         plaintext: schema.type === 'plaintext'
     }));
@@ -174,6 +216,10 @@ export function initialExpandedGroup(sections) {
  * 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.
  *
+ * 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
+ * packed neighbour would reflow every time the discriminant moves.
+ *
  * An array declines whatever its items are: one-line elements make a one-line step,
  * but nothing holds two arrays to the same number of them, so the shorter of a packed
  * pair pays a cell of whitespace for every element the taller one has past it, and
@@ -182,7 +228,7 @@ export function initialExpandedGroup(sections) {
 function packable(f) {
     if (!f.compact)
         return false;
-    if (f.control === 'object' || f.control === 'array')
+    if (f.control === 'object' || f.control === 'array' || f.control === 'variant')
         return false;
     return f.control !== 'prose' || f.inline;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@quillmark/svelte",
-	"version": "0.5.0",
+	"version": "0.6.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.105.0-0",
+		"@quillmark/wasm": ">=0.108.0-0",
 		"svelte": "^5.0.0"
 	},
 	"dependencies": {

package/dist/core/codec/clipboard.d.ts

@@ -1,59 +0,0 @@
-import { DOMParser as PMDOMParser, Slice } from 'prosemirror-model';
-import type { Node as PMNode, Schema } from 'prosemirror-model';
-import { Plugin } from 'prosemirror-state';
-import type { TableCell, TableProps } from '@quillmark/wasm';
-import { type TableAlign } from './table.js';
-/** What a clipboard event hands over, which is all either arm needs of it: jsdom has no
- *  `DataTransfer`, and the suite drives these paths with the two methods themselves. */
-interface Clipboard {
-    getData: (type: string) => string;
-    setData: (type: string, data: string) => void;
-}
-/**
- * A `<table>` element as props. `rowspan` is not carried — a merged cell is not a
- * rectangle, so a table with one arrives with the rows below it short and
- * {@link normalizeTable} pads them at the end. `colspan` is, as the empty cells it
- * covers, so the columns after it keep their index.
- *
- * Only the table's own rows: a `<tr>` inside a nested table belongs to a cell this
- * reader is about to flatten, not to a rank of this one.
- */
-export declare function tableFromDOM(dom: Element): TableProps;
-/** The table a paste is carrying, or `undefined` for a paste that holds none. The first
- *  one: a clipboard holding a table among other blocks is a document paste, and only a
- *  surface that takes nothing but a table (a cell) reads it this way. */
-export declare function tableFromClipboard(data: Clipboard | null | undefined): TableProps | undefined;
-/**
- * A rectangle as a `<table>`: the wire the HTML arm writes and reads. Its first row is
- * a `<th>` row whatever row of the source it came from, that being the row index 0 a
- * paste lands it at.
- */
-export declare function tableToDOM(block: TableCell[][], aligns: TableAlign[], owner: Document): Element;
-/**
- * A rectangle as pipe rows, delimiter row included: what a plain-text target reads as a
- * table and what markdown carries. The delimiter follows the first row for the reason
- * that row serializes as `<th>` — a pasted rectangle's row 0 is a header.
- */
-export declare function tableToPipe(block: TableCell[][], aligns: TableAlign[]): string;
-/** Put a rectangle on the clipboard, both arms. The caller is a `copy` / `cut` handler
- *  over a selection its own surface holds, so the rectangle arrives already cut out and
- *  claiming the event is the caller's. */
-export declare function writeRectangle(data: Clipboard, block: TableCell[][], aligns: TableAlign[], owner: Document): void;
-/** The clipboard's parser: the schema's own rules with the table rule ahead of them.
- *  Ahead, because a `<table>` otherwise matches nothing and its cells' text falls
- *  through to the enclosing block. */
-export declare function tableClipboardParser(schema: Schema): PMDOMParser;
-/** Mint an id for every island a paste is carrying. An id is part of the document's
- *  canonical bytes and the channel that addresses an island (CODEC §Islands), so a
- *  pasted island with none reaches the store as an insert nothing can name afterwards.
- *  One minter for the whole slice, or a paste placing two tables hands them one id. */
-export declare function stampIslandIds(slice: Slice, doc: PMNode): Slice;
-/**
- * The block leaf's clipboard plugin: the table rule on the way in, and the id mint over
- * what it produced. A `clipboardParser` rather than the schema's own `parseDOM`,
- * because what a `<table>` in the DOM means is a question only the clipboard asks — the
- * schema's parse rules are also what a re-parse of the editor's own DOM runs through,
- * where an island is already a node and a `<table>` is the chrome drawing one.
- */
-export declare function tableClipboardPlugin(schema: Schema): Plugin;
-export {};