@guiexpert/table 1.1.98 → 1.1.100

package/lib/table/clipboard/input-pipes.d.ts

@@ -0,0 +1,59 @@
+import { editInputPipe } from '../renderer/edit/edit-input-pipe.if.js';
+
+/**
+ * An `editInputPipe` for numbers in the format of a locale, for the editor and for pasting: `"1.234,56"` (de-DE) and
+ * `"1,234.56"` (en-US) → `1234.56`, `"12 %"` → `0.12`, `"€ 9,90"` → `9.9`, `"(5)"` → `-5`. Empty text stays `""`,
+ * text that is no number stays as it is (a `validate` of the column can refuse it); numbers pass unchanged.
+ *
+ * @param {string} [locale] - BCP 47 tag, default: the browser's locale
+ * @returns {editInputPipe} the pipe
+ *
+ * @example
+ * ColumnDef.create({ property: "price", editable: TrueFn, editInputPipe: createNumberInputPipe("de-DE") });
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export declare function createNumberInputPipe(locale?: string): editInputPipe;
+/**
+ * An `editInputPipe` for dates: ISO text (`"2026-10-16"`, with time `"2026-10-16T08:30"`) or the short date of the
+ * locale (`"16.10.2026"` in de-DE, `"10/16/2026"` in en-US) → `Date` (local time). Empty text stays `""`, other text as
+ * it is; a `Date` passes unchanged.
+ *
+ * @param {string} [locale] - BCP 47 tag for the order of day and month, default: the browser's locale
+ * @returns {editInputPipe} the pipe
+ *
+ * @example
+ * ColumnDef.create({ property: "due", editable: TrueFn, editInputPipe: createDateInputPipe("de-DE") });
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export declare function createDateInputPipe(locale?: string): editInputPipe;
+/**
+ * An `editInputPipe` for `true`/`false`: `"TRUE"`, `"yes"`, `"1"`, `"x"` (also German `WAHR`, `ja`) → `true`; `"FALSE"`,
+ * `"no"`, `"0"` (`FALSCH`, `nein`) → `false`, ignoring case; empty text stays `""`, other text as it is.
+ *
+ * @example
+ * ColumnDef.create({ property: "paid", editable: TrueFn, editInputPipe: booleanInputPipe });
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export declare const booleanInputPipe: editInputPipe;
+/**
+ * An `editInputPipe` that recognizes values like Excel: a number in the format of the locale (also `%` and currency
+ * signs), a date (ISO or the short date of the locale), `TRUE`/`FALSE` (ignoring case) – otherwise text. Text that
+ * starts with `=` or `'=` (formulas, see the spreadsheet mode) stays unchanged; so does a leading `'` (Excel: "keep
+ * this as text") minus the quote.
+ *
+ * @param {string} [locale] - BCP 47 tag, default: the browser's locale
+ * @returns {editInputPipe} the pipe
+ *
+ * @example
+ * ColumnDef.create({ property: "b", editable: TrueFn, editInputPipe: sheetInputPipe("en-US") });
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export declare function sheetInputPipe(locale?: string): editInputPipe;

package/lib/table/clipboard/paste-plan.d.ts

@@ -0,0 +1,96 @@
+import { CellRange } from '../data/common/cell-range.js';
+
+/**
+ * Input of {@link computePastePlan}: what is pasted and where. All rows are **displayed** rows (display order after
+ * sorting and filtering), columns are model indices; `shownColumns` lists the visible columns in display order –
+ * hidden columns are skipped and not counted (like the fill handle).
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export interface PasteRequestIf<V = unknown> {
+    /** The pasted cells (rows of values, at least one row and one column). */
+    matrix: ReadonlyArray<ReadonlyArray<V>>;
+    /** First row of the target (display index). */
+    anchorRow: number;
+    /** First column of the target (model index, must be in `shownColumns`). */
+    anchorColumn: number;
+    /** The visible columns (model indices) in display order. */
+    shownColumns: ReadonlyArray<number>;
+    /** Number of displayed body rows. */
+    rowCount: number;
+    /**
+     * The selected target in rows × shown columns (from the anchor), if a range is selected: an integer multiple of
+     * the matrix tiles it (Excel), a single value fills it.
+     */
+    selection?: {
+        rows: number;
+        columns: number;
+    };
+    /** True if rows may be added below the last row (`pasteAddsRows`). */
+    canAddRows?: boolean;
+    /** `false` skips a target cell (not editable, calculated, group row); it still counts for the layout. */
+    isWritable?: (rowIndex: number, columnIndex: number) => boolean;
+}
+/**
+ * Result of {@link computePastePlan}.
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export interface PastePlanIf<V = unknown> {
+    /** The cells to write: display row (may be ≥ `rowCount` for added rows), model column, value. */
+    cells: {
+        rowIndex: number;
+        columnIndex: number;
+        value: V;
+    }[];
+    /** The covered target (display rows, model columns from the first to the last shown column). */
+    range: CellRange;
+    /** Target cells left out because they are not writable. */
+    skipped: number;
+    /** Cells cut off at the last column (or the last row without `canAddRows`). */
+    clipped: number;
+    /** Rows to add below the last row before writing (`canAddRows`). */
+    addRows: number;
+}
+/**
+ * Where pasted cells go, like Excel: from the anchor, once – or tiled over a selected range that is an integer
+ * multiple of the matrix, a single value into every cell of the selected range; cut off at the last column (and at
+ * the last row unless rows may be added); cells that are not writable are skipped. DOM-free.
+ *
+ * @param {PasteRequestIf<V>} req - matrix, target and table size
+ * @returns {PastePlanIf<V>} the cells to write
+ *
+ * @example
+ * const plan = computePastePlan({ matrix: [["x"]], anchorRow: 1, anchorColumn: 2, shownColumns: [0, 1, 2, 3],
+ *   rowCount: 10, selection: { rows: 3, columns: 1 } });
+ * plan.cells.length;   // 3 – rows 1…3 of column 2
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export declare function computePastePlan<V>(req: PasteRequestIf<V>): PastePlanIf<V>;
+/**
+ * The size a paste covers before cutting off: the matrix – or the selected range if the matrix is a single value or
+ * fits into it an integer number of times (tiling, Excel).
+ *
+ * @param {number} matrixRows - rows of the pasted cells
+ * @param {number} matrixColumns - columns of the pasted cells
+ * @param {{ rows: number, columns: number }} [selection] - the selected range (rows × shown columns)
+ * @returns {{ rows: number, columns: number }} the covered size
+ *
+ * @example
+ * getPasteSize(2, 1, { rows: 6, columns: 1 });   // { rows: 6, columns: 1 } – three times
+ * getPasteSize(2, 1, { rows: 5, columns: 1 });   // { rows: 2, columns: 1 } – once
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export declare function getPasteSize(matrixRows: number, matrixColumns: number, selection?: {
+    rows: number;
+    columns: number;
+}): {
+    rows: number;
+    columns: number;
+};

package/lib/table/clipboard/tsv.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Text of a cell matrix as tab-separated values (TSV) the way Excel and Google Sheets read it: cells separated by a
+ * tab, rows by a line break; a cell with a tab, a line break or a quotation mark is put in quotation marks
+ * (`"…"`), a quotation mark inside is doubled. DOM-free.
+ *
+ * @param {ReadonlyArray<ReadonlyArray<string>>} matrix - rows of cell texts
+ * @returns {string} the TSV text (a line break at the end only if the last row is empty)
+ *
+ * @example
+ * toTsv([["a", "b"], ["1", 'say "hi"']]);   // 'a\tb\n1\t"say ""hi"""'
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export declare function toTsv(matrix: ReadonlyArray<ReadonlyArray<string>>): string;
+/**
+ * Cell matrix of a TSV text from the clipboard (Excel, Google Sheets, LibreOffice, a text editor): line breaks
+ * `\r\n`, `\n` or `\r`; a cell that starts with a quotation mark is quoted (`""` inside = one quotation mark, line
+ * breaks and tabs inside belong to the cell); one line break at the end is ignored; a byte order mark is removed;
+ * shorter rows are filled with `""`. DOM-free.
+ *
+ * @param {string} text - the clipboard text
+ * @returns {string[][]} rows of cell texts, all of the same length; `[]` for `""`
+ *
+ * @example
+ * parseTsv('a\t"x\ny"\r\n1\t2\r\n');   // [["a", "x\ny"], ["1", "2"]]
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export declare function parseTsv(text: string): string[][];

package/lib/table/data/common/event/ge-edit-event.d.ts

@@ -0,0 +1,46 @@
+import { CellEditMode } from '../../../sheet-editing/cell-editor.if.js';
+
+/**
+ * What happened to the cell editor: `"start"` (opened), `"input"` (its text changed – Excel-style editing only),
+ * `"commit"` (closed with the input written or – batch edit – marked), `"cancel"` (closed without writing).
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export type GeEditEventType = "start" | "input" | "commit" | "cancel";
+/**
+ * Reported by {@link EventListenerIf.onEditingChanged}: the cell editor opened, its text changed, it committed or
+ * it was cancelled – e.g. to show the input in an own formula bar or to disable buttons while editing.
+ *
+ * @example
+ * const listener = new EventAdapter();
+ * listener.onEditingChanged = (evt: GeEditEvent) => {
+ *   hint.textContent = evt.type === "start" ? `Editing row ${evt.rowIndex + 1}` : "";
+ * };
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export declare class GeEditEvent {
+    /** What happened. */
+    readonly type: GeEditEventType;
+    /** Display row index of the edited body cell. */
+    readonly rowIndex: number;
+    /** Model column index. */
+    readonly columnIndex: number;
+    /** "enter" (opened by typing) or "edit" (F2, Enter, double click). */
+    readonly mode: CellEditMode;
+    /** The text of the editor (`"input"` and `"commit"`). */
+    readonly input?: string | undefined;
+    constructor(
+    /** What happened. */
+    type: GeEditEventType, 
+    /** Display row index of the edited body cell. */
+    rowIndex: number, 
+    /** Model column index. */
+    columnIndex: number, 
+    /** "enter" (opened by typing) or "edit" (F2, Enter, double click). */
+    mode: CellEditMode, 
+    /** The text of the editor (`"input"` and `"commit"`). */
+    input?: string | undefined);
+}

