@quillmark/svelte 0.2.0 → 0.3.0

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

@@ -8,14 +8,18 @@ export declare const ALIGNS: readonly TableAlign[];
 /** The zero cell: empty text, no marks. */
 export declare function emptyCell(): TableCell;
 /**
- * The row index space the chrome and the ops share: **0 is the header**, 1…n the
- * body rows. A table always has a header (`header` is a separate field, and a
- * header-less table is not expressible), so the header is a row that never
- * deletes rather than a toggle.
+ * The row index space the chrome and the ops share: **0 is the header**, 1…n the body
+ * rows. The split is how a table is stored, not a rank the ops answer to: a row op
+ * works {@link allRows} and whichever row lands at index 0 is the header afterwards,
+ * so index 0 moves and deletes like any other. The one row the model refuses is the
+ * last, there being no table under it.
  */
 export declare function rowCount(props: TableProps): number;
 /** The cells of row `r` in that space. */
 export declare function rowCells(props: TableProps, r: number): TableCell[];
+/** Whether a row holds no text, which is what tells a row on offer from one taken up
+ *  (`table-view.ts` §`step`). Text alone: a mark over none is nothing a writer can see. */
+export declare function rowEmpty(props: TableProps, r: number): boolean;
 /** The cell at `(row, column)`, or the zero cell where the rectangle does not reach. */
 export declare function cellAt(props: TableProps, r: number, c: number): TableCell;
 /** The table's column count: the one number `header`, every row and `aligns` share. */
@@ -27,6 +31,13 @@ export declare function columnCount(props: TableProps): number;
  * back, and a table is never narrower than one column.
  */
 export declare function normalizeTable(props: TableProps): TableProps;
+/**
+ * The rows as one list, header first: the space a row op works in. `header` is a
+ * separate field because a table always has one and `header: []` is not a table — a
+ * storage shape, not a rank a row op has to know about. Reading it as one list is what
+ * lets move and delete treat every row alike, and {@link fromRows} splits it back.
+ */
+export declare function allRows(props: TableProps): TableCell[][];
 /** A fresh table: a header plus `bodyRows` empty rows, every column unaligned.
  *  Growth is cheap (Tab at the last cell appends a row), so the default is small. */
 export declare function newTable(cols?: number, bodyRows?: number): TableProps;
@@ -34,32 +45,48 @@ export declare function newTable(cols?: number, bodyRows?: number): TableProps;
 export declare function withCell(props: TableProps, r: number, c: number, cell: TableCell): TableProps;
 /** A new empty body row below row `r` (row 0, the header, opens the first body row). */
 export declare function insertRow(props: TableProps, r: number): TableProps;
-/** Drop body row `r`. The header (`r === 0`) has no delete: `header: []` is not a
- *  table, so the asymmetry is the model's rather than a guard's. */
+/** Drop row `r`, the header included: the row left at index 0 is the header, which is
+ *  how a table whose first row went still has one. A no-op at the last row, that being
+ *  the removal of the table rather than of a row, and the island's own to answer. */
 export declare function deleteRow(props: TableProps, r: number): TableProps;
 /** A new empty column after column `c`. */
 export declare function insertColumn(props: TableProps, c: number): TableProps;
 /** Drop column `c`; a no-op at one column (a table has at least one). */
 export declare function deleteColumn(props: TableProps, c: number): TableProps;
-/** Body row `r` moved by `by` places, clamped: a drag that leaves the rectangle is a
- *  no-op rather than an error, since the drop target is geometry and geometry runs
- *  past the last row. The header is refused because it has no destination: it is a
- *  separate field, not row 0 of one array. */
+/** Row `r` moved by `by` places, clamped: a drag that leaves the rectangle is a no-op
+ *  rather than an error, since the drop target is geometry and geometry runs past the
+ *  last row. The header travels like any other row, and so does the row that displaces
+ *  it: being the header is holding index 0, which a move is free to hand over. */
 export declare function moveRow(props: TableProps, r: number, by: number): TableProps;
 /** Column `c` moved by `by` places, clamped. `aligns` travels with the column: an
  *  alignment is the column's property, so a move that left it behind would retint the
  *  column that took the index. */
 export declare function moveColumn(props: TableProps, c: number, by: number): TableProps;
