@quillmark/svelte 0.27.0 → 0.28.0

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

@@ -1,83 +1,77 @@
 import { EditorState, Plugin, type Command } from 'prosemirror-state';
 import { type EditorView } from 'prosemirror-view';
 import { type RangeAnchor } from './anchor.js';
-/** The menu as the chrome sees it: the command names the query matched, the keyboard's
- *  cursor, and the trigger's anchor to hang off. `undefined` is a closed menu.
- *
- *  An empty `items` is a live trigger with nothing to offer, and nothing is drawn over
- *  it. The run is the shape of the text (a `/` at a boundary, no whitespace since) and
- *  the menu the shape of the match; splitting the two is what lets a query typed past
- *  the last match narrow back into one. */
+/**
+ * The menu as the chrome sees it: the command names the query matched, the keyboard's cursor, and
+ * the trigger's anchor to hang off. `undefined` is a closed menu. An empty `items` is a live
+ * trigger with nothing to offer, drawn as nothing: the run is the shape of the text and the menu
+ * the shape of the match, so a query typed past the last match can narrow back into one.
+ */
 export interface SlashState {
     items: string[];
     index: number;
     query: string;
-    /** The trigger's caret to hang off, live rather than measured (`anchor.ts`): an
-     *  open menu outlives any one scroll position of the leaf. */
+    /**
+     * The trigger's caret to hang off, live rather than measured (`anchor.ts`): an open menu
+     * outlives any one scroll position.
+     */
     anchor: RangeAnchor;
 }
-/** The menu's wording, which is its accessible name and the empty line's hint: the
- *  offers are command names, and a name is not translated. */
+/**
+ * The menu's wording: its accessible name and the empty line's hint. Offers are command names,
+ * which are not translated.
+ */
 export interface SlashStrings {
     slashLabel: string;
-    /** Drawn on the empty line a focused caret holds, naming the key that opens the
-     *  menu there. */
+    /** Drawn on the empty line a focused caret holds, naming the key that opens the menu. */
     slashHint: string;
 }
-/** The package's English, beside the surface that draws it: the same rule the island
- *  chrome's wording follows, and the visual `strings` set extends both. */
+/** The package's English, beside the surface that draws it; the visual `strings` set extends it. */
 export declare const DEFAULT_SLASH_STRINGS: SlashStrings;
 /**
- * The vocabulary a caret can run, in menu order: the names `SLASH_COMMANDS` is keyed
- * by, each asked whether it would fire here. A row that declines when picked is worse
- * than an absent one, and asking the command rather than restating its guards is what
- * keeps the menu from drifting off what a pick does. So the offers narrow as the caret
- * moves: the lists and the island alone mid-paragraph, and at an item's head only the
- * list of the other kind, which retypes the item's list.
+ * The vocabulary a caret can run, in menu order, each name asked whether it would fire here: a row
+ * that declines when picked is worse than an absent one, and asking the command keeps the menu from
+ * drifting off what a pick does. So the offers narrow as the caret moves (the lists and the island
+ * alone mid-paragraph; at an item's head only the list of the other kind).
  *
- * `state` is the state a pick leaves behind — the run already consumed — since that is
- * the caret every command answers for (`blocks.ts`).
+ * `state` is the state a pick leaves behind, the run already consumed (`blocks.ts`).
  */
 export declare function slashItems(state: EditorState): string[];
-/** The query filter: a case-insensitive prefix of the name or of any of its words, which
- *  is how a command line completes and how a two-word name stays reachable by the noun a
- *  writer has — `/list` offers both lists. A prefix and not a substring: `note` is inside
- *  `footnote` and completes nothing. An empty query offers everything, and the
- *  vocabulary's order survives, so the menu never reorders under a keystroke. */
+/**
+ * The query filter: a case-insensitive prefix of the name or of any of its words, so `/list` offers
+ * both lists. A prefix and not a substring (`note` is inside `footnote` and completes nothing). An
+ * empty query offers everything in the vocabulary's order.
+ */
 export declare function filterItems(items: string[], query: string): string[];