package/lib/table/data/common/event/ge-row-drag-event.d.ts

@@ -56,7 +56,7 @@ export declare class GeRowDragEvent<T = any> {
     /** true if the table moves the rows itself ({@link RowDragOptionsIf.managed}). */
     readonly managed: boolean;
     /** The browser event behind this event (pointer or keyboard). */
-    readonly originalEvent?: PointerEvent | KeyboardEvent | undefined;
+    readonly originalEvent?: KeyboardEvent | PointerEvent | undefined;
     /** true if the moved rows changed in the table (managed mode, `"end"`, not prevented). */
     moved: boolean;
     private prevented;
@@ -81,7 +81,7 @@ export declare class GeRowDragEvent<T = any> {
     /** true if the table moves the rows itself ({@link RowDragOptionsIf.managed}). */
     managed: boolean, 
     /** The browser event behind this event (pointer or keyboard). */
-    originalEvent?: PointerEvent | KeyboardEvent | undefined);
+    originalEvent?: KeyboardEvent | PointerEvent | undefined);
     /** true after {@link preventDefault}. */
     get defaultPrevented(): boolean;
     /** Veto: no drag (`"start"`), invalid target (`"move"`); no effect in `"end"` and `"cancel"`. */

package/lib/table/data/common/event/ge-undo-event.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The undo history changed ({@link EventListenerIf.onUndoStackChanged}, wrapper event `undoStackChanged`): enough to
+ * enable and label own buttons ("Undo Paste").
+ *
+ * @example
+ * const listener = new EventAdapter();
+ * listener.onUndoStackChanged = (evt: GeUndoEvent) => {
+ *   undoButton.disabled = !evt.canUndo;
+ *   undoButton.title = evt.undoLabel ? `Undo ${evt.undoLabel}` : "Undo";
+ * };
+ *
+ * @category Events
+ * @since 1.1.99
+ */
+export declare class GeUndoEvent {
+    readonly canUndo: boolean;
+    readonly canRedo: boolean;
+    readonly undoLabel: string | undefined;
+    readonly redoLabel: string | undefined;
+    readonly size: number;
+    /**
+     * @param {boolean} canUndo - a step can be undone
+     * @param {boolean} canRedo - a step can be redone
+     * @param {string | undefined} undoLabel - the label of the step undo takes (`"Edit"`, `"Paste"` …)
+     * @param {string | undefined} redoLabel - the label of the step redo takes
+     * @param {number} size - steps on the undo stack
+     */
+    constructor(canUndo: boolean, canRedo: boolean, undoLabel: string | undefined, redoLabel: string | undefined, size: number);
+}