-/** Column `c` with every cell emptied, alignment kept: what a delete gesture means at
- *  the LAST column, which the model keeps. There is no row analogue: the header is the
- *  only row a delete is refused for, and it carries no handle to select it from. */
-export declare function clearColumn(props: TableProps, c: number): TableProps;
+/**
+ * Every cell in the inclusive rectangle emptied, alignment kept: what a delete gesture
+ * means over a block of cells that covers no whole rank. A rectangle spanning one axis
+ * covers ranks and deletes them, and one spanning both is the table itself, so what
+ * reaches here is a proper sub-rectangle and the shape it leaves is the shape it found.
+ *
+ * Alignment is the column's rather than the cells', so it survives a clear that spans one.
+ */
+export declare function clearCells(props: TableProps, r0: number, c0: number, r1: number, c1: number): TableProps;
+/**
+ * A rectangle written in at `(r, c)`, the table growing to hold whatever runs past its
+ * edges: what a paste into a cell means (`clipboard.ts`). The alternative is clipping
+ * to the rectangle that is there, which silently drops the tail of what the author
+ * copied; growth drops nothing and every added rank is one the ops already remove.
+ *
+ * `aligns` is the table's own throughout: a column keeps its alignment under a paste,
+ * and a column the paste added arrives `none` like any other fresh one.
+ */
+export declare function pasteCells(props: TableProps, r: number, c: number, block: TableCell[][]): TableProps;
 /** Set column `c`'s alignment: the one table capability the content round-trips
  *  today and nothing in the editor could reach. */
 export declare function setAlign(props: TableProps, c: number, align: TableAlign): TableProps;
 /**
  * A cell as a one-line `Content`: what `decode` takes under the inline schema. The
- * cell's marks ARE that content's marks, because both are offsets into the same
+ * cell's marks are that content's marks, because both are offsets into the same
  * text: the cell-local coordinate space is a `Content`'s coordinate space with
  * one line in it.
  */

package/dist/core/codec/table.js

@@ -2,9 +2,9 @@
 // doc) and the rectangularizing constructors every row and column op goes through
 // (CODEC §Islands, §"The table island").
 //
-// `TableProps` normalizes to ONE column count shared by `header`, every row, and
+// `TableProps` normalizes to one column count shared by `header`, every row, and
 // `aligns`, so a ragged table is not a state the content can hold. The editor keeps
-// its optimistic PM and re-hydrates only on an EXTERNAL change (CODEC
+// its optimistic PM and re-hydrates only on an external change (CODEC
 // §Reconciliation), so an op that emitted a ragged table would leave the store
 // rectangularized and PM ragged with no error channel and no repair. Every
 // constructor here therefore ends in {@link normalizeTable}, and a caller reaches