-/** The live trigger: where the `/` sits, what has been typed after it, and which
- *  offer the keyboard is on. */
+/**
+ * The live trigger: where the `/` sits, what has been typed after it, and which offer the keyboard
+ * is on.
+ */
 interface SlashRun {
     from: number;
     query: string;
     index: number;
 }
 /**
- * The trigger plugin. It holds the run in PM state, so every ordinary dismissal is
- * free: a caret move out of it, an undo, or a re-hydrate all fail the recompute
- * below and close the menu without a listener of their own. A dismissal edits no
- * text; only a pick does, and it consumes exactly the run.
+ * The trigger plugin. It holds the run in PM state, so a caret move out of it, an undo or a
+ * re-hydrate fail the recompute and close the menu without a listener. A dismissal edits no text;
+ * only a pick does, consuming exactly the run.
  */
 export declare function slashPlugin(onState: (state: SlashState | undefined) => void, hint?: () => string | undefined): Plugin<SlashRun | null>;
 /**
- * The menu's keys, the innermost link of the leaf's chain (`keymap.ts`). Every one
- * declines on an empty offer list rather than on a dead run (§`SlashState`): a key an
- * undrawn run claimed would be a key lost to a surface nobody can see. So a body with
- * no menu on screen keeps Enter, Escape and the arrows exactly as it had them.
- *
- * Escape is the contended key: a table gives it three claimants (this menu, the
- * format popover, an island selection). Innermost first, and this is the innermost
- * of the three that can be open over a caret in text.
+ * The menu's keys, the innermost link of the leaf's chain (`keymap.ts`). Every one declines on an
+ * empty offer list rather than a dead run (§`SlashState`), so a body with no menu on screen keeps
+ * Enter, Escape and the arrows as it had them. Escape has three claimants over a table (this menu,
+ * the format popover, an island selection); this is the innermost that can be open over a caret in
+ * text.
  */
 export declare function slashKeymap(): Record<string, Command>;
-/** Move the keyboard cursor onto `name`: what a pointer entering an item calls, so the
- *  highlight has one lane rather than a hover painting a second one. */
+/** Move the keyboard cursor onto `name` (a pointer entering an item): one highlight lane. */
 export declare function focusSlashItem(view: EditorView, name: string): void;
 /**
- * Run a command: one transaction that deletes the trigger run and applies the command's
- * own edit (`blocks.ts` §`consuming`). A command that declines consumes nothing. The
- * menu never picks one, offering only what would run; `slashPick` is a public seam and
- * can.
+ * Run a command: one transaction that deletes the trigger run and applies the command's edit
+ * (`blocks.ts` §`consuming`). A command that declines consumes nothing. The menu only offers what
+ * would run; `slashPick` is a public seam and can pick any.
  */
 export declare function runSlashItem(view: EditorView, name: string): void;
 export {};

package/dist/core/codec/table-copy.d.ts

@@ -7,9 +7,10 @@ export interface CellRange {
     r1: number;
     c1: number;
 }
-/** The cells of `range` as a `<table>`, the header row in a `<thead>` where the range
- *  holds it and the table has one. The cells carry their marks and breaks, and nothing
- *  of the table's layout. */
+/** The cells of `range` as a `<table>`, the header rows in a `<thead>` where the range
+ *  holds them. The cells carry their marks, breaks and spans, a span cut to the range,
+ *  and nothing else of the table's layout. A slot a merged cell in the range covers
+ *  draws nothing; one whose cell starts outside the range draws empty. */
 export declare function tableElement(props: TableProps, range?: CellRange): HTMLTableElement;
 /** The cells of `range` as tab-separated text, a line a row. */
 export declare function tableText(props: TableProps, range?: CellRange): string;

package/dist/core/codec/table-copy.js

@@ -8,7 +8,7 @@ import { Plugin } from 'prosemirror-state';
 import { decode } from './decode.js';
 import { tablePropsOfNode } from './islands.js';
 import { blockSchema, cellSchema } from './schema.js';
