@guiexpert/table 1.1.97 → 1.1.99

package/lib/table/sheet/table-sheet.d.ts

@@ -0,0 +1,214 @@
+import { TableModelIf } from '../data/tablemodel/table-model.if.js';
+import { CellChangeIf } from '../batch-edit/cell-change.if.js';
+import { SheetCellsIf } from './sheet-cells.if.js';
+import { CellFormulaOptionsIf } from './cell-formula-options.if.js';
+import { SheetEngine } from './sheet-engine.js';
+
+/**
+ * A formula copied inside the table (copy and paste): the input and where it came from – pasted, its relative
+ * references move by the distance (Excel). `value` is pasted where formulas are not allowed.
+ *
+ * @internal
+ */
+export declare class CopiedFormula {
+    readonly input: string;
+    readonly row: number;
+    readonly col: number;
+    readonly value: unknown;
+    constructor(input: string, row: number, col: number, value: unknown);
+}
+/**
+ * The cell formulas of a table ({@link TableOptionsIf.cellFormulas}): connects the body model with a
+ * {@link SheetEngine}. Rows are the physical rows (`getAllRows()` / the array), columns the data columns (row number
+ * and checkbox columns don't count). The body asks it for the value of every text input (`SheetCellsIf`); the table
+ * reports every write (`cellsWritten`). A new rows array (`setRows`), another row count or other columns rebuild
+ * the engine.
+ *
+ * @category Internals
+ * @since 1.1.99
+ */
+export declare class TableSheet implements SheetCellsIf {
+    private readonly tableModel;
+    private readonly body;
+    readonly options: CellFormulaOptionsIf;
+    readonly engine: SheetEngine;
+    private dataColumns;
+    private engineColumns;
+    private properties;
+    private propertyColumns;
+    private formulaColumns;
+    /** Engine columns of calculated columns (`valueGetter`): their inputs change with every write of the row. */
+    private calculatedColumns;
+    private rowIndex;
+    private rowsRef?;
+    private rowsLength;
+    /** A spreadsheet body (sparse, positional columns) – otherwise objects or arrays. */
+    private readonly sheetBody?;
+    private columnDefsRef?;
+    private columnCount;
+    private syncing;
+    private constructor();
+    /**
+     * The cell formulas of a table model – `undefined` (with a warning) for a body that is not flat.
+     *
+     * @param {TableModelIf} tableModel - the model
+     * @param {CellFormulaOptionsIf} options - complete options
+     * @returns {TableSheet | undefined} the sheet, attached to the body
+     */
+    static create(tableModel: TableModelIf, options: CellFormulaOptionsIf): TableSheet | undefined;
+    /** Detaches the sheet from the body (table destroyed). */
+    destroy(): void;
+    valueAt(row: unknown, columnIndex: number, input: string): unknown;
+    valueOfProperty(row: unknown, property: string, input: string): unknown;
+    isFormulaProperty(property: string): boolean;
+    isFormulaColumnIndex(columnIndex: number): boolean;
+    /**
+     * True if a written value is a formula: text with `=` in a formula column (it skips `editInputPipe` and `validate`).
+     *
+     * @param {number} columnIndex - model column
+     * @param {unknown} value - the written value
+     * @returns {boolean} true for a formula
+     */
+    isFormulaInput(columnIndex: number, value: unknown): value is string;
+    /**
+     * The message of a syntax error of a formula, `undefined` if it parses.
+     *
+     * @param {string} input - the formula text (with `=`)
+     * @returns {string | undefined} the message
+     */
+    syntaxError(input: string): string | undefined;
+    /**
+     * Cells were written (their inputs changed): the engine compiles their formulas again and recalculates the
+     * dependent cells – before the table repaints.
+     *
+     * @param {CellChangeIf[]} changes - the written cells (row object or display index, model column)
+     */
+    cellsWritten(changes: readonly CellChangeIf[]): void;
+    /**
+     * Recalculates everything (data changed outside the table) – {@link TableApi.recalculate}.
+     */
+    recalculate(): void;
+    /**
+     * The value of a cell by physical row and engine column (the rows are checked first).
+     *
+     * @param {number} row - physical row
+     * @param {number} col - engine column
+     * @returns {unknown} the value
+     */
+    cellValue(row: number, col: number): unknown;
+    /**
+     * Calculates a formula once against the sheet.
+     *
+     * @param {string} source - the formula
+     * @returns {unknown} the result
+     */
+    evaluate(source: string): unknown;
+    /**
+     * The input of a cell by physical row and engine column (also of a row a filter hides).
+     *
+     * @param {number} row - physical row
+     * @param {number} col - engine column
+     * @returns {unknown} the input
+     */
+    inputAt(row: number, col: number): unknown;
+    /**
+     * Writes an input directly into the data (no events, no recalculation) – formulas adjusted after inserting or
+     * deleting rows. `row` is a physical row or the row itself (object or array).
+     *
+     * @param {number | object} row - physical row or row
+     * @param {number} col - engine column
+     * @param {unknown} value - the input
+     */
+    writeInput(row: number | object, col: number, value: unknown): void;
+    /** @returns {unknown[] | undefined} the rows array of an object or array body (not of a sheet) */
+    rowsArray(): unknown[] | undefined;
+    /** @returns {number} the number of physical rows */
+    rowCount(): number;
+    /**
+     * The physical row of a display row (`undefined` if there is none).
+     *
+     * @param {number} displayRow - display index
+     * @returns {number | undefined} the row in `getAllRows()` / the array
+     */
+    physicalRow(displayRow: number): number | undefined;
+    /**
+     * The display row of a physical row, `-1` if a filter hides it.
+     *
+     * @param {number} physicalRow - the row in `getAllRows()` / the array
+     * @returns {number} the display index
+     */
+    displayRow(physicalRow: number): number;
+    /** @returns {number | undefined} the engine column (A = 0) of a model column */
+    engineColumn(columnIndex: number): number | undefined;
+    /** @returns {number} the model column of an engine column, `-1` if there is none */
+    modelColumn(engineColumn: number): number;
+    /**
+     * The address of a cell (`"B3"`), `undefined` for a row number or checkbox column.
+     *
+     * @param {number} displayRow - display index
+     * @param {number} columnIndex - model column
+     * @returns {string | undefined} the address
+     */
+    address(displayRow: number, columnIndex: number): string | undefined;
+    /**
+     * The cell of an address: display row (`-1` if a filter hides it) and model column; `undefined` if invalid.
+     *
+     * @param {string} address - `"B3"`, `"$B$3"`
+     * @returns {[number, number] | undefined} display row and model column
+     */
+    cellOfAddress(address: string): [number, number] | undefined;
+    /**
+     * A formula moved from one cell to another (fill handle, paste): relative references move by the physical distance.
+     *
+     * @param {string} input - the formula (with `=`)
+     * @param {number} fromRow - physical row of the source
+     * @param {number} fromCol - engine column of the source
+     * @param {number} toDisplayRow - display row of the target
+     * @param {number} toColumnIndex - model column of the target
+     * @returns {string | undefined} the moved formula, `undefined` if the target holds no formulas
+     */
+    moveFormula(input: string, fromRow: number, fromCol: number, toDisplayRow: number, toColumnIndex: number): string | undefined;
+    /**
+     * The copy of a cell inside the table: a {@link CopiedFormula} for a formula cell, otherwise `value`.
+     *
+     * @param {number} displayRow - display index
+     * @param {number} columnIndex - model column
+     * @param {unknown} input - the cell's input
+     * @param {unknown} value - the cell's value
+     * @returns {unknown} the copy
+     */
+    copyOf(displayRow: number, columnIndex: number, input: unknown, value: unknown): unknown;
+    /**
+     * The cells and ranges a formula reads, as addresses (`["B2", "C2", "D2:D4", "A:A"]`).
+     *
+     * @param {number} displayRow - display index
+     * @param {number} columnIndex - model column
+     * @returns {string[]} the addresses (empty for a value cell)
+     */
+    precedents(displayRow: number, columnIndex: number): string[];
+    /**
+     * The formula cells that read a cell directly (display row, model column; hidden rows left out).
+     *
+     * @param {number} displayRow - display index
+     * @param {number} columnIndex - model column
+     * @returns {Array<[number, number]>} the dependents
+     */
+    dependents(displayRow: number, columnIndex: number): Array<[number, number]>;
+    /**
+     * False for arrays (moving a column moves the data of every row – the references would point elsewhere); object
+     * rows: the column letter belongs to the property and moves with it.
+     *
+     * @returns {boolean} true if columns may be dragged
+     */
+    allowsColumnDrag(): boolean;
+    /** The engine column of a model column: arrays by position, objects by the property (dragged columns keep it). */
+    private columnOf;
+    private valueOf;
+    private physicalOfRow;
+    private rowCountOf;
+    private rows;
+    private readInput;
+    /** Rebuilds rows, columns and the engine if the rows array, its length or the columns changed. */
+    private sync;
+    private buildColumns;
+}