@@ -26,10 +26,11 @@ export function emptyCell() {
     return { text: '', marks: [] };
 }
 /**
- * The row index space the chrome and the ops share: **0 is the header**, 1…n the
- * body rows. A table always has a header (`header` is a separate field, and a
- * header-less table is not expressible), so the header is a row that never
- * deletes rather than a toggle.
+ * The row index space the chrome and the ops share: **0 is the header**, 1…n the body
+ * rows. The split is how a table is stored, not a rank the ops answer to: a row op
+ * works {@link allRows} and whichever row lands at index 0 is the header afterwards,
+ * so index 0 moves and deletes like any other. The one row the model refuses is the
+ * last, there being no table under it.
  */
 export function rowCount(props) {
     return props.rows.length + 1;
@@ -38,6 +39,11 @@ export function rowCount(props) {
 export function rowCells(props, r) {
     return r === 0 ? props.header : (props.rows[r - 1] ?? []);
 }
+/** Whether a row holds no text, which is what tells a row on offer from one taken up
+ *  (`table-view.ts` §`step`). Text alone: a mark over none is nothing a writer can see. */
+export function rowEmpty(props, r) {
+    return rowCells(props, r).every((cell) => cell.text === '');
+}
 /** The cell at `(row, column)`, or the zero cell where the rectangle does not reach. */
 export function cellAt(props, r, c) {
     return rowCells(props, r)[c] ?? emptyCell();
@@ -61,6 +67,22 @@ export function normalizeTable(props) {
         aligns: Array.from({ length: cols }, (_, c) => props.aligns[c] ?? 'none')
     };
 }
+/**
+ * The rows as one list, header first: the space a row op works in. `header` is a
+ * separate field because a table always has one and `header: []` is not a table — a
+ * storage shape, not a rank a row op has to know about. Reading it as one list is what
+ * lets move and delete treat every row alike, and {@link fromRows} splits it back.
+ */
+export function allRows(props) {
+    return [props.header, ...props.rows];
+}
+/** A flat list back into the stored shape: whatever sits at index 0 is the header, by
+ *  position rather than by having been one. No caller passes an empty list — every op
+ *  that could reach one refuses the last row first. */
+function fromRows(rows, aligns) {
+    const [header = [], ...rest] = rows;
+    return normalizeTable({ header, rows: rest, aligns });
+}
 /** A fresh table: a header plus `bodyRows` empty rows, every column unaligned.
  *  Growth is cheap (Tab at the last cell appends a row), so the default is small. */
 export function newTable(cols = 3, bodyRows = 2) {
@@ -88,12 +110,14 @@ export function insertRow(props, r) {
         rows: [...props.rows.slice(0, at), fresh, ...props.rows.slice(at)]
     });
 }
-/** Drop body row `r`. The header (`r === 0`) has no delete: `header: []` is not a
- *  table, so the asymmetry is the model's rather than a guard's. */
+/** Drop row `r`, the header included: the row left at index 0 is the header, which is
+ *  how a table whose first row went still has one. A no-op at the last row, that being
+ *  the removal of the table rather than of a row, and the island's own to answer. */
 export function deleteRow(props, r) {
-    if (r === 0)
+    const rows = allRows(props);
+    if (rows.length <= 1 || r < 0 || r >= rows.length)
         return normalizeTable(props);
-    return normalizeTable({ ...props, rows: props.rows.filter((_, i) => i !== r - 1) });
+    return fromRows(rows.filter((_, i) => i !== r), props.aligns);
 }
 /** A new empty column after column `c`. */
 export function insertColumn(props, c) {
@@ -124,16 +148,16 @@ function move(xs, from, to) {
     next.splice(to, 0, moved);
     return next;
 }
-/** Body row `r` moved by `by` places, clamped: a drag that leaves the rectangle is a
- *  no-op rather than an error, since the drop target is geometry and geometry runs
- *  past the last row. The header is refused because it has no destination: it is a
- *  separate field, not row 0 of one array. */
+/** Row `r` moved by `by` places, clamped: a drag that leaves the rectangle is a no-op
+ *  rather than an error, since the drop target is geometry and geometry runs past the
+ *  last row. The header travels like any other row, and so does the row that displaces
+ *  it: being the header is holding index 0, which a move is free to hand over. */
 export function moveRow(props, r, by) {
-    const from = r - 1;
-    const to = Math.max(0, Math.min(from + by, props.rows.length - 1));
-    if (r === 0 || from === to || from >= props.rows.length)
+    const rows = allRows(props);
+    const to = Math.max(0, Math.min(r + by, rows.length - 1));
+    if (r === to || r < 0 || r >= rows.length)
         return normalizeTable(props);
-    return normalizeTable({ ...props, rows: move(props.rows, from, to) });
+    return fromRows(move(rows, r, to), props.aligns);
 }
 /** Column `c` moved by `by` places, clamped. `aligns` travels with the column: an
  *  alignment is the column's property, so a move that left it behind would retint the
@@ -149,17 +173,37 @@ export function moveColumn(props, c, by) {
         aligns: shift(props.aligns)
     });
 }
-/** Column `c` with every cell emptied, alignment kept: what a delete gesture means at
- *  the LAST column, which the model keeps. There is no row analogue: the header is the
- *  only row a delete is refused for, and it carries no handle to select it from. */
-export function clearColumn(props, c) {
-    const blank = (cells) => cells.map((cell, i) => (i === c ? emptyCell() : cell));
+/**
+ * Every cell in the inclusive rectangle emptied, alignment kept: what a delete gesture
+ * means over a block of cells that covers no whole rank. A rectangle spanning one axis
+ * covers ranks and deletes them, and one spanning both is the table itself, so what
+ * reaches here is a proper sub-rectangle and the shape it leaves is the shape it found.
+ *
+ * Alignment is the column's rather than the cells', so it survives a clear that spans one.
+ */
+export function clearCells(props, r0, c0, r1, c1) {
+    const blank = (cells, r) => cells.map((cell, c) => (r >= r0 && r <= r1 && c >= c0 && c <= c1 ? emptyCell() : cell));
     return normalizeTable({
-        header: blank(props.header),
-        rows: props.rows.map(blank),
+        header: blank(props.header, 0),
+        rows: props.rows.map((row, i) => blank(row, i + 1)),
         aligns: props.aligns
     });
 }
+/**
+ * A rectangle written in at `(r, c)`, the table growing to hold whatever runs past its
+ * edges: what a paste into a cell means (`clipboard.ts`). The alternative is clipping
+ * to the rectangle that is there, which silently drops the tail of what the author
+ * copied; growth drops nothing and every added rank is one the ops already remove.
+ *
+ * `aligns` is the table's own throughout: a column keeps its alignment under a paste,
+ * and a column the paste added arrives `none` like any other fresh one.
+ */
+export function pasteCells(props, r, c, block) {
+    const rows = allRows(props);
+    const height = Math.max(rows.length, r + block.length);
+    const width = Math.max(columnCount(props), ...block.map((row) => c + row.length));
+    return fromRows(Array.from({ length: height }, (_, i) => Array.from({ length: width }, (_, j) => block[i - r]?.[j - c] ?? rows[i]?.[j] ?? emptyCell())), props.aligns);
+}
 /** Set column `c`'s alignment: the one table capability the content round-trips
  *  today and nothing in the editor could reach. */
 export function setAlign(props, c, align) {
@@ -171,7 +215,7 @@ export function setAlign(props, c, align) {
 // ── The cell codec ──────────────────────────────────────────────────────────
 /**
  * A cell as a one-line `Content`: what `decode` takes under the inline schema. The
- * cell's marks ARE that content's marks, because both are offsets into the same
+ * cell's marks are that content's marks, because both are offsets into the same
  * text: the cell-local coordinate space is a `Content`'s coordinate space with
  * one line in it.
  */

package/dist/core/errors.d.ts

@@ -11,7 +11,7 @@ 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: the optimistic PM state stands and the
+/** The overwrite fallback also failed: 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
@@ -26,12 +26,12 @@ export type EditorErrorCode =
 /** A tip's markdown did not render: the tip shows as literal text. */
  | 'tip-render-failed'
 /**
- * A prop a surface binds ONCE was swapped in place, and the surface neither
+ * A prop a surface binds once was swapped in place, and the surface neither
  * re-keyed on it nor observed it. The mounted surface still names the previous
  * handle. `dev` throughout: the fix is a remount at the call site, so this is
  * aimed at whoever wired it and never at a running app's telemetry.
  *
- * The one code that is also THROWN, in a dev build, once reported: a swapped
+ * The one code that is also thrown, in a dev build, once reported: a swapped
  * `onError` is itself a rebind, so the handler this arrives at may be the one the
  * consumer just replaced (`rebind.svelte.ts`).
  */
@@ -39,12 +39,12 @@ export type EditorErrorCode =
 /**
  * A landing named a card or a field the surface does not hold: a `cardId` from a
  * previous session or an already-removed card, or a `DocPath` naming no declared
- * field — an array ELEMENT path included, where the array itself is undeclared or
+ * field — an array element path included, where the array itself is undeclared or
  * unmounted. The call is a no-op and the document is untouched.
  *
  * `dev`, because the fix is at the call site: a host driving the instance verbs
  * from outside, or a preview pick the editor has no field to route to. Every
- * MOUNTED field is a target, prose leaf and form control alike, and an array's
+ * mounted field is a target, prose leaf and form control alike, and an array's
  * elements are targets through it, so this is not how a scalar or an element
  * reports. The preview never reports it at all: a field it places nothing for is
  * `scrollToField` returning `false`.

package/dist/core/index.js

@@ -1,11 +1,11 @@
 // The theme derivation: the public dials → the private `--_qm-*` scale, applied
 // to every `data-qm-root` element (THEMING.md). Imported at every barrel a
 // consumer can enter through — here, `/visual`, `/preview` — because a subpath is
-// what a consumer gets, and a surface reaching a module INSIDE `core/` reaches
+// what a consumer gets, and a surface reaching a module inside `core/` reaches
 // nothing this file imports. One sheet however many barrels name it: the
 // derivation is minted once rather than re-declared per detached root.
 import './theme.css';
-// `@quillmark/svelte/core`: what this package OWNS at the substrate seam.
+// `@quillmark/svelte/core`: what this package owns at the substrate seam.
 //
 // The `@quillmark/wasm` API is not re-exported: import it straight from the peer
 // dependency, the single source of truth (quiver states the same rule). The

package/dist/core/lifecycle.js

@@ -1,5 +1,5 @@
 // `@quillmark/wasm` ships wasm-bindgen's web target: the core build is
-// instantiated by an explicit `await init()`, which RESOLVES TO the classes and
+// instantiated by an explicit `await init()`, which resolves to the classes and
 // free functions — the artifact exports none of them statically, so awaiting is
 // the only way to hold one. Instantiation carries the panic hook on its start
 // section, so a Rust panic reaches JS as a stack trace.

package/dist/core/rebind.svelte.d.ts

@@ -22,10 +22,10 @@ export declare function reportRebindIgnored(onError: EditorErrorHandler | undefi
  * in place, and in a dev build throw it after. `remount` closes the message with the
  * surface's own remount spelling (`Remount the preview ({#key session}) to rebind.`).
  *
- * Mounted identities are recorded on the effect's FIRST run, the flush the surface
+ * Mounted identities are recorded on the effect's first run, the flush the surface
  * binds in; every later comparison reads them through the same `snapshot`.
  *
- * The report goes to the SNAPSHOT's `onError`: every other error these surfaces
+ * The report goes to the snapshot's `onError`: every other error these surfaces
  * report reaches the handler they bound, and a swapped `onError` is itself one of
  * the reports.
  */

package/dist/core/rebind.svelte.js

@@ -1,9 +1,9 @@
-// The remount contract, enforced. `Preview` binds its props ONCE, in `onMount`, and
+// The remount contract, enforced. `Preview` binds its props once, in `onMount`, and
 // observes nothing after: the vanilla core below it owns scroll position, mounted
 // slots and observer sets that a remount would discard on every apply. So a prop
 // swapped in place is reported, not dropped in silence, and thrown in a dev build.
 //
-// A guard over ONE prop of a set is worse than none: a consumer who learns the
+// A guard over one prop of a set is worse than none: a consumer who learns the
 // surface complains when it ignores a prop reads silence on the rest as reactivity.
 // The snapshot is every once-bound prop, and one report names whichever went stale.
 import { reportError } from './errors.js';
@@ -34,10 +34,10 @@ export function reportRebindIgnored(onError, message) {
  * in place, and in a dev build throw it after. `remount` closes the message with the
  * surface's own remount spelling (`Remount the preview ({#key session}) to rebind.`).
  *
- * Mounted identities are recorded on the effect's FIRST run, the flush the surface
+ * Mounted identities are recorded on the effect's first run, the flush the surface
  * binds in; every later comparison reads them through the same `snapshot`.
  *
- * The report goes to the SNAPSHOT's `onError`: every other error these surfaces
+ * The report goes to the snapshot's `onError`: every other error these surfaces
  * report reaches the handler they bound, and a swapped `onError` is itself one of
  * the reports.
  */

package/dist/core/teardown.d.ts

@@ -4,7 +4,7 @@ export interface Lifespan {
     readonly alive: boolean;
     /**
      * Register work to undo at the end: a registry entry to drop, a timer or frame
-     * to cancel, a handle to free. Cancellers run in REGISTRATION order, which is
+     * to cancel, a handle to free. Cancellers run in registration order, which is
      * where the order lives. Registering on an ended span runs the canceller at
      * once: there is no later run to hold it for.
      */

package/dist/core/teardown.js

@@ -26,7 +26,7 @@ export function createLifespan() {
         end() {
             if (!alive)
                 return;
-            // Dead BEFORE the cancellers run: one of them may synchronously reach
+            // Dead before the cancellers run: one of them may synchronously reach
             // something that asks, and a span mid-teardown is not alive.
             alive = false;
             for (const cancel of cancels)