-import { cellAt, cellContent, columnCount, rowCount } from './table.js';
+import { anchorAt, cellAt, cellContent, columnCount, headRows, rowCount, spanGrid } from './table.js';
 const whole = (props) => ({
     r0: 0,
     c0: 0,
@@ -23,18 +23,36 @@ function cellDOM(tag, cell) {
         dom.append(cellSerializer.serializeFragment(paragraph.content));
     return dom;
 }
-/** The cells of `range` as a `<table>`, the header row in a `<thead>` where the range
- *  holds it and the table has one. The cells carry their marks and breaks, and nothing
- *  of the table's layout. */
+/** The cells of `range` as a `<table>`, the header rows in a `<thead>` where the range
+ *  holds them. The cells carry their marks, breaks and spans, a span cut to the range,
+ *  and nothing else of the table's layout. A slot a merged cell in the range covers
+ *  draws nothing; one whose cell starts outside the range draws empty. */
 export function tableElement(props, range = whole(props)) {
     const table = document.createElement('table');
+    const grid = spanGrid(props);
     let body;
     for (let r = range.r0; r <= range.r1; r++) {
-        const head = r === 0 && !props.headless;
+        const head = r < headRows(props);
         const section = head ? table.createTHead() : (body ??= table.createTBody());
         const tr = section.insertRow();
-        for (let c = range.c0; c <= range.c1; c++)
-            tr.append(cellDOM(head ? 'th' : 'td', cellAt(props, r, c)));
+        for (let c = range.c0; c <= range.c1; c++) {
+            const tag = head ? 'th' : 'td';
+            const at = anchorAt(grid, r, c);
+            if (at.r < range.r0 || at.c < range.c0) {
+                tr.append(cellDOM(tag, { text: '', marks: [] }));
+                continue;
+            }
+            if (at.r !== r || at.c !== c)
+                continue;
+            const dom = cellDOM(tag, cellAt(props, r, c));
+            const colspan = Math.min(at.span.colspan, range.c1 - c + 1);
+            const rowspan = Math.min(at.span.rowspan, range.r1 - r + 1);
+            if (colspan > 1)
+                dom.setAttribute('colspan', String(colspan));
+            if (rowspan > 1)
+                dom.setAttribute('rowspan', String(rowspan));
+            tr.append(dom);
+        }
     }
     return table;
 }

package/dist/core/codec/table-view.d.ts

@@ -27,28 +27,28 @@ export interface TableChromeStrings {
     tableAlignRight: string;
     /** The held first row's toggle, pressed while the row draws as the header. */
     tableHeaderToggle: string;
+    /** The held cells' cluster: one cell from the block, and the merged cells in it back
+     *  to the cells under them. */
+    tableMergeCells: string;
+    tableSplitCell: string;
 }
 /**
- * The package's English for the island chrome. It lives here, beside the surface
- * that draws it, rather than in the visual tier's table: the codec mounts this
- * chrome and a consumer reaching `createField` directly gets wording with it. The
- * visual `strings` set extends this one, so a consumer overrides these keys beside
- * every other key and there is still one English list.
+ * The package's English for the island chrome. It lives beside the surface that draws it so a
+ * consumer reaching `createField` directly gets wording; the visual `strings` set extends it.
  */
 export declare const DEFAULT_TABLE_STRINGS: TableChromeStrings;
 /** What the field hands each island view: its wording (read live, so a locale swap
  *  re-renders) and the callbacks that keep a nested view visible to the leaf. */
 export interface TableViewDeps {
     strings: () => TableChromeStrings;
-    /** Register a mounted cell view; the returned function unregisters it. The field
-     *  needs the set to answer "which view holds the caret" for the format popover. */
+    /** Register a mounted cell view; the returned function unregisters it. */
     register: (view: EditorView) => () => void;
-    /** A cell took focus: the leaf's own `focus` handler never fires for one (a focus
-     *  event does not bubble), so the active address would not follow the caret. */
+    /** A cell took focus; a focus event does not bubble to the leaf's own handler. */
     onCellFocus: () => void;
-    /** The clearance a revealed caret keeps, in the leaf's own line box (`field.ts`), which
-     *  is a cell's line box too. `undefined` where the derivation is out of reach (jsdom),
-     *  which is PM's 5px default. */
+    /**
+     * The clearance a revealed caret keeps; `undefined` where the derivation is out of reach
+     * (jsdom).
+     */
     clearance: number | undefined;
 }
 /** The table island mounted at `pos` in `view`, which a caret can step into; `undefined`