@vueye-table/core 3.0.0-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Brahim Boussadjra and vueye-table contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,30 @@
+# @vueye-table/core
+
+The framework-independent engine behind vueye-table: typed column definitions, searching,
+filtering, stable multi-column sorting, pagination, selection, column visibility and order,
+editing with undo, spreadsheet addressing, clipboard text, and CSV export. No DOM, no Node.js,
+no framework.
+
+```bash
+pnpm add @vueye-table/core
+```
+
+```ts
+import { createTable } from "@vueye-table/core";
+
+const table = createTable({
+  data: users,
+  columns: [
+    { id: "name.first", header: "First name" },
+    { id: "age", align: "end" },
+  ],
+  initialState: { pagination: { page: 1, pageSize: 20 } },
+  onStateChange: (state) => console.log(state.sorting),
+});
+
+table.search("ada");
+table.toggleSort("age");
+const { rows, pageCount, issues } = table.getSnapshot();
+```
+
+See the [repository README](https://github.com/boussadjra/vueye-table#readme) for every layer.

package/dist/index.d.ts

@@ -0,0 +1,554 @@
+//#region src/path.d.ts
+/**
+ * Dotted property paths.
+ *
+ * A column addresses nested data with a path such as `"address.city"`. The types below give every
+ * such path its value type, and the functions read and write through a path without mutating.
+ */
+type Leaf = string | number | boolean | bigint | symbol | null | undefined | Date | readonly unknown[] | ((...args: never[]) => unknown);
+type Depth = [never, 0, 1, 2, 3];
+/** Every dotted path into `T`, four levels deep. Arrays, dates, and functions are leaves. */
+type DeepKeys<T, TDepth extends number = 4> = [TDepth] extends [never] ? never : T extends Leaf ? never : { [K in keyof T & string]: K | (NonNullable<T[K]> extends Leaf ? never : `${K}.${DeepKeys<NonNullable<T[K]>, Depth[TDepth]>}`); }[keyof T & string];
+/** The value found at `TPath` in `T`. A nullable step makes the result possibly `undefined`. */
+type PathValue<T, TPath extends string> = TPath extends `${infer THead}.${infer TRest}` ? THead extends keyof T ? PathValue<NonNullable<T[THead]>, TRest> | (undefined extends T[THead] ? undefined : never) : undefined : TPath extends keyof T ? T[TPath] : undefined;
+/** Read the value at a dotted path, or `undefined` when a step is missing. */
+declare function getPath(source: unknown, path: string): unknown;
+/**
+ * Return a copy of `source` with `value` at `path`. Only the objects along the path are copied;
+ * everything else is shared. Missing steps are created as plain objects.
+ */
+declare function setPath<T>(source: T, path: string, value: unknown): T;
+//#endregion
+//#region src/column.d.ts
+type ColumnAlign = "start" | "center" | "end";
+/** How typed or pasted text becomes a value when a column has no `parse`. */
+type ColumnType = "text" | "number" | "boolean" | "date";
+/** A range filter value, inclusive at both ends. Either end may be left open. */
+interface RangeFilter {
+  readonly min?: number | string | Date | undefined;
+  readonly max?: number | string | Date | undefined;
+}
+/** Options shared by path columns and computed columns. */
+interface ColumnOptions<TRow, TValue> {
+  /** Header text. Defaults to the id made readable: `"createdAt"` becomes `"Created at"`. */
+  readonly header?: string | undefined;
+  readonly align?: ColumnAlign | undefined;
+  /** Width in pixels. */
+  readonly width?: number | undefined;
+  readonly minWidth?: number | undefined;
+  /** Whether a user may sort by this column. Defaults to `true`. */
+  readonly sortable?: boolean | undefined;
+  /** Whether the free-text search looks at this column. Defaults to `true`. */
+  readonly searchable?: boolean | undefined;
+  /** Hidden until a user shows it. */
+  readonly hidden?: boolean | undefined;
+  /**
+   * How text becomes a value. Defaults to the type of the cell's current value, or of another
+   * row's value when the cell is empty.
+   */
+  readonly type?: ColumnType | undefined;
+  /** Whether cells of this column accept edits. A function decides per row. */
+  readonly editable?: boolean | ((row: TRow) => boolean) | undefined;
+  /** Order two values; the engine flips the sign for descending sorts. */
+  readonly compare?: ((left: TValue, right: TValue) => number) | undefined;
+  /** Decide whether a row passes this column's filter value. */
+  readonly filter?: ((value: TValue, filterValue: unknown, row: TRow) => boolean) | undefined;
+  /** Turn a value into the text a cell shows, searches, copies, and exports. */
+  readonly format?: ((value: TValue, row: TRow) => string) | undefined;
+  /**
+   * Turn typed or pasted text into a value. Throw to reject the input. Defaults to reading the
+   * column's `type`.
+   */
+  readonly parse?: ((input: string, row: TRow) => TValue) | undefined;
+  /** Free-form data for renderers. The engine never reads it. */
+  readonly meta?: Readonly<Record<string, unknown>> | undefined;
+}
+/** A column that reads `row[id]`, following dots into nested objects. */
+interface PathColumnDef<TRow, TPath extends string> extends ColumnOptions<TRow, PathValue<TRow, TPath>> {
+  readonly id: TPath;
+  readonly accessor?: undefined;
+  readonly setValue?: undefined;
+}
+/** A column whose value is computed from the row. It is editable only with `setValue`. */
+interface ComputedColumnDef<TRow, TValue = unknown> extends ColumnOptions<TRow, TValue> {
+  readonly id: string;
+  readonly accessor: (row: TRow) => TValue;
+  /** Return a copy of `row` carrying `value`. Without it the column is read-only. */
+  readonly setValue?: ((row: TRow, value: TValue) => TRow) | undefined;
+}
+/**
+ * One column definition. A path column is discriminated by its literal id, so `format`,
+ * `compare`, and `parse` receive the value type found at that path.
+ */
+type ColumnDef<TRow> = { [TPath in DeepKeys<TRow>]: PathColumnDef<TRow, TPath>; }[DeepKeys<TRow>] | ComputedColumnDef<TRow, any>;
+/**
+ * A column definition for any row type, for props and containers that accept every table.
+ */
+type AnyColumnDef = ColumnDef<any>;
+/** Declare columns for a row type with full inference, outside a table. */
+declare function defineColumns<TRow>(columns: readonly ColumnDef<TRow>[]): readonly ColumnDef<TRow>[];
+/**
+ * A column resolved against its defaults. Renderers read these; they never read definitions.
+ */
+interface TableColumn<TRow> {
+  readonly id: string;
+  readonly header: string;
+  readonly align: ColumnAlign;
+  readonly width: number | undefined;
+  readonly minWidth: number | undefined;
+  readonly sortable: boolean;
+  readonly searchable: boolean;
+  readonly initiallyHidden: boolean;
+  readonly meta: Readonly<Record<string, unknown>>;
+  readonly definition: ColumnDef<TRow>;
+  getValue(row: TRow): unknown;
+  format(value: unknown, row: TRow): string;
+  compare(left: unknown, right: unknown): number;
+  matches(value: unknown, filterValue: unknown, row: TRow): boolean;
+  isEditable(row: TRow): boolean;
+  /**
+   * Parse text into a value, or report why it could not be read. `sample` is a value from another
+   * row, used to tell the column's type when this cell is empty.
+   */
+  parse(input: string, row: TRow, sample?: unknown): ParseResult;
+  /** Return a copy of `row` carrying `value`, or `undefined` for a read-only column. */
+  setValue(row: TRow, value: unknown): TRow | undefined;
+}
+/** The outcome of reading text into a cell value. */
+type ParseResult = {
+  readonly ok: true;
+  readonly value: unknown;
+} | {
+  readonly ok: false;
+  readonly message: string;
+};
+/** Order any two values: empty last, then numbers, dates, booleans, and text naturally. */
+declare function compareValues(left: unknown, right: unknown): number;
+/**
+ * Text for a value: empty for `null` and `undefined`, ISO for dates, comma-joined for arrays, and
+ * JSON for other objects. The result never depends on the runtime's locale, so server and client
+ * render the same text.
+ */
+declare function formatValue(value: unknown): string;
+/**
+ * The default column filter:
+ *
+ * - an empty filter value (`undefined`, `null`, `""`, `[]`) lets every row through;
+ * - an array keeps rows whose value is one of its items;
+ * - `{ min, max }` keeps values inside the inclusive range; a bound given as text is read as a
+ *   number or a date when the value is one, and an empty bound leaves that end open;
+ * - text keeps rows whose shown text contains it, ignoring case;
+ * - anything else keeps rows whose value is identical.
+ */
+declare function matchesFilter(value: unknown, filterValue: unknown, display: string): boolean;
+/** The column type a value suggests, or `undefined` for an empty value. */
+declare function typeOf(value: unknown): ColumnType | undefined;
+/** Read text as a column type. Empty text is `null` for every type but text. */
+declare function parseAs(input: string, type: ColumnType): ParseResult;
+/** Resolve a definition against its defaults. */
+declare function resolveColumn<TRow>(definition: ColumnDef<TRow>): TableColumn<TRow>;
+//#endregion
+//#region src/delimited.d.ts
+/** Write a matrix of text as delimited lines joined with `\n`. */
+declare function toDelimited(matrix: readonly (readonly string[])[], delimiter?: string): string;
+/**
+ * Read delimited text into a matrix. Accepts `\n` and `\r\n`, quoted fields with doubled quotes
+ * and embedded line breaks, and ignores one trailing line break.
+ */
+declare function parseDelimited(text: string, delimiter?: string): string[][];
+//#endregion
+//#region src/grid.d.ts
+/**
+ * Spreadsheet addressing and selection.
+ *
+ * A cell is addressed by its position in what is shown: the row index on the current page and the
+ * column index among visible columns. A selection is an anchor, where it started, and a focus,
+ * where it is now; the rectangle between them is the selected range.
+ */
+interface CellPosition {
+  readonly row: number;
+  readonly column: number;
+}
+interface CellRange {
+  readonly top: number;
+  readonly left: number;
+  readonly bottom: number;
+  readonly right: number;
+}
+interface GridSelection {
+  readonly anchor: CellPosition;
+  readonly focus: CellPosition;
+}
+/** The size of the addressable grid. */
+interface GridBounds {
+  readonly rows: number;
+  readonly columns: number;
+}
+type GridDirection = "up" | "down" | "left" | "right";
+interface MoveOptions {
+  /** Keep the anchor and move only the focus, growing or shrinking the range. */
+  readonly extend?: boolean | undefined;
+  /** Jump to the edge of the grid in that direction. */
+  readonly toEdge?: boolean | undefined;
+}
+declare function clampPosition(position: CellPosition, bounds: GridBounds): CellPosition;
+/** A selection of one cell. */
+declare function selectCell(position: CellPosition): GridSelection;
+/** Move the focus one step, or to the edge, staying inside the bounds. */
+declare function moveSelection(selection: GridSelection, direction: GridDirection, bounds: GridBounds, options?: MoveOptions): GridSelection;
+/** The rectangle a selection covers. */
+declare function selectionRange(selection: GridSelection): CellRange;
+declare function rangeContains(range: CellRange, position: CellPosition): boolean;
+/** `0` is `"A"`, `25` is `"Z"`, `26` is `"AA"`. */
+declare function columnLabel(index: number): string;
+/** `{ row: 2, column: 1 }` is `"B3"`. */
+declare function toA1(position: CellPosition): string;
+/** `"B3"` is `{ row: 2, column: 1 }`. Returns `undefined` for anything else. */
+declare function fromA1(reference: string): CellPosition | undefined;
+/** The keys of a keyboard event that grid navigation reads. */
+interface GridKey {
+  readonly key: string;
+  readonly shiftKey?: boolean | undefined;
+  readonly ctrlKey?: boolean | undefined;
+  readonly metaKey?: boolean | undefined;
+  readonly altKey?: boolean | undefined;
+}
+/** What a key press asks a grid to do while no cell is being edited. */
+type GridCommand = {
+  readonly type: "move";
+  readonly direction: GridDirection;
+  readonly options: MoveOptions;
+} | {
+  readonly type: "edit";
+  readonly initial?: string | undefined;
+} | {
+  readonly type: "clear";
+} | {
+  readonly type: "selectAll";
+} | {
+  readonly type: "undo";
+} | {
+  readonly type: "redo";
+} | {
+  readonly type: "cancel";
+};
+/**
+ * Map a key press to a grid command, spreadsheet style: arrows move (Shift extends, Ctrl or Cmd
+ * jumps to the edge), Tab moves across, Home and End reach the row's ends, Enter or F2 edit,
+ * a printable character starts editing with that character, Delete and Backspace clear, Escape
+ * collapses the selection, and Ctrl or Cmd with A, Z, Y select all, undo, and redo.
+ */
+declare function gridCommand(event: GridKey): GridCommand | undefined;
+//#endregion
+//#region src/undo-stack.d.ts
+/**
+ * An undo stack of batches. Recording a batch clears whatever could be redone, and the stack
+ * keeps at most `limit` batches, dropping the oldest.
+ */
+interface UndoStack<TEntry> {
+  readonly canUndo: boolean;
+  readonly canRedo: boolean;
+  record(entry: TEntry): void;
+  /** Take the most recent batch to undo, if any. */
+  undo(): TEntry | undefined;
+  /** Take the most recently undone batch to redo, if any. */
+  redo(): TEntry | undefined;
+  clear(): void;
+}
+declare function createUndoStack<TEntry>(limit?: number): UndoStack<TEntry>;
+//#endregion
+//#region src/humanize.d.ts
+/**
+ * Turn a column id into a readable header: `"name.first_name"` becomes `"Name first name"` and
+ * `"createdAt"` becomes `"Created at"`.
+ */
+declare function humanize(id: string): string;
+//#endregion
+//#region src/infer.d.ts
+/**
+ * Columns for data that has none declared: one path column per leaf of the first `sample` rows,
+ * nested objects flattened into dotted paths, in first-seen order.
+ */
+declare function inferColumns<TRow>(rows: readonly TRow[], sample?: number): readonly ColumnDef<TRow>[];
+//#endregion
+//#region src/state.d.ts
+/** A stable identity for a row, read from the row itself or produced by a function. */
+type RowKey = string | number;
+type SortDirection = "asc" | "desc";
+/** One level of a sort. Several rules sort by the first, then break ties with the next. */
+interface SortRule {
+  readonly column: string;
+  readonly direction: SortDirection;
+}
+/** Pages are counted from 1. */
+interface PaginationState {
+  readonly page: number;
+  readonly pageSize: number;
+}
+/**
+ * Everything a user can change about a table, as plain serializable data.
+ *
+ * Being plain data, the state can be stored, restored, sent to a server that sorts and pages, or
+ * written to the URL with a library such as QueryWeave.
+ */
+interface TableState {
+  readonly sorting: readonly SortRule[];
+  /** Free text matched against every searchable column. */
+  readonly search: string;
+  /** Filter value per column id, interpreted by that column's `filter`. */
+  readonly filters: Readonly<Record<string, unknown>>;
+  readonly pagination: PaginationState;
+  readonly selection: readonly RowKey[];
+  readonly hiddenColumns: readonly string[];
+  /** Column ids in display order. Columns missing from the list keep their definition order. */
+  readonly columnOrder: readonly string[];
+}
+/** A partial state, as accepted by `setState` and `initialState`. */
+type TableStatePatch = { readonly [K in keyof TableState]?: TableState[K] | undefined; };
+declare const DEFAULT_PAGE_SIZE = 10;
+//#endregion
+//#region src/issues.d.ts
+/** Every problem the engine can report. The union grows in minor versions. */
+type TableIssueCode = "duplicate_row_key" | "unknown_column" | "invalid_page_size" | "unknown_row" | "read_only_cell" | "invalid_value";
+/**
+ * A problem the engine recovered from. Invalid input is never dropped silently: the engine falls
+ * back to something safe and reports what it did here.
+ */
+interface TableIssue {
+  readonly code: TableIssueCode;
+  readonly message: string;
+  readonly column?: string | undefined;
+  readonly rowKey?: RowKey | undefined;
+}
+//#endregion
+//#region src/row.d.ts
+/**
+ * One row of data as the engine sees it: its key, its position in the source data, and cached
+ * access to each column's value and text.
+ */
+interface TableRow<TRow> {
+  readonly key: RowKey;
+  /** Position in the data the table was given. */
+  readonly index: number;
+  readonly original: TRow;
+  getValue(columnId: string): unknown;
+  /** The formatted text of a cell, as shown, searched, copied, and exported. */
+  getDisplay(columnId: string): string;
+}
+//#endregion
+//#region src/pipeline.d.ts
+/**
+ * Keep rows that pass every column filter and contain every search term in at least one
+ * searchable column.
+ */
+declare function filterRows<TRow>(rows: readonly TableRow<TRow>[], columns: readonly TableColumn<TRow>[], search: string, filters: Readonly<Record<string, unknown>>): readonly TableRow<TRow>[];
+/** Sort rows by each rule in turn. The sort is stable: ties keep their incoming order. */
+declare function sortRows<TRow>(rows: readonly TableRow<TRow>[], columns: readonly TableColumn<TRow>[], sorting: readonly SortRule[]): readonly TableRow<TRow>[];
+/** The number of pages for a row count. An empty table still has one page. */
+declare function countPages(rowCount: number, pageSize: number): number;
+/** Clamp a page into `1..pageCount`. */
+declare function clampPage(page: number, pageCount: number): number;
+/** The rows on one page. `pagination.page` must already be clamped. */
+declare function paginateRows<TRow>(rows: readonly TableRow<TRow>[], pagination: PaginationState): readonly TableRow<TRow>[];
+/** A page number, or a gap between page numbers. */
+type PageItem = {
+  readonly type: "page";
+  readonly page: number;
+  readonly current: boolean;
+} | {
+  readonly type: "gap";
+  readonly key: string;
+};
+/**
+ * The page buttons to show: always the first and last page, `siblings` pages on each side of the
+ * current one, and a gap wherever pages are skipped. A gap never hides a single page.
+ */
+declare function paginationItems(page: number, pageCount: number, siblings?: number): readonly PageItem[];
+//#endregion
+//#region src/table.d.ts
+type SelectionMode = "none" | "single" | "multiple";
+/** Which rows "select all" covers: the current page, or every row that passes the filters. */
+type SelectScope = "page" | "all";
+interface TableOptions<TRow> {
+  readonly data: readonly TRow[];
+  readonly columns: readonly ColumnDef<TRow>[];
+  /**
+   * How to identify a row: a path into it, or a function. Defaults to `id` when rows have one and
+   * to the row's position otherwise.
+   */
+  readonly rowKey?: DeepKeys<TRow> | ((row: TRow, index: number) => RowKey) | undefined;
+  readonly initialState?: TableStatePatch | undefined;
+  /** Defaults to `"multiple"`. */
+  readonly selectionMode?: SelectionMode | undefined;
+  /** Defaults to `"all"`. */
+  readonly selectScope?: SelectScope | undefined;
+  /**
+   * The data is one page that a server has already searched, filtered, sorted, and paginated
+   * with the current state. The table only presents it; `rowCount` gives the total.
+   */
+  readonly manual?: boolean | undefined;
+  /** The total number of rows across all pages, for `manual` tables. */
+  readonly rowCount?: number | undefined;
+  /** Called after every state change a table operation makes, not after `setState`. */
+  readonly onStateChange?: ((state: TableState, previous: TableState) => void) | undefined;
+  /** Called with the new data after an edit, a paste, an undo, or a redo. */
+  readonly onDataChange?: ((data: readonly TRow[], changes: readonly CellChange<TRow>[]) => void) | undefined;
+  /** Called with the reasons whenever an edit, a paste, or a clear refuses some cells. */
+  readonly onEditIssues?: ((issues: readonly TableIssue[]) => void) | undefined;
+  /** The most edit batches `undo` can reach. Defaults to 100. */
+  readonly historyLimit?: number | undefined;
+}
+type SelectionCoverage = "none" | "some" | "all";
+interface SortInfo {
+  readonly direction: SortDirection;
+  /** 0 for the first rule, 1 for the next, and so on. */
+  readonly priority: number;
+}
+/**
+ * Everything a renderer needs, computed from the data, the columns, and the state. A snapshot is
+ * frozen and replaced on each change, so comparing snapshots by identity detects a change.
+ */
+interface TableSnapshot<TRow> {
+  readonly state: TableState;
+  /** Visible columns in display order. */
+  readonly columns: readonly TableColumn<TRow>[];
+  /** Every column in display order, hidden ones included. */
+  readonly allColumns: readonly TableColumn<TRow>[];
+  /** Rows on the current page. */
+  readonly rows: readonly TableRow<TRow>[];
+  /** Rows on every page, filtered and sorted. For `manual` tables this is the current page. */
+  readonly processedRows: readonly TableRow<TRow>[];
+  /** The current page, clamped into range. */
+  readonly page: number;
+  readonly pageSize: number;
+  readonly pageCount: number;
+  /** Rows that pass the search and filters. */
+  readonly rowCount: number;
+  /** Rows before searching and filtering. */
+  readonly totalRowCount: number;
+  /** The 1-based position of the first row on this page, or 0 when there are no rows. */
+  readonly pageStart: number;
+  /** The 1-based position of the last row on this page, or 0 when there are no rows. */
+  readonly pageEnd: number;
+  readonly pageItems: readonly PageItem[];
+  readonly canPreviousPage: boolean;
+  readonly canNextPage: boolean;
+  readonly selectionMode: SelectionMode;
+  readonly selectedCount: number;
+  /** How much of the current page is selected. */
+  readonly pageSelection: SelectionCoverage;
+  /** How much of the select-all scope is selected. */
+  readonly allSelection: SelectionCoverage;
+  readonly canUndo: boolean;
+  readonly canRedo: boolean;
+  readonly issues: readonly TableIssue[];
+  isSelected(key: RowKey): boolean;
+  getSort(columnId: string): SortInfo | undefined;
+  getColumn(columnId: string): TableColumn<TRow> | undefined;
+  getRow(key: RowKey): TableRow<TRow> | undefined;
+}
+/** An edit given as a value of the column's type. */
+interface CellValueEdit {
+  readonly rowKey: RowKey;
+  readonly column: string;
+  readonly value: unknown;
+}
+/** An edit given as text, read by the column's `parse`, as typed or pasted. */
+interface CellInputEdit {
+  readonly rowKey: RowKey;
+  readonly column: string;
+  readonly input: string;
+}
+type CellEdit = CellValueEdit | CellInputEdit;
+interface CellChange<TRow> {
+  readonly rowKey: RowKey;
+  readonly column: string;
+  readonly previous: unknown;
+  readonly value: unknown;
+  /** The row after the change. */
+  readonly row: TRow;
+}
+type EditStatus = "applied" | "partial" | "rejected" | "unchanged";
+/**
+ * The outcome of a batch of edits. `partial` means some edits applied and others were refused;
+ * each refusal is in `issues`.
+ */
+interface EditResult<TRow> {
+  readonly status: EditStatus;
+  readonly changes: readonly CellChange<TRow>[];
+  readonly issues: readonly TableIssue[];
+}
+interface ExportOptions {
+  /** Defaults to `"csv"`. */
+  readonly format?: "csv" | "tsv" | undefined;
+  /** Column ids to export. Defaults to the visible columns. */
+  readonly columns?: readonly string[] | undefined;
+  /** Export only the current page. Defaults to every filtered row. */
+  readonly pageOnly?: boolean | undefined;
+  /** Defaults to `true`. */
+  readonly headers?: boolean | undefined;
+}
+/**
+ * A data table: data, columns, and state, with named operations to change them. It knows nothing
+ * about rendering; a framework binding subscribes to it and draws each snapshot.
+ */
+interface DataTable<TRow> {
+  getSnapshot(): TableSnapshot<TRow>;
+  getState(): TableState;
+  /** Called after every change with the new snapshot. Returns the unsubscribe function. */
+  subscribe(listener: (snapshot: TableSnapshot<TRow>) => void): () => void;
+  /** Replace part of the state from outside, without calling `onStateChange`. */
+  setState(patch: TableStatePatch): void;
+  /** Replace the data. The undo stack is cleared unless the data is the table's own. */
+  setData(data: readonly TRow[]): void;
+  setColumns(columns: readonly ColumnDef<TRow>[]): void;
+  /** Update the total row count of a `manual` table. */
+  setRowCount(rowCount: number): void;
+  /** Cycle a column through ascending, descending, and unsorted. */
+  toggleSort(columnId: string, options?: {
+    readonly multi?: boolean | undefined;
+  }): void;
+  /** Sort by one column, or clear it with `undefined`. */
+  sort(columnId: string, direction: SortDirection | undefined, options?: {
+    readonly multi?: boolean | undefined;
+  }): void;
+  clearSorting(): void;
+  search(text: string): void;
+  /** Set a column's filter value; an empty value removes the filter. */
+  filter(columnId: string, value: unknown): void;
+  clearFilters(): void;
+  goToPage(page: number): void;
+  nextPage(): void;
+  previousPage(): void;
+  /** Change the page size, keeping the first row of the current page in view. */
+  setPageSize(pageSize: number): void;
+  select(keys: readonly RowKey[]): void;
+  deselect(keys: readonly RowKey[]): void;
+  toggleRow(key: RowKey, selected?: boolean): void;
+  /** Select every row in the scope, or clear them when all are already selected. */
+  toggleAll(scope?: SelectScope): void;
+  clearSelection(): void;
+  /** The selected rows that are present in the data. */
+  getSelectedRows(): readonly TableRow<TRow>[];
+  toggleColumn(columnId: string, visible?: boolean): void;
+  moveColumn(columnId: string, toIndex: number): void;
+  edit(edits: CellEdit | readonly CellEdit[]): EditResult<TRow>;
+  undo(): boolean;
+  redo(): boolean;
+  /** The text of a range of shown cells, tab-separated like a spreadsheet clipboard. */
+  copy(range: CellRange): string;
+  /** Paste tab-separated text with its top-left cell at `origin`, clipped to the grid. */
+  paste(origin: CellPosition, text: string): EditResult<TRow>;
+  /** Empty every editable cell in a range. */
+  clear(range: CellRange): EditResult<TRow>;
+  exportRows(options?: ExportOptions): string;
+  /** Return to the initial state. */
+  reset(): void;
+  /** Drop every listener. */
+  destroy(): void;
+}
+/** Create a data table. */
+declare function createTable<TRow>(options: TableOptions<TRow>): DataTable<TRow>;
+//#endregion
+export { type AnyColumnDef, type CellChange, type CellEdit, type CellInputEdit, type CellPosition, type CellRange, type CellValueEdit, type ColumnAlign, type ColumnDef, type ColumnOptions, type ColumnType, type ComputedColumnDef, DEFAULT_PAGE_SIZE, type DataTable, type DeepKeys, type EditResult, type EditStatus, type ExportOptions, type GridBounds, type GridCommand, type GridDirection, type GridKey, type GridSelection, type MoveOptions, type PageItem, type PaginationState, type ParseResult, type PathColumnDef, type PathValue, type RangeFilter, type RowKey, type SelectScope, type SelectionCoverage, type SelectionMode, type SortDirection, type SortInfo, type SortRule, type TableColumn, type TableIssue, type TableIssueCode, type TableOptions, type TableRow, type TableSnapshot, type TableState, type TableStatePatch, type UndoStack, clampPage, clampPosition, columnLabel, compareValues, countPages, createTable, createUndoStack, defineColumns, filterRows, formatValue, fromA1, getPath, gridCommand, humanize, inferColumns, matchesFilter, moveSelection, paginateRows, paginationItems, parseAs, parseDelimited, rangeContains, resolveColumn, selectCell, selectionRange, setPath, sortRows, toA1, toDelimited, typeOf };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/path.ts","../src/column.ts","../src/delimited.ts","../src/grid.ts","../src/undo-stack.ts","../src/humanize.ts","../src/infer.ts","../src/state.ts","../src/issues.ts","../src/row.ts","../src/pipeline.ts","../src/table.ts"],"mappings":"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"}