@quillmark/svelte 0.27.0 → 0.28.0

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

@@ -8,110 +8,143 @@ 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. 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.
+ * The row index space the chrome and the ops share: **0 is the header**, 1…n the body rows. A row
+ * op works {@link allRows}, and whichever row lands at index 0 is the header afterwards. 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. */
+/**
+ * Whether a row holds no text, telling a row on offer from one taken up (`table-view.ts` §`step`).
+ * Text alone: a mark over none is invisible.
+ */
 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. */
 export declare function columnCount(props: TableProps): number;
 /**
- * The rectangularizing constructor: one column count across `header`, every row,
- * `aligns` and `widths`, padding with empty cells, `none` and auto-fit. The column
- * count is the widest thing present, so a caller that appended to one axis alone still
- * gets a rectangle back, and a table is never narrower than one column. The layout
- * keys ride through, each absent at its default as the store writes it.
+ * The rectangularizing constructor: one column count (the widest thing present, at least one)
+ * across `header`, every row, `aligns` and `widths`, padding with empty cells, `none` and auto-fit.
+ * The layout keys ride through, each absent at its default as the store writes it.
  */
 export declare function normalizeTable(props: TableProps): TableProps;
+/** How many rows from the top draw as header rows, absent being one. */
+export declare function headRows(props: TableProps): number;
+/** The columns and rows a drawn cell spans. */
+export interface Span {
+    colspan: number;
+    rowspan: number;
+}
+/** {@link spansOf} over a table's rows, header first. */
+export declare function spanGrid(props: TableProps): (Span | null)[][];
+/**
+ * The drawn cell whose span covers `(r, c)`; the slot itself where nothing covers it or it lies
+ * outside the grid.
+ */
+export declare function anchorAt(grid: (Span | null)[][], r: number, c: number): {
+    r: number;
+    c: number;
+    span: Span;
+};
 /**
- * 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.
+ * The rows as one list, header first: the space a row op works in, so move and delete treat every
+ * row alike. `header` is a separate field because a table always has one; {@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. */
+/** A fresh table: a header plus `bodyRows` empty rows, every column unaligned. */
 export declare function newTable(cols?: number, bodyRows?: number): TableProps;
 /** `props` with the cell at `(r, c)` replaced. */
 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 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. */
+/**
+ * Drop row `r`, the header included: the row left at index 0 becomes the header. A no-op at the
+ * last row, which is the removal of the table and the island's 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;
-/** 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. */
+/**
+ * Row `r` moved by `by` places, clamped: a drag past the rectangle is a no-op, not an error. The
+ * header travels like any other row; being the header is holding index 0.
+ */
 export declare function moveRow(props: TableProps, r: number, by: number): TableProps;
