@quillmark/svelte 0.21.0 → 0.22.0

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

@@ -15,10 +15,10 @@
 // is preserved, never minted), and no placeholder.
 //
 // The chrome is a band and a selection (CODEC §"The table island"), and the band raises
-// nothing: what floats over the grid is a held column's alignment, the held first row's
-// header toggle, or a sweep's cell alignment. Every control is absolutely positioned out
-// of the grid, so none is in a row or a column of it; `codec/prose.css` draws the band,
-// the clusters and the selection wash.
+// nothing: what floats over the grid is a held column's alignment or the held first
+// row's header toggle. Every control is absolutely positioned out of the grid, so none
+// is in a row or a column of it; `codec/prose.css` draws the band, the clusters and the
+// selection wash.
 import { baseKeymap, chainCommands, selectAll, toggleMark } from 'prosemirror-commands';
 import { redo, undo } from 'prosemirror-history';
 import { keymap } from 'prosemirror-keymap';
@@ -28,9 +28,10 @@ import { decode } from './decode.js';
 import { inputRulesPlugin, undoRuleKeymap } from './inputrules.js';
 import { linkPastePlugin } from './link-paste.js';
 import { tablePropsOfNode } from './islands.js';
+import { tableElement, tableText } from './table-copy.js';
 import { breakKeymap } from './breaks.js';
 import { cellSchema } from './schema.js';