package/lib/table/sheet-editing/cell-editor-service.d.ts

@@ -0,0 +1,105 @@
+import { TableScope } from '../table-scope.js';
+import { EditingOptionsIf } from './editing-options.if.js';
+import { CellEditMode, EditMove } from './cell-editor.if.js';
+
+/**
+ * Excel-style editing ({@link TableOptionsIf.editing}): **one** editor element above the edited cell (not inside
+ * it – the cells are rebuilt on every render pass, the editor survives scrolling and repaints), typing to edit,
+ * Enter/Tab/arrow keys commit and move, Escape cancels, a click elsewhere commits. Created by {@link TableScope}
+ * only with the option (`tableScope.cellEditorService`).
+ *
+ * @category Internals
+ * @since 1.1.99
+ */
+export declare class CellEditorService {
+    private readonly tableScope;
+    readonly options: EditingOptionsIf;
+    private container?;
+    private editor?;
+    private session?;
+    /** Formula input of a formula column (pointing, colors, suggestions – since 1.1.99, `cellFormulas`). */
+    private assist?;
+    /** The column the last Tab sequence started in (Enter goes back to it, like Excel). */
+    private tabStartColumn;
+    private readonly editorId;
+    /** An invalid value refused a click: its mousedown/click/dblclick must not move the focus either. */
+    private blockClick;
+    constructor(tableScope: TableScope, options: EditingOptionsIf);
+    /** True while the editor is open. */
+    isOpen(): boolean;
+    /**
+     * The edited cell.
+     *
+     * @returns {[number, number] | undefined} display row and model column, `undefined` without editor
+     */
+    getCell(): [number, number] | undefined;
+    /**
+     * The id of the editor element (and of the formula popups) if `(rowIndex, columnIndex)` is the edited cell – the cell gets `aria-owns` with it
+     * (screen readers find the editor in the cell, not as a stray child of the grid).
+     *
+     * @param {number} rowIndex - display row index
+     * @param {number} columnIndex - model column index
+     * @returns {string | undefined} the id
+     */
+    getOwnedEditorId(rowIndex: number, columnIndex: number): string | undefined;
+    /**
+     * True if this service edits the column (otherwise the column's own `getEditRenderer` – or an own
+     * `tableOptions.getEditRenderer` of the app – edits inside the cell, as before 1.1.99).
+     *
+     * @param {number} columnIndex - model column index
+     * @returns {boolean} true for the editor above the cell
+     */
+    handlesColumn(columnIndex: number): boolean;
+    /**
+     * Opens the editor on a body cell.
+     *
+     * @param {number} rowIndex - display row index
+     * @param {number} columnIndex - model column index
+     * @param {{ mode?: CellEditMode, typedText?: string, textSelection?: "all" | "end" }} [opts] - "enter" with the typed
+     *        character, or "edit" (F2: caret at the end)
+     * @returns {boolean} true if the editor is open
+     */
+    start(rowIndex: number, columnIndex: number, opts?: {
+        mode?: CellEditMode;
+        typedText?: string;
+        textSelection?: "all" | "end";
+        imeStart?: boolean;
+    }): boolean;
+    /**
+     * Writes the editor's value (through `editInputPipe` and `validate`; batch edit: marks it) and moves on.
+     * An invalid value keeps the editor open (`aria-invalid`, the message is announced and the `title`).
+     *
+     * @param {EditMove} [move="none"] - where the active cell goes afterwards
+     * @param {{ fillSelection?: boolean, deferRepaint?: boolean }} [opts] - Ctrl/⌘+Enter: into all selected cells;
+     *        a mouse click: repaint after the click (a repaint between mousedown and click loses the click)
+     * @returns {boolean} true if the editor closed
+     */
+    commit(move?: EditMove, opts?: {
+        fillSelection?: boolean;
+        deferRepaint?: boolean;
+        tab?: boolean;
+    }): boolean;
+    /** Closes the editor without writing (Escape). */
+    cancel(): void;
+    /** Places the editor over its cell (called after every render pass) – also when the cell scrolled out of view. */
+    update(): void;
+    /** Removes the editor (table destroyed). */
+    destroy(): void;
+    private ensureContainer;
+    private createEditor;
+    /** The row moved (sorting, filter, inserted rows): the editor follows it; `false` if it is gone. */
+    private followRow;
+    /** The columns moved or changed (reordering, grouping, `setColumns`): the editor follows its column definition. */
+    private followColumn;
+    private close;
+    private fire;
+    private moveAfterCommit;
+    private onPointerDown;
+    private onBlockedMouse;
+    private onFocusOut;
+    private onKeyDown;
+    private isMac;
+    /** A key on the focused table (no editor open): printable keys open the editor ("enter" mode). */
+    private onTypeToEdit;
+    private onEditorKeyDown;
+}