package/lib/table/data/options/table-options.d.ts

@@ -16,8 +16,26 @@ import { AriaTextsIf } from '../../aria/aria-texts.if.js';
 import { OverlayOptionsIf } from './overlay-options.if.js';
 import { RowDragOptionsIf } from '../../row-drag/row-drag-options.if.js';
 import { FillHandleOptionsIf } from '../../fill/fill-handle-options.if.js';
+import { EditingOptionsIf } from '../../sheet-editing/editing-options.if.js';
+import { ClipboardOptionsIf } from '../../clipboard/clipboard-options.if.js';
+import { UndoOptionsIf } from '../../undo/undo-options.if.js';
+import { CellFormulaOptionsIf } from '../../sheet/cell-formula-options.if.js';
+import { SpreadsheetOptionsIf } from '../../spreadsheet/spreadsheet-options.if.js';
 import { BatchEditOptionsIf } from '../../batch-edit/batch-edit-options.if.js';
 
+/**
+ * The default editor of {@link TableOptions.getEditRenderer}: a text input in the cell ({@link InputCellRenderer}).
+ * With Excel-style editing ({@link TableOptionsIf.editing}) the table recognises this default and uses its own
+ * editor above the cell instead – an own `getEditRenderer` is kept.
+ *
+ * @example
+ * const tableOptions: TableOptionsIf = { ...new TableOptions() };
+ * tableOptions.getEditRenderer === DEFAULT_GET_EDIT_RENDERER;   // true
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export declare const DEFAULT_GET_EDIT_RENDERER: GetEditRenderer;
 /**
  * All default options of a table – see {@link TableOptionsIf} for the meaning of each field.
  *
@@ -89,6 +107,16 @@ export declare class TableOptions implements TableOptionsIf {
     fillHandle?: boolean | Partial<FillHandleOptionsIf>;
     masterDetail?: Partial<MasterDetailOptionsIf>;
     batchEdit?: boolean | Partial<BatchEditOptionsIf>;
+    /** Excel-style editing ({@link TableOptionsIf.editing}). Not set = off. @since 1.1.99 */
+    editing?: boolean | Partial<EditingOptionsIf>;
+    /** Copy, cut and paste ({@link TableOptionsIf.clipboard}). Not set = off. @since 1.1.99 */
+    clipboard?: boolean | Partial<ClipboardOptionsIf>;
+    /** Undo and redo ({@link TableOptionsIf.undo}). Not set = off. @since 1.1.99 */
+    undo?: boolean | Partial<UndoOptionsIf>;
+    /** Cell formulas ({@link TableOptionsIf.cellFormulas}). Not set = off. @since 1.1.99 */
+    cellFormulas?: boolean | Partial<CellFormulaOptionsIf>;
+    /** Preset like a spreadsheet ({@link TableOptionsIf.spreadsheet}). Not set = off. @since 1.1.99 */
+    spreadsheet?: boolean | Partial<SpreadsheetOptionsIf>;
     /**
      * Writing direction (`"ltr"` | `"rtl"` | `"auto"`). Not set = `"ltr"`; a nested table (master/detail) without its
      * own value takes the direction of the outer table. @since 1.1.98

package/lib/table/data/options/table-options.if.d.ts

@@ -1,6 +1,11 @@
 import { MasterDetailOptionsIf } from '../../master-detail/master-detail-options.if.js';
 import { RowDragOptionsIf } from '../../row-drag/row-drag-options.if.js';
 import { FillHandleOptionsIf } from '../../fill/fill-handle-options.if.js';
+import { ClipboardOptionsIf } from '../../clipboard/clipboard-options.if.js';
+import { UndoOptionsIf } from '../../undo/undo-options.if.js';
+import { CellFormulaOptionsIf } from '../../sheet/cell-formula-options.if.js';
+import { SpreadsheetOptionsIf } from '../../spreadsheet/spreadsheet-options.if.js';
+import { EditingOptionsIf } from '../../sheet-editing/editing-options.if.js';
 import { BatchEditOptionsIf } from '../../batch-edit/batch-edit-options.if.js';
 import { DefaultRowHeightsIf } from './default-row-heights.if.js';
 import { TreeOptionsIf } from './tree-options.if.js';
@@ -267,7 +272,7 @@ export interface TableOptionsIf {
      * const tableOptions: TableOptionsIf = { ...new TableOptions(), ariaLabel: "Orders" };
      *
      * @since 1.1.91
-     * @see Training: [Accessible tables: keyboard and screen readers](https://gui.expert/training/accessibility/)
+     * @see [Live demo: accessible order table](https://gui.expert/showcase/accessibility/run/) · Training: [Accessible tables: keyboard and screen readers](https://gui.expert/training/accessibility/)
      */
     ariaLabel?: string;
     /**
@@ -320,6 +325,7 @@ export interface TableOptionsIf {
      * };
      *
      * @since 1.1.92
+     * @see [Live demo: loading & empty states](https://gui.expert/showcase/overlays/run/) · Training: [Loading and empty tables](https://gui.expert/training/live-data/#overlays)
      */
     overlayOptions?: Partial<OverlayOptionsIf>;
     /**
@@ -333,6 +339,7 @@ export interface TableOptionsIf {
      * };
      *
      * @since 1.1.95
+     * @see [Live demo: row drag](https://gui.expert/showcase/rowdrag/run/) · Training: [Dragging rows into order](https://gui.expert/training/events-and-context-menu/#row-drag)
      */
     rowDragOptions?: Partial<RowDragOptionsIf>;
     /**
@@ -350,8 +357,95 @@ export interface TableOptionsIf {
      * };
      *
      * @since 1.1.96
+     * @see [Live demo: fill handle & batch edit](https://gui.expert/showcase/batchedit/run/) · Training: [Fill handle and batch edit](https://gui.expert/training/inline-editing/#fill-batch)
      */
     fillHandle?: boolean | Partial<FillHandleOptionsIf>;