-import { ALIGNS, cellAt, cellContent, cellEqual, cellFromDoc, clearCells, columnCount, deleteColumn, deleteRow, insertColumn, insertRow, moveColumn, moveRow, normalizeTable, rowCells, rowCount, rowEmpty, setAlign, setHeadless, setCellLayout, columnShares, setWidths, shapeEqual, withCell } from './table.js';
+import { ALIGNS, cellAt, cellContent, cellEqual, cellFromDoc, clearCells, columnCount, deleteColumn, deleteRow, insertColumn, insertRow, moveColumn, moveRow, normalizeTable, rowCells, rowCount, rowEmpty, setAlign, setHeadless, columnShares, setWidths, shapeEqual, withCell } from './table.js';
 /**
  * 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
@@ -52,11 +53,7 @@ export const DEFAULT_TABLE_STRINGS = {
     tableAlignLeft: 'Align left',
     tableAlignCenter: 'Align center',
     tableAlignRight: 'Align right',
-    tableHeaderToggle: 'Header row',
-    tableAlignTop: 'Align top',
-    tableAlignMiddle: 'Align middle',
-    tableAlignBottom: 'Align bottom',
-    tableCellAlignment: 'Cell alignment'
+    tableHeaderToggle: 'Header row'
 };
 /** The grip's glyph, as the path data a DOM node can carry — this chrome's own set rather
  *  than `visual/icons/nodes.ts`, this being the one place chrome is built without Svelte,
@@ -81,28 +78,6 @@ const HEADER_GLYPH = [
     'M5 3h14a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2z',
     'M3 9h18'
 ];
-/** The held cells' vertical toggles' glyphs, off the same release. */
-const VALIGN_GLYPH = {
-    top: [
-        'M6 6h2a2 2 0 0 1 2 2v12a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2z',
-        'M16 6h2a2 2 0 0 1 2 2v5a2 2 0 0 1-2 2h-2a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2z',
-        'M22 2H2'
-    ],
-    middle: [
-        'M2 12h20',
-        'M10 16v4a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2v-4',
-        'M10 8V4a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v4',
-        'M20 16v1a2 2 0 0 1-2 2h-2a2 2 0 0 1-2-2v-1',
-        'M14 8V7c0-1.1.9-2 2-2h2a2 2 0 0 1 2 2v1'
-    ],
-    bottom: [
-        'M6 2h2a2 2 0 0 1 2 2v12a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2z',
-        'M16 9h2a2 2 0 0 1 2 2v5a2 2 0 0 1-2 2h-2a2 2 0 0 1-2-2v-5a2 2 0 0 1 2-2z',
-        'M22 22H2'
-    ]
-};
-/** The vertical alignments a cell takes, in the cluster's order. */
-const VALIGNS = ['top', 'middle', 'bottom'];
 /** Draw a cell's alignment on its box: its own where it holds one, its column's
  *  otherwise, and the vertical one where it holds one. */
 function layCell(box, props, r, c) {
@@ -202,6 +177,13 @@ const spanCells = (a, b) => ({
  *  back for a position: how a key in the field reaches into a table ({@link tableAt}). A
  *  placeholder is absent, so it answers as the atom it draws. */
 const mounted = new WeakMap();
+/**
+ * Where the caret stood as each table value was written over, keyed by that value. An
+ * undo hands the node back the very `props` object the undone edit replaced, so the seat
+ * held against it is where the edit was made from: where PM's history puts the caret
+ * back in a field's own text.
+ */
+const departures = new WeakMap();
 class TableIslandView {
     node;
     outer;
@@ -223,9 +205,6 @@ class TableIslandView {
     clusters = [];
     /** The first row's header toggle, up while that row is held. */
     headerCluster;
-    /** The held cells' cluster, up over the first cell of a held rectangle that is no
-     *  column, and built for each paint since what it presses is the cells'. */
-    cellCluster;
     /** The grid's own box, and the containing block every out-of-flow control is placed
      *  against. Not the scroller: an absolute inside a scroll container is placed
      *  against a padding box the scroll then slides out from under, so a control at the
@@ -251,6 +230,7 @@ class TableIslandView {
         this.dom.addEventListener('mousedown', this.onPointerDown);
         this.dom.addEventListener('mouseover', this.onHover);
         this.dom.addEventListener('mouseleave', this.onLeave);
+        this.dom.addEventListener('copy', this.onCopy, true);
         this.render();
     }
     // ── PM's NodeView contract ────────────────────────────────────────────────
@@ -273,6 +253,7 @@ class TableIslandView {
         // transaction, which is every keystroke in the table, and projecting each cell
         // costs a `mapMarks` across the WASM boundary wherever one holds an anchor.
         this.rendered = props;
+        const departure = departures.get(props);
         for (const mounted of this.cells) {
             const stored = cellAt(props, mounted.r, mounted.c);
             if (cellEqual(stored, mounted.shown))
@@ -284,13 +265,14 @@ class TableIslandView {
             });
             mounted.view.updateState(fresh);
             mounted.shown = stored;
-            // Best-effort caret continuity, the rule a field's own re-hydrate takes: keep
-            // the offset, clamped into the text that is there now. A fresh state resolves
-            // its selection to the start of the cell, so an undo would otherwise put the
-            // caret somewhere the edit it undid never was.
+            // The rule a field's own re-hydrate takes: keep the offset, clamped into the
+            // text that is there now, a fresh state resolving to the cell's start. An undo
+            // outranks it below, the departure being where the edit was.
             const at = Math.min(head, fresh.doc.content.size);
             mounted.view.dispatch(fresh.tr.setSelection(Selection.near(fresh.doc.resolve(at))));
         }
+        if (departure && this.focusedSeat())
+            this.focusCell(departure.r, departure.c, departure.head);
         // A cell's alignment is no part of its text, so it is restated on every box: the
         // reseed above compares text and marks alone.
         for (const mounted of this.cells)
@@ -315,6 +297,7 @@ class TableIslandView {
         this.dom.removeEventListener('mousedown', this.onPointerDown);
         this.dom.removeEventListener('mouseover', this.onHover);
         this.dom.removeEventListener('mouseleave', this.onLeave);
+        this.dom.removeEventListener('copy', this.onCopy, true);
         this.endDrag();
         this.endSweep();
         this.endResize();
@@ -399,6 +382,18 @@ class TableIslandView {
             grip.removeAttribute('data-near');
         this.near = [];
     };
+    /** A copy over a held rectangle writes its cells (`table-copy.ts`). Captured, since the
+     *  caret's cell would otherwise copy its own text selection over them. */
+    onCopy = (event) => {
+        const held = this.selected;
+        if (!held || !event.clipboardData)
+            return;
+        const props = this.props();
+        event.clipboardData.setData('text/html', tableElement(props, held).outerHTML);
+        event.clipboardData.setData('text/plain', tableText(props, held));
+        event.preventDefault();
+        event.stopPropagation();
+    };
     /** The cell a press inside the frame belongs to: the nearest by rect, which for a
      *  press on a border or a cell's own padding is the cell it is against.
      *
@@ -650,7 +645,6 @@ class TableIslandView {
             if (line.axis === 'row' && line.index === 0 && this.headerCluster)
                 this.headerCluster.hidden = !named;
         }
-        this.paintCellCluster(props);
         for (const cell of this.cells)
             cell.box.toggleAttribute('data-selected', !!held && cell.r >= held.r0 && cell.r <= held.r1 && cell.c >= held.c0 && cell.c <= held.c1);
     }
@@ -733,69 +727,11 @@ class TableIslandView {
      *  cell of its own writes nothing. */
     align(c, to) {
         const props = this.props();
-        const last = rowCount(props) - 1;
-        const own = Array.from({ length: last + 1 }, (_, r) => cellAt(props, r, c)).some((cell) => cell.align !== undefined);
+        const own = Array.from({ length: rowCount(props) }, (_, r) => cellAt(props, r, c)).some((cell) => cell.align !== undefined);
         if (props.aligns[c] !== to || own)
-            this.write(setCellLayout(setAlign(props, c, to), 0, c, last, c, 'align', undefined));
+            this.write(setAlign(props, c, to));
         this.selectLine({ axis: 'column', index: c });
     }
-    /** The swept cells' cluster: up over the first cell of a sweep, each toggle pressed
-     *  where every cell in it holds it. It floats over the cell under that one, as the
-     *  column's floats over the first row, and is out of the tab order for the reason a
-     *  grip is. A named line raises none: a grip is pressed to move or delete its line. */
-    paintCellCluster(props) {
-        this.cellCluster?.remove();
-        this.cellCluster = undefined;
-        const held = this.selected;
-        if (!held?.swept)
-            return;
-        const first = this.cells.find((m) => m.r === held.r0 && m.c === held.c0);
-        if (!first)
-            return;
-        const s = this.deps.strings();
-        const covered = allCells(props, held);
-        const holds = (key, value) => covered.every((cell) => cell[key] === value);
-        const cluster = el('div', 'qm-table-align');
-        cluster.setAttribute('role', 'group');
-        cluster.setAttribute('aria-label', s.tableCellAlignment);
-        cluster.setAttribute('data-cells', '');
-        cluster.addEventListener('mousedown', (e) => e.preventDefault());
-        const toggle = (label, glyph, pressed, run) => {
-            const btn = chromeButton('qm-table-align-option', label, run);
-            btn.tabIndex = -1;
-            btn.setAttribute('aria-pressed', String(pressed));
-            btn.appendChild(svg(glyph, 2));
-            cluster.appendChild(btn);
-            return btn;
-        };
-        const names = {
-            left: s.tableAlignLeft,
-            center: s.tableAlignCenter,
-            right: s.tableAlignRight
-        };
-        for (const align of SETTABLE)
-            toggle(names[align], ALIGN_GLYPH[align], holds('align', align), () => this.layCells('align', align)).setAttribute('data-align', align);
-        const vnames = {
-            top: s.tableAlignTop,
-            middle: s.tableAlignMiddle,
-            bottom: s.tableAlignBottom
-        };
-        for (const valign of VALIGNS)
-            toggle(vnames[valign], VALIGN_GLYPH[valign], holds('valign', valign), () => this.layCells('valign', valign)).setAttribute('data-valign', valign);
-        first.box.appendChild(cluster);
-        this.cellCluster = cluster;
-    }
-    /** Lay every held cell at `value`, and clear the key from them where every one already
-     *  holds it: the press that set an alignment takes it back to the column's. One
-     *  `set`, and the rectangle stays held. */
-    layCells(key, value) {
-        const held = this.selected;
-        if (!held)
-            return;
-        const props = this.props();
-        const every = allCells(props, held).every((cell) => cell[key] === value);
-        this.write(setCellLayout(props, held.r0, held.c0, held.r1, held.c1, key, every ? undefined : value));
-    }
     // ── Drag to reorder ───────────────────────────────────────────────────────
     /**
      * Press-and-drag a grip moves its line. The press still selects: the dead zone is
@@ -1084,6 +1020,7 @@ class TableIslandView {
         this.headerCluster = undefined;
         this.dom.textContent = '';
         const props = tablePropsOfNode(this.node);
+        const departure = props && departures.get(props);
         this.rendered = props;
         if (props)
             mounted.set(this.dom, this);
@@ -1130,7 +1067,7 @@ class TableIslandView {
         scroller.appendChild(frame);
         this.dom.appendChild(scroller);
         this.paintSelection();
-        this.reseat(seat);
+        this.reseat(seat, departure);
     }
     /**
      * Where the focus sits, in terms a rebuild can restore it by: the caret's cell by
@@ -1145,14 +1082,19 @@ class TableIslandView {
      */
     focusedSeat() {
         const held = this.cells.find((m) => m.view.hasFocus());
-        return held && { r: held.r, c: held.c };
+        return held && { r: held.r, c: held.c, head: held.view.state.selection.head };
     }
-    /** Put the caret back where {@link TableIslandView.focusedSeat} found it, clamped by
-     *  `focusCell` into the rectangle that is there now: the seat may be the cell the
-     *  rebuild removed. A caller that has a landing of its own overrides this by running
-     *  after. */
-    reseat(seat) {
-        if (seat)
+    /** Put the focus back after a rebuild: at the departure where the table returns to a
+     *  value an edit was made from, which is an undo, else at the end of the cell
+     *  {@link TableIslandView.focusedSeat} found, clamped by `focusCell` into the
+     *  rectangle that is there now, the seat being perhaps a cell the rebuild removed. A
+     *  caller that has a landing of its own overrides this by running after. */
+    reseat(seat, departure) {
+        if (!seat)
+            return;
+        if (departure)
+            this.focusCell(departure.r, departure.c, departure.head);
+        else
             this.focusCell(seat.r, seat.c);
     }
     /** One table row: its cells, each carrying whatever chrome hangs off it. */
@@ -1272,12 +1214,10 @@ class TableIslandView {
      *  the pointer out past the last line is the claim — so its name carries the verb for
      *  everything that does not read position.
      *
-     *  In the tab order, where a grip is not: growth is what the line verbs do not carry,
-     *  so the column bar is the keyboard's only route to a new column, and the row bar is
-     *  that control on the other axis, where Enter at the last row and Tab past the last
-     *  cell reach the verb from inside a cell. They sit after the grid, so the Tab that
-     *  declines off the last cell lands on them, and the focus rung draws the one it lands
-     *  on (`codec/prose.css`). */
+     *  Out of the tab order, as a grip is: the Tab that declines off the last cell leaves
+     *  the island rather than landing on two controls drawn only under the pointer. A row
+     *  is the keyboard's from inside a cell, by Enter at the last row and Tab past the
+     *  last cell, and a column is the pointer's alone. */
     addBar(axis, label) {
         const btn = chromeButton('qm-table-add', label, () => {
             const props = this.props();
@@ -1287,6 +1227,7 @@ class TableIslandView {
                 this.write(insertColumn(props, columnCount(props) - 1), { r: 0, c: columnCount(props) });
         });
         btn.setAttribute('data-axis', axis);
+        btn.tabIndex = -1;
         btn.appendChild(el('span', 'qm-table-add-bar'));
         return btn;
     }
@@ -1307,6 +1248,7 @@ class TableIslandView {
             scrollThreshold: this.deps.clearance,
             scrollMargin: this.deps.clearance,
             dispatchTransaction: (tr) => {
+                const from = { r, c, head: view.state.selection.head };
                 const next = view.state.apply(tr);
                 view.updateState(next);
                 if (!tr.docChanged)
@@ -1319,7 +1261,7 @@ class TableIslandView {
                 const now = this.props();
                 const cell = cellFromDoc(next.doc, cellAt(now, r, c));
                 mounted.shown = cell;
-                this.write(withCell(now, r, c, cell));
+                this.write(withCell(now, r, c, cell), undefined, from);
             },
             handleDOMEvents: {
                 focus: () => {
@@ -1355,13 +1297,16 @@ class TableIslandView {
      * op is one commit and one undo step, which is why every op writes a whole
      * table rather than mutating the props in place.
      */
-    write(next, focus) {
+    write(next, focus, from = this.focusedSeat()) {
         const pos = this.getPos();
         if (pos == null)
             return;
         const node = this.outer.state.doc.nodeAt(pos);
         if (!node || node.type !== this.node.type)
             return;
+        const left = tablePropsOfNode(node);
+        if (left && from)
+            departures.set(left, from);
         this.outer.dispatch(this.outer.state.tr.setNodeMarkup(pos, undefined, {
             ...node.attrs,
             props: normalizeTable(next)
@@ -1369,8 +1314,9 @@ class TableIslandView {
         if (focus)
             this.focusCell(focus.r, focus.c);
     }
-    /** Land the caret at the end of a cell, or at its start, clamped into the rectangle:
-     *  where a row or column op puts it, since the op rebuilt the views the caret was in. */
+    /** Land the caret at the end of a cell, at its start, or at an offset clamped into its
+     *  text, the cell itself clamped into the rectangle: where a row or column op puts it,
+     *  since the op rebuilt the views the caret was in. */
     focusCell(r, c, edge = 'end') {
         const props = this.props();
         const row = Math.max(0, Math.min(r, rowCount(props) - 1));
@@ -1379,7 +1325,12 @@ class TableIslandView {
         if (!mounted)
             return;
         const { view } = mounted;
-        const at = edge === 'start' ? Selection.atStart(view.state.doc) : Selection.atEnd(view.state.doc);
+        const { doc } = view.state;
+        const at = edge === 'start'
+            ? Selection.atStart(doc)
+            : edge === 'end'
+                ? Selection.atEnd(doc)
+                : Selection.near(doc.resolve(Math.min(edge, doc.content.size)));
         // Flagged, for the reason the leaf's own landing is (`field.ts`, `setCaret`): PM
         // focuses with `preventScroll`, so an unflagged dispatch lands the caret where no
         // scroller has moved to — a Tab past the right edge of the horizontal scroller a

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

@@ -73,19 +73,12 @@ export declare function moveColumn(props: TableProps, c: number, by: number): Ta
  * empties is text.
  */
 export declare function clearCells(props: TableProps, r0: number, c0: number, r1: number, c1: number): TableProps;
-/** Set column `c`'s alignment: what the held column's cluster and Shift+arrow write
- *  (`table-view.ts`). */
+/** Set column `c`'s alignment and clear its cells' own `align`, which would outrank it:
+ *  what the held column's cluster and Shift+arrow write (`table-view.ts`). */
 export declare function setAlign(props: TableProps, c: number, align: TableAlign): TableProps;
 /** Draw the first row as a header or as a body row: what the header toggle writes
  *  (`table-view.ts`). */
 export declare function setHeadless(props: TableProps, headless: boolean): TableProps;
-/** A cell's horizontal alignment, and its vertical one: the keys a cell holds beside
- *  its text, each absent at the default the column or the quill supplies. */
-export type CellAlign = NonNullable<TableCell['align']>;
-export type CellValign = NonNullable<TableCell['valign']>;
-/** Every cell in the inclusive rectangle given `key`'s `value`, or cleared of it where
- *  `value` is absent, which returns the cell to its column's alignment or the quill's. */
-export declare function setCellLayout<K extends 'align' | 'valign'>(props: TableProps, r0: number, c0: number, r1: number, c1: number, key: K, value: TableCell[K] | undefined): TableProps;
 /** Set or clear the column weights: what a border drag and its double-click write
  *  (`table-view.ts`). `undefined` returns every column to auto-fit. */
 export declare function setWidths(props: TableProps, widths: (number | null)[] | undefined): TableProps;

package/dist/core/codec/table.js

@@ -184,11 +184,19 @@ export function clearCells(props, r0, c0, r1, c1) {
         rows: props.rows.map((row, i) => blank(row, i + 1))
     });
 }
-/** Set column `c`'s alignment: what the held column's cluster and Shift+arrow write
- *  (`table-view.ts`). */
+/** Set column `c`'s alignment and clear its cells' own `align`, which would outrank it:
+ *  what the held column's cluster and Shift+arrow write (`table-view.ts`). */
 export function setAlign(props, c, align) {
+    const release = (cells) => cells.map((cell, i) => {
+        if (i !== c || cell.align === undefined)
+            return cell;
+        const { align: _align, ...rest } = cell;
+        return rest;
+    });
     return normalizeTable({
         ...props,
+        header: release(props.header),
+        rows: props.rows.map(release),
         aligns: props.aligns.map((a, i) => (i === c ? align : a))
     });
 }
@@ -197,23 +205,6 @@ export function setAlign(props, c, align) {
 export function setHeadless(props, headless) {
     return normalizeTable({ ...props, headless: headless || undefined });
 }
-/** Every cell in the inclusive rectangle given `key`'s `value`, or cleared of it where
- *  `value` is absent, which returns the cell to its column's alignment or the quill's. */
-export function setCellLayout(props, r0, c0, r1, c1, key, value) {
-    const lay = (cells, r) => cells.map((cell, c) => {
-        if (r < r0 || r > r1 || c < c0 || c > c1)
-            return cell;
-        const next = { ...cell, [key]: value };
-        if (value === undefined)
-            delete next[key];
-        return next;
-    });
-    return normalizeTable({
-        ...props,
-        header: lay(props.header, 0),
-        rows: props.rows.map((row, i) => lay(row, i + 1))
-    });
-}
 /** Set or clear the column weights: what a border drag and its double-click write
  *  (`table-view.ts`). `undefined` returns every column to auto-fit. */
 export function setWidths(props, widths) {

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

@@ -0,0 +1,19 @@
+import { type DOMOutputSpec, type NodeType } from 'prosemirror-model';
+import { Plugin, type Command } from 'prosemirror-state';
+/** The `checked` an `<li>` states: `data-qm-checked`, which `toDOM` writes, else none. */
+export declare function taskChecked(el: HTMLElement): boolean | null;
+/** Where an `<li>`'s blocks are: a task item's body, past its checkbox; the item itself
+ *  otherwise. */
+export declare function taskBody(el: Node): HTMLElement;
+/** A task item's `<li>`: the checkbox, unreachable by the caret, then the body holding
+ *  the item's blocks, which names it. The mark is the check glyph a matrix tick draws. */
+export declare function taskDOM(checked: boolean): DOMOutputSpec;
+/** The node view a block leaf mounts its list items through. */
+export declare function taskPlugin(): Plugin;
+/**
+ * `splitListItem`, leaving the item that takes none of a task item's text an open task:
+ * the one below, or the one above where Enter is pressed at the head of the item's text.
+ * An empty item the split lifts out of a nested list keeps its own `checked`, as a
+ * Shift-Tab lift keeps it.
+ */
+export declare function splitTaskItem(itemType: NodeType): Command;

package/dist/core/codec/tasks.js

@@ -0,0 +1,140 @@
+// A task item is a `list_item` whose `checked` is a boolean (CODEC §"Task items"). Its
+// `toDOM` draws a checkbox ahead of the item's blocks, disabled, which is the drawing a
+// held leaf, a copy and `renderContent` take; a leaf that edits mounts the item through
+// `taskItemView`, whose checkbox toggles. A task item is minted by source mode and by a
+// paste alone: no shorthand, command or key makes one.
+import { DOMSerializer } from 'prosemirror-model';
+import { Plugin } from 'prosemirror-state';
+import { splitListItem } from 'prosemirror-schema-list';
+const SVG = 'http://www.w3.org/2000/svg';
+/** The id the checkbox names its item's blocks by, fresh per drawing. */
+let drawn = 0;
+/** The `checked` an `<li>` states: `data-qm-checked`, which `toDOM` writes, else none. */
+export function taskChecked(el) {
+    const stated = el.getAttribute('data-qm-checked');
+    return stated === null ? null : stated === 'true';
+}
+/** Where an `<li>`'s blocks are: a task item's body, past its checkbox; the item itself
+ *  otherwise. */
+export function taskBody(el) {
+    const li = el;
+    const body = li.hasAttribute('data-qm-checked')
+        ? li.querySelector(':scope > [data-qm-task-body]')
+        : null;
+    return body ?? li;
+}
+/** A task item's `<li>`: the checkbox, unreachable by the caret, then the body holding
+ *  the item's blocks, which names it. The mark is the check glyph a matrix tick draws. */
+export function taskDOM(checked) {
+    const body = `qm-task-${++drawn}`;
+    return [
+        'li',
+        { 'data-qm-checked': String(checked) },
+        [
+            'span',
+            { class: 'qm-task', contenteditable: 'false' },
+            [
+                'input',
+                {
+                    type: 'checkbox',
+                    class: 'qm-task-box',
+                    'aria-labelledby': body,
+                    checked: checked ? '' : null,
+                    disabled: ''
+                }
+            ],
+            [
+                `${SVG} svg`,
+                {
+                    class: 'qm-task-mark',
+                    viewBox: '0 0 24 24',
+                    fill: 'none',
+                    stroke: 'currentColor',
+                    'stroke-width': '2',
+                    'stroke-linecap': 'round',
+                    'stroke-linejoin': 'round',
+                    'aria-hidden': 'true'
+                },
+                [`${SVG} path`, { d: 'M20 6 9 17l-5-5' }]
+            ]
+        ],
+        ['div', { id: body, 'data-qm-task-body': '' }, 0]
+    ];
+}
+const isTask = (node) => node.attrs.checked !== null;
+/**
+ * Every `list_item` in a leaf that edits, drawn by its own `toDOM`. A task item's checkbox
+ * is enabled, and a change to it is one `checked` transaction, so one `Mod-z` takes it
+ * back; where the leaf declines the edit the box returns to the item's value. The box
+ * keeps the press from the caret: a mousedown leaves the selection and the focus where
+ * they were, and ProseMirror reads no event aimed at it.
+ */
+function taskItemView(node, view, getPos) {
+    const { dom, contentDOM } = DOMSerializer.renderSpec(document, node.type.spec.toDOM(node));
+    const box = isTask(node)
+        ? dom.querySelector(':scope > .qm-task > input')
+        : null;
+    if (box) {
+        box.disabled = false;
+        box.addEventListener('mousedown', (e) => e.preventDefault());
+        box.addEventListener('change', () => {
+            const pos = getPos();
+            if (pos === undefined || !view.editable) {
+                box.checked = node.attrs.checked;
+                return;
+            }
+            view.dispatch(view.state.tr.setNodeAttribute(pos, 'checked', box.checked));
+        });
+    }
+    return {
+        dom,
+        contentDOM,
+        update(next) {
+            if (next.type !== node.type || isTask(next) !== isTask(node))
+                return false;
+            node = next;
+            if (box) {
+                box.checked = next.attrs.checked;
+                dom.setAttribute('data-qm-checked', String(next.attrs.checked));
+            }
+            return true;
+        },
+        stopEvent: (e) => box !== null && e.target === box,
+        ignoreMutation: (m) => m.type !== 'selection' && !contentDOM.contains(m.target)
+    };
+}
+/** The node view a block leaf mounts its list items through. */
+export function taskPlugin() {
+    return new Plugin({ props: { nodeViews: { list_item: taskItemView } } });
+}
+/**
+ * `splitListItem`, leaving the item that takes none of a task item's text an open task:
+ * the one below, or the one above where Enter is pressed at the head of the item's text.
+ * An empty item the split lifts out of a nested list keeps its own `checked`, as a
+ * Shift-Tab lift keeps it.
+ */
+export function splitTaskItem(itemType) {
+    const split = splitListItem(itemType);
+    return (state, dispatch, view) => {
+        const { $from, empty } = state.selection;
+        const item = $from.depth >= 2 ? $from.node(-1) : null;
+        if (!dispatch || item?.type !== itemType || !isTask(item))
+            return split(state, dispatch, view);
+        const lifted = $from.parent.content.size === 0 && item.childCount === 1;
+        const atHead = empty && $from.parentOffset === 0 && $from.index(-1) === 0;
+        return split(state, (tr) => {
+            const $at = tr.selection.$from;
+            const below = $at.before($at.depth - 1);
+            if (lifted)
+                tr.setNodeAttribute(below, 'checked', item.attrs.checked);
+            else if (atHead) {
+                const above = tr.doc.resolve(below).nodeBefore;
+                if (above)
+                    tr.setNodeAttribute(below - above.nodeSize, 'checked', false);
+            }
+            else
+                tr.setNodeAttribute(below, 'checked', false);
+            dispatch(tr);
+        });
+    };
+}

package/dist/core/errors.d.ts

@@ -11,8 +11,8 @@ export type EditorErrorCode =
  *  the whole projection instead, so the store is correct and this field's
  *  identity anchors were paid. */
  | 'commit-fallback'
-/** The overwrite fallback also failed, or the typed writer refused a `plaintext`
- *  leaf's text: the optimistic PM state stands and the store is stale for this
+/** The overwrite fallback also failed, or the typed writer refused a `text` leaf's
+ *  text: the optimistic PM state stands and the store is stale for this
  *  field. The one code here that leaves damage. */
  | 'commit-lost'
 /** A card operation (add, move, remove, retype) that threw. The document is