package/lib/table/sheet-editing/cell-editor.if.d.ts

@@ -0,0 +1,110 @@
+import { ColumnDefIf } from '../data/tablemodel/column/column-def.if.js';
+import { DomServiceIf } from '../service/dom-service.if.js';
+
+/**
+ * How the cell editor was opened: `"enter"` by typing (arrow keys commit and move, like Excel's "Enter" mode) or
+ * `"edit"` by F2, Enter or a double click (arrow keys move the caret). F2 switches between the two.
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export type CellEditMode = "enter" | "edit";
+/**
+ * Where the focus goes after the editor committed: one cell down, up, right, left – or nowhere.
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export type EditMove = "down" | "up" | "right" | "left" | "none";
+/**
+ * What a {@link CellEditorIf} gets when it opens (Excel-style editing, {@link TableOptionsIf.editing}).
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export interface CellEditorContextIf {
+    /** Display row index of the edited body cell. */
+    readonly rowIndex: number;
+    /** Model column index. */
+    readonly columnIndex: number;
+    /** The row object (the data of a tree row), `undefined` for models without objects. */
+    readonly row: unknown;
+    /** The column definition, if the model has one. */
+    readonly columnDef?: ColumnDefIf;
+    /** The current value of the cell (a pending value in a batch edit). */
+    readonly value: unknown;
+    /** The value as editor text, e.g. `"42"` – the editor starts with it unless {@link typedText} is set. */
+    readonly input: string;
+    /** The character typed to open the editor ("enter" mode); it replaces the content. */
+    readonly typedText?: string;
+    /** "enter" (typed) or "edit" (F2, Enter, double click). */
+    readonly mode: CellEditMode;
+    /** "all": select the text, "end": caret at the end (F2 is always "end"). */
+    readonly textSelection: "all" | "end";
+    /** Writing direction of the table. */
+    readonly direction: "ltr" | "rtl";
+    /** Accessible name of the editor (the column label). */
+    readonly ariaLabel: string;
+    /** DOM access of the table. */
+    readonly domService: DomServiceIf;
+    /** The editor is done (e.g. a value was chosen in a list): commit and move. */
+    commit(move?: EditMove): void;
+    /** Close without writing. */
+    cancel(): void;
+    /** The text changed (the table reports it as `GeEditEvent` of the type `"input"`). */
+    inputChanged(): void;
+}
+/**
+ * A cell editor of Excel-style editing: lives in one element above the cell (it survives scrolling) until it is
+ * committed or cancelled. Built-in: {@link TextCellEditor}, {@link NumberCellEditor}, {@link SelectCellEditor},
+ * {@link DateCellEditor}. The table handles Enter, Tab, Escape and the arrow keys; an editor that needs a key
+ * itself (a list, a date field) says so in {@link wantsKey}.
+ *
+ * @example
+ * class UpperCaseEditor extends TextCellEditor {
+ *   override getValue(): unknown {
+ *     return String(super.getValue()).toUpperCase();
+ *   }
+ * }
+ * ColumnDef.create({ property: "code", editable: TrueFn, editor: ctx => new UpperCaseEditor() });
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export interface CellEditorIf {
+    /** Builds the editor into `container` (the table positions the container over the cell). */
+    open(container: HTMLDivElement, ctx: CellEditorContextIf): void;
+    /** The value to write (it runs through `editInputPipe` and `validate` of the column). */
+    getValue(): unknown;
+    /** Gives the input element the keyboard focus. */
+    focus(): void;
+    /** Removes listeners and elements. */
+    close(): void;
+    /** The element that has the focus (the table names it and lets the active cell own it for screen readers). */
+    getFocusElement(): HTMLElement | undefined;
+    /** F2 switched the mode. */
+    setMode?(mode: CellEditMode): void;
+    /** `true` while an IME composition is running – the table ignores Enter, Tab and arrows then. */
+    isComposing?(): boolean;
+    /** `true` if the editor needs this key itself (e.g. ↑/↓ in a list) – the table does not commit then. */
+    wantsKey?(evt: KeyboardEvent, mode: CellEditMode): boolean;
+    /** The text of the editor, e.g. `"=B2*C2"` (formula input, later stages). */
+    getText?(): string;
+    /** Replaces the text and puts the caret at the end. */
+    setText?(text: string): void;
+}
+/**
+ * Creates the editor of a column for one edit (see {@link ColumnDefIf.editor}).
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export type CellEditorFactory = (ctx: CellEditorContextIf) => CellEditorIf;
+/**
+ * The editor of a column in Excel-style editing: a factory or the name of a built-in editor. Without it the
+ * table chooses by the value: numbers → `"number"`, dates → `"date"`, otherwise `"text"`.
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export type ColumnEditorOption = CellEditorFactory | "text" | "number" | "date";

package/lib/table/sheet-editing/editing-keymap.d.ts

@@ -0,0 +1,17 @@
+import { ShortcutActionIdMapping } from '../action/shortcut-actionid-mapping.type.js';
+
+/**
+ * The keys of Excel-style editing ({@link TableOptionsIf.editing}) – a layer over the system mapping that the
+ * table only uses with the option; `tableOptions.shortcutActionIdMapping` still overrides it. Typing, F2, Enter,
+ * Escape and Ctrl/⌘+Enter are handled by the editor itself.
+ *
+ * @param {boolean} mac - macOS keys (⌘ instead of Ctrl for the data edge – ⌃+arrows belong to macOS Spaces)
+ * @returns {ShortcutActionIdMapping} the layer
+ *
+ * @example
+ * editingShortcutLayer(false)["ctrl+down"];   // "NAVIGATE_DATA_EDGE_DOWN"
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export declare function editingShortcutLayer(mac: boolean): ShortcutActionIdMapping;

package/lib/table/sheet-editing/editing-options.d.ts

@@ -0,0 +1,34 @@
+import { EditingOptionsIf } from './editing-options.if.js';
+
+/**
+ * The defaults of {@link EditingOptionsIf} (Excel-style editing, {@link TableOptionsIf.editing}).
+ *
+ * @example
+ * const options = EditingOptions.create(true);
+ * options?.enterKey;   // "edit"
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export declare class EditingOptions implements EditingOptionsIf {
+    startOnType: boolean;
+    enterKey: "edit" | "moveDown";
+    enterMoves: "down" | "right" | "none";
+    tabMoves: boolean;
+    arrowKeysCommit: boolean;
+    textSelection: "all" | "end";
+    clearKeys: boolean;
+    ctrlEnterFillsSelection: boolean;
+    collapseSelectionOnNavigate: boolean;
+    emptyValue: unknown;
+    defaultEditable: boolean;
+    maxClearCells: number;
+    /**
+     * The options of {@link TableOptionsIf.editing}: `undefined`/`false` = off, `true` = the defaults, an object = the
+     * defaults overridden by its values (`undefined` keeps the default).
+     *
+     * @param {boolean | Partial<EditingOptionsIf>} [option] - `tableOptions.editing`
+     * @returns {EditingOptionsIf | undefined} complete options, `undefined` if Excel-style editing is off
+     */
+    static create(option?: boolean | Partial<EditingOptionsIf>): EditingOptionsIf | undefined;
+}