+    /**
+     * Excel-style editing: typing on a focused cell opens the editor (the text is replaced), Enter edits, Enter/Tab
+     * commit and move on, Shift+arrows extend the selection, Ctrl/⌘+arrows jump to the edge of the data, Delete
+     * clears the selected cells, Ctrl/⌘+Enter writes into all selected cells. The editor lives above the cell and
+     * survives scrolling. `true` = defaults ({@link EditingOptions}); without the option the table behaves as before
+     * (F2/double click edit, Enter activates, Tab leaves the table).
+     *
+     * @example
+     * const selectionModel = new SelectionModel("range", "multi");
+     * const tableOptions: TableOptionsIf = {
+     *   ...new TableOptions(),
+     *   getSelectionModel: () => selectionModel,
+     *   editing: { defaultEditable: true },   // every data column can be edited
+     * };
+     *
+     * @since 1.1.99
+     */
+    editing?: boolean | Partial<EditingOptionsIf>;
+    /**
+     * Copy, cut and paste like Excel and Google Sheets: Ctrl/⌘+C puts tab-separated text (with Excel's quoting) and an
+     * HTML table into the clipboard, Ctrl/⌘+X marks the range (dashed frame) and moves it on paste, Ctrl/⌘+V pastes
+     * from the anchor – tiled over a selected range, cut off at the last column, skipping read-only cells; **one**
+     * `onModelChanged` with `source: "paste"` (or `"cut"`). `true` = defaults ({@link ClipboardOptions}); without the
+     * option Ctrl/⌘+C copies as before and Ctrl/⌘+X/V do nothing.
+     *
+     * @example
+     * const tableOptions: TableOptionsIf = {
+     *   ...new TableOptions(),
+     *   getSelectionModel: () => new SelectionModel("range", "multi"),
+     *   editing: true,
+     *   clipboard: true,
+     * };
+     *
+     * @since 1.1.99
+     */
+    clipboard?: boolean | Partial<ClipboardOptionsIf>;
+    /**
+     * Undo and redo: Ctrl/⌘+Z undoes the last change – an edit, a fill, a paste, a cut, Delete – as **one** step,
+     * Ctrl+Y or Ctrl/⌘+Shift+Z redoes it (source `"undo"`/`"redo"` in `onModelChanged`). Cells are found by their row
+     * object (sorting and filtering in between don't matter). `true` = defaults ({@link UndoOptions}); without the option
+     * Ctrl/⌘+Z does nothing (as before). In a batch edit the marked values are undone; commit and cancel empty the
+     * history.
+     *
+     * @example
+     * const tableOptions: TableOptionsIf = {
+     *   ...new TableOptions(),
+     *   editing: true,
+     *   clipboard: true,
+     *   undo: true,
+     * };
+     *
+     * @since 1.1.99
+     */
+    undo?: boolean | Partial<UndoOptionsIf>;
+    /**
+     * Cell formulas like in Excel: a text with a leading `=` in the data (`row.total = "=B2*C2"`) is calculated –
+     * references `A1`, `$B$3`, `B2:D10`, `A:A`, ≈ 70 functions, dependencies are recalculated after every write.
+     * Row 1 is the first row of `getAllRows()` (sorting and filtering keep the references), column A the first data
+     * column (row numbers and checkboxes don't count). The data keep the formula text; sorting, filters, totals, copy
+     * and the Excel export use the results. `'=…` is the text `=…`. `true` = every data column with the defaults of
+     * {@link CellFormulaOptions}; `{ columns: ["total"] }` = only these properties. Flat bodies only (objects or
+     * arrays; a tree, row grouping, pivot table or master/detail: a warning, no formulas). Not set: `"=1+1"` is text.
+     *
+     * @example
+     * const tableOptions: TableOptionsIf = {
+     *   ...new TableOptions(),
+     *   editing: { defaultEditable: true },
+     *   cellFormulas: true,
+     * };
+     *
+     * @since 1.1.99
+     */
+    cellFormulas?: boolean | Partial<CellFormulaOptionsIf>;
+    /**
+     * Preset „like a spreadsheet“ for existing models: switches on `editing` (with `defaultEditable`), `clipboard`,
+     * `undo`, `cellFormulas` and `fillHandle` – unless the options set them themselves – and a range selection.
+     * An object switches single parts off (`false`) or configures them ({@link SpreadsheetOptionsIf}). For a new, empty
+     * sheet use {@link SpreadsheetFactory}; column letters above existing headers: `TableFactory.createTableModel({ …,
+     * columnLetters: true })`.
+     *
+     * @example
+     * const tableOptions: TableOptionsIf = { ...new TableOptions(), spreadsheet: true };
+     *
+     * @since 1.1.99
+     */
+    spreadsheet?: boolean | Partial<SpreadsheetOptionsIf>;
     /**
      * Batch edit always on: edited and filled values are collected (marked `ge-table-cell-pending`) and written with
      * {@link TableApi.commitBatchEdit} or discarded with {@link TableApi.cancelBatchEdit}. Without it, start a batch
@@ -361,6 +455,7 @@ export interface TableOptionsIf {
      * const tableOptions: TableOptionsIf = { ...new TableOptions(), batchEdit: true };
      *
      * @since 1.1.96
+     * @see [Live demo: fill handle & batch edit](https://gui.expert/showcase/batchedit/run/) · Training: [Fill handle and batch edit](https://gui.expert/training/inline-editing/#fill-batch)
      */
     batchEdit?: boolean | Partial<BatchEditOptionsIf>;
     /**
@@ -378,6 +473,7 @@ export interface TableOptionsIf {
      * };
      *
      * @since 1.1.97
+     * @see [Live demo: master/detail](https://gui.expert/showcase/masterdetail/run/) · Training: [Master/detail](https://gui.expert/training/master-detail/)
      */
     masterDetail?: Partial<MasterDetailOptionsIf>;
     /**
@@ -394,6 +490,7 @@ export interface TableOptionsIf {
      * const tableOptions: TableOptionsIf = { ...new TableOptions(), direction: "rtl" };
      *
      * @since 1.1.98
+     * @see [Live demo: right-to-left](https://gui.expert/showcase/rtl/run/) · Training: [Right-to-left](https://gui.expert/training/theming-dark-mode/#rtl)
      */
     direction?: TableDirection;
     /**
@@ -406,6 +503,7 @@ export interface TableOptionsIf {
      * const tableOptions: TableOptionsIf = { ...new TableOptions(), initialState: saved ?? undefined };
      *
      * @since 1.1.92
+     * @see [Live demo: persisted layout](https://gui.expert/showcase/state/run/) · Training: [Remember the state](https://gui.expert/training/persist-state/)
      */
     initialState?: Partial<TableStateIf>;
     /**

package/lib/table/data/tablemodel/areamodel/abstract-area-model.d.ts

@@ -8,6 +8,7 @@ import { FilterFunction } from '../../common/filter-function.js';
 import { SortItem } from '../../common/sort-item.js';
 import { HasDefaultRowHeightIf } from './has-default-row-height-if.js';
 import { ColumnValues } from '../../../calc/column-values.js';
+import { SheetCellsIf } from '../../../sheet/sheet-cells.if.js';
 
 /** @category Area models */
 export declare abstract class AbstractAreaModel<T> implements AreaModelIf, HasDefaultRowHeightIf {
@@ -19,15 +20,17 @@ export declare abstract class AbstractAreaModel<T> implements AreaModelIf, HasDe
     private calcTextRenderer?;
     protected cellRenderers: (CellRendererIf | undefined)[];
     protected yPositions: number[];
+    /** Cell formulas of the table (since 1.1.99, set by the table for a flat body). @internal */
+    sheetCells?: SheetCellsIf;
     constructor(areaIdent: AreaIdent, columnDefs?: ColumnDefIf[], defaultRowHeight?: number);
     abstract getRowCount(): number;
     abstract getValueAt(rowIndex: number, columnIndex: number): any;
     getTextValueAt(rowIndex: number, columnIndex: number): string;
-    getTooltipAt(_rowIndex: number, _columnIndex: number): any;
+    getTooltipAt(rowIndex: number, columnIndex: number): any;
     abstract getRowHeight(rowIndex: number): number;
     getCellRenderer(_rowIndex: number, columnIndex: number): CellRendererIf | undefined;
     getColspanAt(_rowIndex: number, _columnIndex: number): number;
-    getCustomClassesAt(_rowIndex: number, _columnIndex: number): string[];
+    getCustomClassesAt(rowIndex: number, columnIndex: number): string[];
     getCustomStyleAt(_rowIndex: number, _columnIndex: number): {
         [key: string]: string;
     } | undefined;
@@ -44,6 +47,12 @@ export declare abstract class AbstractAreaModel<T> implements AreaModelIf, HasDe
     isFilterable(): boolean;
     doSort(_sortItems: SortItem[]): boolean;
     sort(_compareFn?: (a: any, b: any) => number): void;
+    /**
+     * Columns without an own `editable` are editable (Excel-style editing, `EditingOptionsIf.defaultEditable`; set by
+     * the table). Row number, checkbox and group columns stay read only.
+     * @since 1.1.99
+     */
+    defaultEditable: boolean;
     isEditable(_rowIndex: number, columnIndex: number): boolean;
     setValue(rowIndex: number, columnIndex: number, value: any): boolean;
     isSelectable(_rowIndex: number, _columnIndex: number): boolean;

package/lib/table/data/tablemodel/areamodel/area-model-array-of-arrays.d.ts

@@ -50,6 +50,20 @@ export declare class AreaModelArrayOfArrays<T> extends AbstractAreaModel<T[][]>
      */
     moveRows(rowIndices: number[], target: RowDropTargetIf): boolean;
     getValueAt(rowIndex: number, columnIndex: number): any;
+    /**
+     * The input of a cell – the formula text of a cell formula (`"=B2*C2"`), otherwise the value (since 1.1.99,
+     * {@link TableOptionsIf.cellFormulas}).
+     *
+     * @param {number} rowIndex - display index
+     * @param {number} columnIndex - column
+     * @returns {unknown} the input
+     *
+     * @example
+     * new AreaModelArrayOfArrays("body", [[2, "=A1*2"]], 30).getInputValueAt(0, 1);   // "=A1*2"
+     *
+     * @since 1.1.99
+     */
+    getInputValueAt(rowIndex: number, columnIndex: number): unknown;
     setValue(rowIndex: number, columnIndex: number, value: any): boolean;
     getRowByIndex(rowIndex: number): any;
     getRowHeight(_rowIndex: number): number;

package/lib/table/data/tablemodel/areamodel/area-model-object-array.d.ts

@@ -577,6 +577,20 @@ export declare class AreaModelObjectArray<T> extends AbstractAreaModel<T> implem
      * console.log(email); // 'john@example.com'
      */
     getValueByT(t: T, property: string): any;
+    /**
+     * The input of a cell – what was typed: the formula text of a cell formula (`"=B2*C2"`), otherwise the value
+     * (since 1.1.99, {@link TableOptionsIf.cellFormulas}).
+     *
+     * @param {number} rowIndex - display index
+     * @param {number} columnIndex - model column
+     * @returns {unknown} the input
+     *
+     * @example
+     * bodyAreaModel.getInputValueAt(0, 3);   // "=B2*C2" (getValueAt: 2598)
+     *
+     * @since 1.1.99
+     */
+    getInputValueAt(rowIndex: number, columnIndex: number): unknown;
     /**
      * Changes the order of columns by moving a column from one position to another.
      * This method updates both the properties array and calls the parent class implementation.

package/lib/table/data/tablemodel/areamodel/area-model.if.d.ts

@@ -364,6 +364,17 @@ export interface AreaModelIf {
      * @since 1.1.95
      */
     isCalculatedProperty?(property: string): boolean;
+    /**
+     * Optional: the input of a cell – what was typed, e.g. the formula text of a cell formula (`"=B2*C2"`), while
+     * {@link getValueAt} gives its result ({@link TableOptionsIf.cellFormulas}). Editor, copy inside the table and undo
+     * use it. Without it the input is the value. Implemented by the object-array and array models.
+     *
+     * @example
+     * tableModel.getBodyModel().getInputValueAt?.(0, 3);   // "=B2*C2"
+     *
+     * @since 1.1.99
+     */
+    getInputValueAt?(rowIndex: number, columnIndex: number): unknown;
     /**
      * Optional: the value of a column for a row object – computed for a calculated column, otherwise the property
      * path ({@link TableApi.getRowValue}). Implemented by the object-array, tree, row-group and pivot models.

package/lib/table/data/tablemodel/column/column-def.d.ts

@@ -7,6 +7,7 @@ import { BooleanFunction } from '../../common/boolean-function.js';
 import { SortState } from '../../common/sort-state.type.js';
 import { GetEditRenderer } from '../../../renderer/edit/edit-cell-renderer.type.js';
 import { editInputPipe } from '../../../renderer/edit/edit-input-pipe.if.js';
+import { ColumnEditorOption } from '../../../sheet-editing/cell-editor.if.js';
 import { ValueGetter, ValueSetter } from '../../../calc/value-getter.type.js';
 import { ShowValuesAsConfig } from '../../../calc/show-values-as.type.js';
 import { FormulaOptionsIf } from '../../../formula/formula-options.if.js';
@@ -66,6 +67,12 @@ export declare class ColumnDef implements ColumnDefIf {
     rowDrag?: RowDragColumnOption;
     /** Checks edited values, see {@link ColumnDefIf.validate} (since 1.1.96). */
     validate?: CellValidator;
+    /** The editor of Excel-style editing, see {@link ColumnDefIf.editor} (since 1.1.99). */
+    editor?: ColumnEditorOption;
+    /** The value of a cleared cell, see {@link ColumnDefIf.emptyValue} (since 1.1.99). */
+    emptyValue?: unknown;
+    /** `false`: no cell formulas in this column, see {@link ColumnDefIf.cellFormulas} (since 1.1.99). */
+    cellFormulas?: boolean;
     constructor(property: string, headerLabel: string, width?: SizeIf, classes?: AreaObjectMapType<string[]>, rendererMap?: AreaObjectMapType<CellRendererIf>, minWidth?: SizeIf, maxWidth?: SizeIf, sortable?: BooleanFunction | undefined, sortComparator?: ValueRowSortComparator | undefined, sortState?: SortState | undefined, sortStatesOrder?: SortState[] | undefined, sortIconVisible?: BooleanFunction | undefined, editable?: BooleanFunction | undefined, getEditRenderer?: GetEditRenderer | undefined, editInputPipe?: editInputPipe | undefined, isVisible?: BooleanFunction);
     static bodyRenderer(bodyRenderer: CellRendererIf): AreaObjectMap<CellRendererIf>;
     /**
@@ -139,5 +146,11 @@ export declare class ColumnDef implements ColumnDefIf {
         rowDrag?: RowDragColumnOption;
         /** Checks edited values: a message for an invalid value (since 1.1.96). */
         validate?: CellValidator;
+        /** The editor of Excel-style editing: `"text"`, `"number"`, `"date"` or a factory (since 1.1.99). */
+        editor?: ColumnEditorOption;
+        /** The value of a cleared cell (Delete) – default `EditingOptionsIf.emptyValue` (since 1.1.99). */
+        emptyValue?: unknown;
+        /** `false`: `"=…"` stays text in this column of a table with cell formulas (since 1.1.99). */
+        cellFormulas?: boolean;
     }): ColumnDefIf;
 }