-/** Column `c` moved by `by` places, clamped. `aligns` and `widths` travel with the
- *  column: each is the column's property, so a move that left it behind would retint
- *  or resize the column that took the index. */
+/**
+ * Column `c` moved by `by` places, clamped. `aligns` and `widths` travel with the column, being its
+ * properties.
+ */
 export declare function moveColumn(props: TableProps, c: number, by: 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.
- *
- * A cell keeps its own alignment, and a column its alignment and width: what a clear
- * empties is text.
+ * Every cell in the inclusive rectangle emptied, alignment kept (a cell its own, a column its
+ * alignment and width): a delete over a block covering no whole rank. A rectangle spanning one axis
+ * deletes ranks and one spanning both is the table, so what reaches here is a proper sub-rectangle.
  */
 export declare function clearCells(props: TableProps, r0: number, c0: number, r1: number, c1: number): TableProps;
-/** 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`). */
+/**
+ * Set column `c`'s alignment and clear its cells' own `align`, which would outrank it
+ * (`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;
-/** 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. */
+/** Draw the top `head` rows as header rows (`table-view.ts`). */
+export declare function setHead(props: TableProps, head: number): TableProps;
+/** An inclusive block of cells, in the row space {@link rowCount} names. */
+export interface CellBlock {
+    r0: number;
+    c0: number;
+    r1: number;
+    c1: number;
+}
+/** `block` grown until every drawn cell it touches lies wholly inside it. */
+export declare function closeBlock(props: TableProps, block: CellBlock): CellBlock;
+/**
+ * Whether `block` can be one cell: more than one drawn cell, inside the header rows or the body.
+ */
+export declare function canMerge(props: TableProps, block: CellBlock): boolean;
+/**
+ * The block's cells as one, at its top-left: the text of each drawn cell holding any, in reading
+ * order, a line apiece, every other slot an empty one the span covers, alignment kept. The top-left
+ * cell's alignment is the merged cell's. A block {@link canMerge} refuses comes back as it was.
+ */
+export declare function mergeCells(props: TableProps, block: CellBlock): TableProps;
+/**
+ * The merged cell covering `(r, c)` back to the cells under it: its text stays top-left, the rest
+ * are the empty cells it covered.
+ */
+export declare function splitCell(props: TableProps, r: number, c: number): TableProps;
+/**
+ * Set or clear the column weights (`table-view.ts`); `undefined` returns every column to auto-fit.
+ */
 export declare function setWidths(props: TableProps, widths: (number | null)[] | undefined): TableProps;
 /**
- * Each column's share of the table's width, summing to 1, or `undefined` for a table
- * that auto-fits throughout. An auto-fit column beside weighted ones takes the mean
- * weight: the page sizes it to its content, which the editor's grid, laid out fixed so
- * the weights hold, cannot ask.
+ * Each column's share of the table's width, summing to 1, or `undefined` for a table that auto-fits
+ * throughout. An auto-fit column beside weighted ones takes the mean weight, since the editor's
+ * fixed-layout grid cannot size it to content as the page does.
  */
 export declare function columnShares(props: TableProps): number[] | undefined;
 /**
- * A cell as a one-paragraph `Content`: what `decode` takes under `cellSchema`. Each
- * `\n` in the text opens a `continues` line, which is the hard break it decodes to and
- * the one USV `pmToContent` projects a break back to. The cell's marks are that
- * content's marks, both being offsets into the same text.
+ * A cell as a one-paragraph `Content` for `decode` under `cellSchema`: each `\n` opens a
+ * `continues` line, the hard break it decodes to. The cell's marks are that content's marks.
  */
 export declare function cellContent(cell: TableCell): Content;
 /**
  * The cell a nested PM doc projects, carrying `prior`'s identity anchors through.
  *
- * Anchors inside a cell are **preserved verbatim, never minted**: they are not in
- * the field plugin's coordinate space (the field's position map holds one `atom`
- * run for the whole table), so nothing here can mint one and the popover withholds
- * its `anchor` button while the caret is in a cell. Preserving them still means
- * rebasing: a cell edit is a splice like any other, so `mapMarks` carries each held
- * anchor through the cell's own delta by the rule the store applies to a field's,
- * and a mark the splice deleted through lands where the splice left it rather than
- * pointing past the text.
+ * Anchors inside a cell are preserved verbatim, never minted: they are not in the field plugin's
+ * coordinate space (its position map holds one `atom` run for the whole table), so the popover
+ * withholds its `anchor` button in a cell. Preserving still means rebasing: `mapMarks` carries each
+ * held anchor through the cell's delta by the store's rule, and a mark the splice deleted through
+ * lands where the splice left it.
  */
 export declare function cellFromDoc(doc: PMNode, prior: TableCell): TableCell;
-/** Whether two cells are the same value: what tells an own edit (the projection the
- *  view just produced) from an external one (an undo, a re-hydrate) without a flag.
- *  The marks structurally, for the reason `reconcile.ts` states. */
+/**
+ * Whether two cells are the same value, telling an own edit from an external one (an undo, a
+ * re-hydrate) without a flag. Marks compare structurally, as `reconcile.ts` states.
+ */
 export declare function cellEqual(a: TableCell, b: TableCell): boolean;
 /** Whether two tables have the same rectangle, alignment, header and widths: the
  *  change that forces a rebuild rather than a per-cell reseed. */