package/lib/table/sheet-editing/editing-options.if.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Excel-style editing ({@link TableOptionsIf.editing}): what typing, Enter, Tab, the arrow keys and Delete do.
+ * `editing: true` uses the defaults of {@link EditingOptions}; an object overrides single values.
+ *
+ * @example
+ * const tableOptions: TableOptionsIf = {
+ *   ...new TableOptions(),
+ *   getSelectionModel: () => selectionModel,           // new SelectionModel("range", "multi")
+ *   editing: { enterKey: "moveDown", textSelection: "end" },   // Enter moves down like Excel
+ * };
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export interface EditingOptionsIf {
+    /** A printable key on a focused editable cell opens the editor with that character ("enter" mode). Default `true`. */
+    startOnType: boolean;
+    /**
+     * Enter on a cell without editor: `"edit"` opens the editor (Google Sheets, default), `"moveDown"` moves down
+     * (Excel). Checkbox, tree, group and detail cells keep their own Enter action.
+     */
+    enterKey: "edit" | "moveDown";
+    /** Where Enter in the editor goes after committing (Shift+Enter: the opposite). Default `"down"`. */
+    enterMoves: "down" | "right" | "none";
+    /**
+     * Tab/Shift+Tab commit and move to the next/previous shown column. In the last (first) column Tab is not used:
+     * the browser focus leaves the table (no keyboard trap). Default `true`.
+     */
+    tabMoves: boolean;
+    /** In "enter" mode (opened by typing) the arrow keys commit and move; in "edit" mode they move the caret. Default `true`. */
+    arrowKeysCommit: boolean;
+    /** Enter and double click select the text of the editor (`"all"`, default) or put the caret at the end; F2 always at the end. */
+    textSelection: "all" | "end";
+    /** Delete clears the selected cells, Backspace clears one cell and opens the editor. Default `true`. */
+    clearKeys: boolean;
+    /** Ctrl/⌘+Enter in the editor writes the input into all selected cells. Default `true`. */
+    ctrlEnterFillsSelection: boolean;
+    /** Arrow keys, Tab, Enter and clicks select the active cell (Excel); Shift+arrows extend from it. Default `true`. */
+    collapseSelectionOnNavigate: boolean;
+    /** The value of a cleared cell (a column can have its own: {@link ColumnDefIf.emptyValue}). Default `""`. */
+    emptyValue: unknown;
+    /**
+     * `true`: columns without an own `editable` are editable (row numbers, checkbox and group columns, calculated
+     * columns without `valueSetter` stay read only). Default `false`.
+     */
+    defaultEditable: boolean;
+    /** At most this many cells are cleared at once (Delete). Default 1 000 000. */
+    maxClearCells: number;
+}

package/lib/table/sheet-editing/editors/date-cell-editor.d.ts

@@ -0,0 +1,23 @@
+import { CellEditMode, CellEditorContextIf } from '../cell-editor.if.js';
+import { TextCellEditor } from './text-cell-editor.js';
+
+/**
+ * Editor for dates: `input type="date"`. A `Date` value comes back as `Date` (its time of day stays), an ISO text
+ * (`"2026-10-16"`, also with a time part) as ISO text; an empty field as `""`. The arrow keys belong to the date
+ * field.
+ *
+ * @example
+ * ColumnDef.create({ property: "due", editable: TrueFn, editor: "date" });
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export declare class DateCellEditor extends TextCellEditor {
+    private original;
+    private originalText;
+    protected inputType(): string;
+    protected toText(ctx: CellEditorContextIf): string;
+    open(container: HTMLDivElement, ctx: CellEditorContextIf): void;
+    getValue(): unknown;
+    wantsKey(evt: KeyboardEvent, _mode: CellEditMode): boolean;
+}

package/lib/table/sheet-editing/editors/number-cell-editor.d.ts

@@ -0,0 +1,18 @@
+import { CellEditorContextIf } from '../cell-editor.if.js';
+import { TextCellEditor } from './text-cell-editor.js';
+
+/**
+ * Editor for numbers: a text field with the numeric keyboard on touch devices (`inputmode="decimal"`), aligned to
+ * the end. Without an `editInputPipe` of the column a typed number is written as number (`"42"` → `42`), other text
+ * stays text.
+ *
+ * @example
+ * ColumnDef.create({ property: "price", editable: TrueFn, editor: "number" });
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export declare class NumberCellEditor extends TextCellEditor {
+    protected decorate(input: HTMLInputElement, ctx: CellEditorContextIf): void;
+    getValue(): unknown;
+}

package/lib/table/sheet-editing/editors/select-cell-editor.d.ts

@@ -0,0 +1,36 @@
+import { CellEditMode, CellEditorContextIf, CellEditorIf } from '../cell-editor.if.js';
+import { ValueLabelIf } from '../../data/common/value-label.if.js';
+
+/**
+ * Editor with a fixed list of values (`select`). ↑/↓ choose, Alt+↓ opens the list, typing jumps to the first
+ * matching entry (browser behaviour), Enter commits.
+ *
+ * @example
+ * ColumnDef.create({
+ *   property: "status", editable: TrueFn,
+ *   editor: () => SelectCellEditor.create(["open", "paid", "void"]),
+ * });
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export declare class SelectCellEditor implements CellEditorIf {
+    protected readonly options: ValueLabelIf[];
+    private select?;
+    private readonly abort;
+    constructor(options: ValueLabelIf[]);
+    /**
+     * An editor whose values are their own labels.
+     *
+     * @param {string[]} values - the entries
+     * @returns {SelectCellEditor} the editor
+     */
+    static create(values: string[]): SelectCellEditor;
+    open(container: HTMLDivElement, ctx: CellEditorContextIf): void;
+    getValue(): unknown;
+    getText(): string;
+    focus(): void;
+    getFocusElement(): HTMLElement | undefined;
+    wantsKey(evt: KeyboardEvent, _mode: CellEditMode): boolean;
+    close(): void;
+}

package/lib/table/sheet-editing/editors/text-cell-editor.d.ts

@@ -0,0 +1,35 @@
+import { CellEditMode, CellEditorContextIf, CellEditorIf } from '../cell-editor.if.js';
+
+/**
+ * The default editor of Excel-style editing: a text field (`input type="text"`). Built with DOM APIs only (no
+ * inline handlers, no `innerHTML`) – it works under a strict Content Security Policy.
+ *
+ * @example
+ * ColumnDef.create({ property: "name", editable: TrueFn, editor: () => new TextCellEditor() });
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export declare class TextCellEditor implements CellEditorIf {
+    protected input?: HTMLInputElement;
+    protected ctx?: CellEditorContextIf;
+    protected composing: boolean;
+    private readonly abort;
+    open(container: HTMLDivElement, ctx: CellEditorContextIf): void;
+    /** The `type` attribute of the input. */
+    protected inputType(): string;
+    /** Extra attributes and classes (subclasses). */
+    protected decorate(_input: HTMLInputElement, _ctx: CellEditorContextIf): void;
+    /** The start text from the cell value. */
+    protected toText(ctx: CellEditorContextIf): string;
+    getValue(): unknown;
+    getText(): string;
+    setText(text: string): void;
+    focus(): void;
+    private focusedOnce;
+    getFocusElement(): HTMLElement | undefined;
+    setMode(_mode: CellEditMode): void;
+    isComposing(): boolean;
+    wantsKey(_evt: KeyboardEvent, _mode: CellEditMode): boolean;
+    close(): void;
+}