@guiexpert/table 1.1.98 → 1.1.99

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

@@ -5,6 +5,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';
 
@@ -131,7 +132,7 @@ export interface ColumnDefIf {
      * ColumnDef.create({ property: "total", headerLabel: "Total", sortable: TrueFn,
      *                    valueGetter: (o: Item) => o.price * o.quantity })
      *
-     * @see Training: [Columns with ColumnDef](https://gui.expert/training/column-definitions/)
+     * @see [Live demo: formulas & calculated columns](https://gui.expert/showcase/formulas/run/) · Training: [Calculated columns, “Show values as” and formulas](https://gui.expert/training/formulas/)
      * @since 1.1.95
      */
     valueGetter?: ValueGetter;
@@ -151,6 +152,7 @@ export interface ColumnDefIf {
      * @example
      * ColumnDef.create({ property: "total", headerLabel: "Share", showValuesAs: "percentOfColumnTotal" })
      *
+     * @see Training: [Show values as](https://gui.expert/training/formulas/#show-values-as)
      * @since 1.1.95
      */
     showValuesAs?: ShowValuesAsConfig;
@@ -158,6 +160,7 @@ export interface ColumnDefIf {
      * The formula of a formula column (`ColumnDef.create({ formula })` compiles it into the `valueGetter`), e.g.
      * `"[price] * [quantity] * 1.19"`. Informational – change it with {@link TableApi.setColumnFormula}.
      *
+     * @see [Live demo: formulas](https://gui.expert/showcase/formulas/run/) · Training: [Formulas your users can type](https://gui.expert/training/formulas/#formulas)
      * @since 1.1.95
      */
     formula?: string;
@@ -187,6 +190,38 @@ export interface ColumnDefIf {
      * @since 1.1.96
      */
     validate?: CellValidator;
+    /**
+     * The editor of this column in Excel-style editing ({@link TableOptionsIf.editing}): `"text"`, `"number"`,
+     * `"date"` or a factory for an own {@link CellEditorIf}. Without it the table chooses by the value (numbers →
+     * number editor, dates → date editor, otherwise text). A column with an own {@link getEditRenderer} keeps that
+     * editor (inside the cell, as before).
+     *
+     * @example
+     * ColumnDef.create({ property: "status", editable: TrueFn, editor: () => SelectCellEditor.create(["open", "paid"]) })
+     *
+     * @since 1.1.99
+     */
+    editor?: ColumnEditorOption;
+    /**
+     * The value a cleared cell gets (Delete/Backspace in Excel-style editing), e.g. `null` or `0`. Default:
+     * {@link EditingOptionsIf.emptyValue} (`""`).
+     *
+     * @example
+     * ColumnDef.create({ property: "quantity", editable: TrueFn, emptyValue: 0 })
+     *
+     * @since 1.1.99
+     */
+    emptyValue?: unknown;
+    /**
+     * `false`: this column never holds cell formulas ({@link TableOptionsIf.cellFormulas}) – `"=…"` stays text (free
+     * text, notes). Default: every data column of a table with `cellFormulas`.
+     *
+     * @example
+     * ColumnDef.create({ property: "note", editable: TrueFn, cellFormulas: false })
+     *
+     * @since 1.1.99
+     */
+    cellFormulas?: boolean;
 }
 /**
  * {@link ColumnDefIf.validate}: a message for an invalid value, `undefined` (or `null`, `""`) for a valid one.

package/lib/table/data/tablemodel/column/default-editable.d.ts

@@ -0,0 +1,18 @@
+import { ColumnDefIf } from './column-def.if.js';
+
+/**
+ * `editable` of a column that `ColumnDef.create()` got without `editable`: read only (Excel-style editing with
+ * `defaultEditable` may edit it). An own `editable` set later – also `FalseFn` – replaces it.
+ *
+ * @returns {boolean} false
+ * @internal
+ */
+export declare const DEFAULTED_EDITABLE: () => boolean;
+/**
+ * True if the column has no own `editable` (`undefined`, or the default of `ColumnDef.create`).
+ *
+ * @param {ColumnDefIf} def - the column
+ * @returns {boolean} true without own `editable`
+ * @internal
+ */
+export declare function hasDefaultEditable(def: ColumnDefIf): boolean;

package/lib/table/event-adapter.d.ts

@@ -1,3 +1,5 @@
+import { GeEditEvent } from './data/common/event/ge-edit-event.js';
+import { GeUndoEvent } from './data/common/event/ge-undo-event.js';
 import { GeDetailEvent } from './data/common/event/ge-detail-event.js';
 import { GeModelChangeEvent } from './data/common/event/ge-model-change-event.js';
 import { GeMouseEvent } from './data/common/event/ge-mouse-event.js';
@@ -43,4 +45,8 @@ export declare class EventAdapter implements EventListenerIf {
     onBatchEditChanged(_evt: GeBatchEditEvent): void;
     /** @since 1.1.97 */
     onDetailExpandedChanged(_evt: GeDetailEvent): void;
+    /** @since 1.1.99 */
+    onEditingChanged(_evt: GeEditEvent): void;
+    /** @since 1.1.99 */
+    onUndoStackChanged(_evt: GeUndoEvent): void;
 }

package/lib/table/event-listener-hub.d.ts

@@ -0,0 +1,10 @@
+import { EventListenerIf } from './event-listener.if.js';
+
+/**
+ * The event listener of a table: the listener given to the constructor plus the listeners of
+ * {@link TableApi.subscribe}. Without subscribers every call goes to the main listener exactly as before
+ * (`listener.onX` is the main listener's member, also `undefined`).
+ *
+ * Not exported: an internal of {@link TableScope}.
+ */
+export declare function createEventListenerHub(main: EventListenerIf, subscribers: Set<Partial<EventListenerIf>>): EventListenerIf;

package/lib/table/event-listener.if.d.ts

@@ -1,3 +1,5 @@
+import { GeEditEvent } from './data/common/event/ge-edit-event.js';
+import { GeUndoEvent } from './data/common/event/ge-undo-event.js';
 import { GeDetailEvent } from './data/common/event/ge-detail-event.js';
 import { GeMouseEvent } from './data/common/event/ge-mouse-event.js';
 import { GeModelChangeEvent } from './data/common/event/ge-model-change-event.js';
@@ -102,4 +104,18 @@ export interface EventListenerIf extends EventFocusChangedListenerIf, EventSelec
      * @since 1.1.97
      */
     onDetailExpandedChanged?(evt: GeDetailEvent): void;
+    /**
+     * The cell editor opened, its text changed (Excel-style editing), it committed or it was cancelled. Optional.
+     *
+     * @param {GeEditEvent} evt - type, cell, mode, editor text
+     * @since 1.1.99
+     */
+    onEditingChanged?(evt: GeEditEvent): void;
+    /**
+     * The undo history changed (undo and redo, {@link TableOptionsIf.undo}) – to enable and label own buttons. Optional.
+     *
+     * @param {GeUndoEvent} evt - can undo/redo, labels, size
+     * @since 1.1.99
+     */
+    onUndoStackChanged?(evt: GeUndoEvent): void;
 }

package/lib/table/factory/pivot-factory.d.ts

@@ -38,7 +38,7 @@ import { PivotTableModel } from '../pivot/pivot-table-model.js';
  * });
  * select.addEventListener("change", () => tableApi.setPivotConfig({ columnFields: [select.value] }));
  *
- * @see Training: [Pivot tables](https://gui.expert/training/pivot-tables/)
+ * @see [Live demo: pivot tables](https://gui.expert/showcase/pivot/run/) · Training: [Pivot tables](https://gui.expert/training/pivot-tables/)
  *
  * @since 1.1.94
  * @category Pivot

package/lib/table/factory/row-group-factory.d.ts

@@ -31,7 +31,7 @@ import { RowGroupTableModelParaIf } from './row-group-table-model-para.if.js';
  * });
  * select.addEventListener("change", () => tableApi.setRowGroupBy(select.value.split(",")));
  *
- * @see Training: [Row grouping](https://gui.expert/training/row-grouping/)
+ * @see [Live demo: row grouping](https://gui.expert/showcase/rowgrouping/run/) · Training: [Row grouping](https://gui.expert/training/row-grouping/)
  *
  * @since 1.1.94
  * @category Row grouping

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

@@ -54,6 +54,7 @@ export interface CreateTableModelPara {
      *   footerAggregates: { quantity: "sum", total: "sum" }       // footer: "100,000 rows" | … | 549,812 | 27,481,033.5
      * });
      *
+     * @see [Live demo: totals & aggregation](https://gui.expert/showcase/aggregation/run/) · Training: [Totals in one option](https://gui.expert/training/footer-totals/#built-in)
      * @since 1.1.94
      */
     footerAggregates: AggregateFooterConfig;
@@ -75,6 +76,7 @@ export interface CreateTableModelPara {
      * @example
      * const tableModel = TableFactory.createTableModel({ rows: orders, columnDefs, rowNumbersVisible: true });
      *
+     * @see [Live demo: row numbers](https://gui.expert/showcase/rownumbers/run/) · Training: [Row numbers](https://gui.expert/training/fixed-columns/#row-numbers)
      * @since 1.1.93
      */
     rowNumbersVisible: boolean | Partial<RowNumberOptionsIf>;
@@ -86,9 +88,21 @@ export interface CreateTableModelPara {
      * @example
      * const tableModel = TableFactory.createTableModel({ rows: orders, rowDrag: true });
      *
+     * @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)
      * @since 1.1.95
      */
     rowDrag: boolean;
+    /**
+     * Column letters `A, B, …` as an extra header row above the header labels (like a spreadsheet; for cell formulas,
+     * {@link TableOptionsIf.cellFormulas}). A click on a letter selects the column (selection type `"range"`).
+     * Row number and checkbox columns get no letter. Only with the default header (labels or `headerData`).
+     *
+     * @example
+     * const tableModel = TableFactory.createTableModel({ rows, columnDefs, rowNumbersVisible: { mode: "original" }, columnLetters: true });
+     *
+     * @since 1.1.99
+     */
+    columnLetters: boolean;
     /** Row heights of header, body and footer in px. Default: `tableOptions.defaultRowHeights`, otherwise 34 / 34 / 34. */
     defaultRowHeights: DefaultRowHeightsIf;
     /** The columns: property, header label, width, classes, renderers, sorting, editing. See {@link ColumnDef}. */

package/lib/table/formula/formula-ast.if.d.ts

@@ -2,6 +2,10 @@
  * A node of a compiled formula (abstract syntax tree). Read-only; the evaluator walks it – no code is generated
  * (no `eval`, no `new Function`).
  *
+ * Cell formulas (since 1.1.99, spreadsheet mode) add cell references (`ref`), ranges (`range`), error literals
+ * (`error`, e.g. `#REF!` after deleting rows) and the percent operator (`unary` with `"%"`); the formulas of
+ * calculated columns never contain them.
+ *
  * @example
  * const ast = compileFormula("[price] * 2").ast;
  * // { kind: "binary", op: "*", left: { kind: "field", name: "price" }, right: { kind: "literal", value: 2 } }
@@ -11,13 +15,13 @@
  */
 export type FormulaNode = {
     readonly kind: "literal";
-    readonly value: number | string | boolean;
+    readonly value: number | string | boolean | null;
 } | {
     readonly kind: "field";
     readonly name: string;
 } | {
     readonly kind: "unary";
-    readonly op: "-" | "+";
+    readonly op: "-" | "+" | "%";
     readonly operand: FormulaNode;
 } | {
     readonly kind: "binary";
@@ -28,7 +32,33 @@ export type FormulaNode = {
     readonly kind: "call";
     readonly name: string;
     readonly args: readonly FormulaNode[];
+} | FormulaRefNode | {
+    readonly kind: "range";
+    readonly from: FormulaRefNode;
+    readonly to: FormulaRefNode;
+} | {
+    readonly kind: "error";
+    readonly code: string;
+    readonly message?: string;
+    readonly text?: string;
 };
+/**
+ * A cell reference of a cell formula: row and column 0-based (`B3` = row 2, column 1), `$` = absolute. In a range a
+ * whole column (`A:A`) has `row: -1`, a whole row (`3:3`) has `col: -1`.
+ *
+ * @example
+ * const ref: FormulaRefNode = { kind: "ref", row: 2, col: 1, absRow: true, absCol: false };   // B$3
+ *
+ * @since 1.1.99
+ * @category Spreadsheet
+ */
+export interface FormulaRefNode {
+    readonly kind: "ref";
+    readonly row: number;
+    readonly col: number;
+    readonly absRow: boolean;
+    readonly absCol: boolean;
+}
 /**
  * The binary operators of a formula: arithmetic (`+ - * / ^`), text concatenation (`&`) and comparisons
  * (`=`/`==`, `<>`/`!=`, `<`, `<=`, `>`, `>=`; normalized to `=` and `<>`).

package/lib/table/formula/formula-error.d.ts

@@ -8,12 +8,14 @@
  * | `#VALUE!` | wrong type, e.g. `"abc" * 2` |
  * | `#DIV/0!` | division by zero |
  * | `#NUM!` | the result is not a finite number (`SQRT(-1)`, overflow) |
- * | `#CIRC!` | circular reference between calculated columns |
+ * | `#CIRC!` | circular reference between calculated columns (cell formulas: between cells) |
+ * | `#REF!` | cell formulas: a reference to a deleted or non-existing cell (since 1.1.99) |
+ * | `#N/A` | cell formulas: a lookup found nothing, `NA()` (since 1.1.99) |
  *
  * @since 1.1.95
  * @category Calculated columns & formulas
  */
-export type FormulaErrorCode = "#ERROR!" | "#NAME?" | "#VALUE!" | "#DIV/0!" | "#NUM!" | "#CIRC!";
+export type FormulaErrorCode = "#ERROR!" | "#NAME?" | "#VALUE!" | "#DIV/0!" | "#NUM!" | "#CIRC!" | "#REF!" | "#N/A";
 /**
  * An error value of a formula. Formulas never throw: a cell shows the {@link FormulaErrorCode} (`toString()`), the
  * table adds the CSS class `ge-table-cell-error` and shows the message as tooltip. Errors propagate through

package/lib/table/formula/parser.d.ts

@@ -6,5 +6,8 @@ export declare const MAX_FORMULA_LENGTH = 10000;
 export declare const MAX_FORMULA_DEPTH = 64;
 /** The maximum number of binary operators (a long chain is a deep tree, too). */
 export declare const MAX_FORMULA_OPERATORS = 1000;
-/** Parses a formula into an AST. Throws a {@link FormulaSyntaxError}. */
-export declare function parseFormula(source: string): FormulaNode;
+/**
+ * Parses a formula into an AST. Throws a {@link FormulaSyntaxError}. `references`: a cell formula with Excel's syntax
+ * (cell references, ranges, `%`, `;`, Excel's precedence of the negation) – since 1.1.99.
+ */
+export declare function parseFormula(source: string, references?: boolean): FormulaNode;

package/lib/table/formula/tokenizer.d.ts

@@ -1,7 +1,7 @@
 import { FormulaError } from './formula-error.js';
 
 /** The kinds of tokens of a formula. */
-export type FormulaTokenKind = "number" | "string" | "field" | "ident" | "op" | "(" | ")" | "," | "eof";
+export type FormulaTokenKind = "number" | "string" | "field" | "ident" | "op" | "(" | ")" | "," | "error" | "eof";
 /** One token: kind, text (number/string already decoded) and position in the source. */
 export interface FormulaToken {
     readonly kind: FormulaTokenKind;
@@ -18,5 +18,8 @@ export declare class FormulaSyntaxError extends Error {
 /**
  * Splits a formula into tokens. Whitespace is ignored. Throws a {@link FormulaSyntaxError} for an unknown character,
  * an unterminated string or field reference.
+ *
+ * `references` (cell formulas, since 1.1.99): Excel's rules – texts only in `"…"` with `""` as quotation mark, `$` in
+ * identifiers (`$B$3`), `:` and `%`, `;` as argument separator, error literals like `#REF!`.
  */
-export declare function tokenize(source: string): FormulaToken[];
+export declare function tokenize(source: string, references?: boolean): FormulaToken[];

package/lib/table/input-handler.d.ts

@@ -11,6 +11,14 @@ import { TableScope } from './table-scope.js';
 export declare class InputHandler {
     protected tableScope: TableScope;
     constructor(tableScope: TableScope);
+    /**
+     * A restored in-cell editor (its text was put back after a repaint, see {@link RenderScope.setEditorDraft}) fires
+     * no "change" for that text – it is committed when the focus leaves it (not when a repaint removes it).
+     */
+    private onHostElementFocusOut;
+    private commitInCellEditor;
+    /** Text typed into the in-cell editor: remembered, so that a repaint (scrolling, live data) keeps it (since 1.1.99). */
+    private onHostElementInput;
     /** Escape in the cell editor cancels the editing: the old value stays, nothing is committed. */
     private onHostElementKeyDown;
     /**

package/lib/table/master-detail/master-detail-service.d.ts

@@ -215,6 +215,15 @@ export declare class MasterDetailService {
     /** The mouse wheel over a detail row: scrolls the outer table if nothing in the detail row takes the movement. */
     private onWheel;
     private canScrollInside;
+    /**
+     * True if Tab on the master row `rowIndex` goes into its open detail row (a focusable element in it) – Excel-style
+     * editing then leaves Tab to this service.
+     *
+     * @param {number} rowIndex - display row index of the focused cell
+     * @returns {boolean} true with a tab target
+     * @since 1.1.99
+     */
+    hasTabTarget(rowIndex: number): boolean;
     /** Tab on a master row with an open detail row: the focus moves to the first focusable element in it. */
     private onHostKeyDown;
     /** The host got the focus back from a detail row (Shift+Tab): its master row gets the focus. */

package/lib/table/render-scope.d.ts

@@ -1,6 +1,7 @@
 import { RowDragService } from './row-drag/row-drag-service.js';
 import { BatchEditService } from './batch-edit/batch-edit-service.js';
 import { FillHandleService } from './fill/fill-handle-service.js';
+import { CellEditorService } from './sheet-editing/cell-editor-service.js';
 import { TableOverlayChange } from './overlay/table-overlay.js';
 import { EleScope } from './ele-scope.js';
 import { TableModelIf } from './data/tablemodel/table-model.if.js';
@@ -28,6 +29,7 @@ import { AriaGridInfo } from './aria/aria-grid-info.js';
 import { AriaTextsIf } from './aria/aria-texts.if.js';
 import { RowLayout } from './row-layout/row-layout.js';
 import { MasterDetailService } from './master-detail/master-detail-service.js';
+import { TableSheet } from './sheet/table-sheet.js';
 
 /** @category Internals */
 export declare class RenderScope extends EleScope {
@@ -105,12 +107,28 @@ export declare class RenderScope extends EleScope {
      * @since 1.1.96
      */
     fillHandleService?: FillHandleService;
+    /**
+     * Excel-style editing of this table (the editor above the cell) – created by {@link TableScope} with
+     * `tableOptions.editing`.
+     * @since 1.1.99
+     */
+    cellEditorService?: CellEditorService;
+    /**
+     * The text of the open in-cell editor (`getEditRenderer`): the cell is rebuilt on every repaint, the text and
+     * the caret are put back (before 1.1.99 the typed text was lost when the table scrolled or repainted).
+     */
+    private editorDraft?;
     /**
      * Master/detail of this table (detail rows below master rows) – created by {@link TableScope} with
      * `tableOptions.masterDetail`.
      * @since 1.1.97
      */
     masterDetailService?: MasterDetailService;
+    /**
+     * Cell formulas of this table – created by {@link TableScope} with `tableOptions.cellFormulas` (flat bodies).
+     * @since 1.1.99
+     */
+    tableSheet?: TableSheet;
     /** Positions of the body rows (prefix sums of the heights + detail rows), see {@link getBodyRowLayout}. */
     private readonly bodyRowLayout;
     private bodyRowLayoutDirty;
@@ -221,6 +239,23 @@ export declare class RenderScope extends EleScope {
      */
     getScrollerToContentRatioY(): number;
     isEditing(): boolean;
+    /**
+     * The cell of the open editor inside a cell (`getEditRenderer`, the way before Excel-style editing).
+     *
+     * @returns {[number, number] | undefined} display row and model column, `undefined` without such an editor
+     * @since 1.1.99
+     */
+    getInCellEditorCell(): [number, number] | undefined;
+    /**
+     * Remembers the text of the open in-cell editor (called on every input, see {@link InputHandler}) so that a
+     * repaint keeps it.
+     *
+     * @param {number} rowIndex - display row index of the edited cell
+     * @param {number} columnIndex - model column index
+     * @param {HTMLInputElement | HTMLTextAreaElement} input - the editor element
+     * @since 1.1.99
+     */
+    setEditorDraft(rowIndex: number, columnIndex: number, input: HTMLInputElement | HTMLTextAreaElement): void;
     /**
      * Resets the editor renderer by clearing its values and state.
      *
@@ -327,6 +362,11 @@ export declare class RenderScope extends EleScope {
      * @returns {void}
      */
     updateCells(events: TableCellUpdateEventIf[], repaintAll?: boolean): void;
+    /**
+     * Writes a value without the column's `editInputPipe` (values copied inside the table are already converted – a pipe
+     * that expects text could break them). All area models apply the pipe in `setValue`, so it is left out for the call.
+     */
+    protected setRawValue(rowIndex: number, columnIndex: number, value: unknown): boolean;
     /**
      * After `updateCells()` without a repaint: draws the rendered cells of calculated and „Show values as“ columns of
      * the body again (they depend on the changed cells, e.g. `total = price * quantity` or a share of the total).

package/lib/table/row-drag/row-drag-service.d.ts

@@ -42,9 +42,10 @@ export declare class RowDragService {
     isDragSourceRow(rowIndex: number): boolean;
     /**
      * Why a managed drag is not possible right now: `"sorted"` (a column has the sort state asc/desc), `"filtered"`
-     * (a filter hides rows) – `undefined` if it is possible or the drag is unmanaged.
+     * (a filter hides rows), `"cellFormulas"` (moved rows would change the references of cell formulas, since 1.1.99)
+     * – `undefined` if it is possible or the drag is unmanaged.
      */
-    getBlockReason(): "sorted" | "filtered" | undefined;
+    getBlockReason(): "sorted" | "filtered" | "cellFormulas" | undefined;
     /**
      * The drag handle of a body cell: none (no `rowDrag`, a group or pivot row, a managed drag the model cannot do),
      * enabled or disabled (managed + sorted/filtered).

package/lib/table/selection/selection-service.d.ts

@@ -20,6 +20,10 @@ export declare class SelectionService implements OnActionTriggeredIf {
     protected anchorRanges: CellRange[];
     /** The selection before a Ctrl/⌘-drag – each drag frame replaces only the dragged rectangle. */
     protected dragSnapshot?: SelectionSnapshot;
+    /** The cell a Shift+click or Shift+arrow range starts at (the last click, or the active cell). @since 1.1.99 */
+    protected anchor?: [number, number];
+    /** The moving corner of the range of Shift+arrows (Excel); `undefined` = the anchor. @since 1.1.99 */
+    protected extent?: [number, number];
     constructor(tableScope: TableScope);
     /**
      * Called on mouse down: a new gesture starts.
@@ -51,8 +55,52 @@ export declare class SelectionService implements OnActionTriggeredIf {
      */
     onMouseClicked(evt: GeMouseEvent, _previousEvt: GeMouseEvent | undefined): boolean;
     onActionTriggered(actionId: ActionId): boolean;
+    /**
+     * The cell a Shift+click or Shift+arrow range starts at: the last clicked cell or the active cell set by the
+     * keyboard ({@link collapseTo}).
+     *
+     * @returns {[number, number] | undefined} row and column, `undefined` before the first click/keyboard move
+     * @since 1.1.99
+     */
+    getAnchor(): [number, number] | undefined;
+    /**
+     * The moving corner of the range Shift+arrows grow (the anchor if there is none).
+     *
+     * @returns {[number, number] | undefined} row and column
+     * @since 1.1.99
+     */
+    getExtent(): [number, number] | undefined;
+    /**
+     * Excel-style editing: the active cell moved (arrow keys, Tab, Enter) – the selection becomes this one cell and it
+     * is the new anchor. Selection types other than `"range"`/`"cell"` only get the anchor.
+     *
+     * @param {number} rowIndex - display row index
+     * @param {number} columnIndex - model column index
+     * @since 1.1.99
+     */
+    collapseTo(rowIndex: number, columnIndex: number): void;
+    /**
+     * Excel-style editing (Shift+arrows): the last range is spanned from the anchor to `(rowIndex, columnIndex)`;
+     * other ranges (Ctrl/⌘-clicks) stay. Only for the selection type `"range"`.
+     *
+     * @param {number} rowIndex - the new moving corner (display row index)
+     * @param {number} columnIndex - model column index
+     * @returns {CellRange | undefined} the new range, `undefined` without a range selection
+     * @since 1.1.99
+     */
+    extendTo(rowIndex: number, columnIndex: number): CellRange | undefined;
+    private static rangeBetween;
     /** True if the column is a row number column ({@link RowNumberColumnDef}). */
     private isRowNumberColumn;
+    /** True for a cell of a header row with column letters (spreadsheet) – not over row numbers. */
+    private isColumnLetterCell;
+    /**
+     * A click on a column letter (selection type "range"): the whole column – Shift: the columns from the last letter
+     * (or the active cell), Ctrl/⌘: added. The active cell goes into the column.
+     */
+    private clickColumnLetter;
+    /** The column of the last click on a letter (Shift+click spans from it). */
+    private letterAnchor?;
     /** A click on the header cell of the row numbers: everything (selection types "row" and "range"). */
     private selectAllByRowNumberHeader;
     /** Selection type "range", click on a row number: the whole row – new, toggled (Ctrl/⌘) or removed (Ctrl/⌘+Alt). */

package/lib/table/service/excel-export-options.if.d.ts

@@ -14,4 +14,10 @@ export interface ExcelExportOptionsIf {
      * {@link TableApi.downloadExcel} sets it for a right-to-left table ({@link TableOptionsIf.direction}).
      */
     rightToLeft?: boolean;
+    /**
+     * {@link TableApi.downloadExcel}: cell formulas ({@link TableOptionsIf.cellFormulas}) become Excel formulas with their
+     * calculated values (otherwise: values). Only if the export is the sheet itself – no filter hides rows, no sorting,
+     * every data column visible; otherwise values and a warning. Since 1.1.99.
+     */
+    cellFormulas?: boolean;
 }

package/lib/table/service/excel-service.d.ts

@@ -27,6 +27,8 @@ import { ExcelServiceIf } from './excel-service.if.js';
 export declare class ExcelService implements ExcelServiceIf {
     /** Understands cells `{ value, numberFormat }` ({@link ExcelFormattedValueIf}), since 1.1.95. */
     readonly supportsNumberFormats = true;
+    /** Understands cells `{ formula, value }` ({@link ExcelFormulaCellIf}), since 1.1.99. */
+    readonly supportsFormulas = true;
     /**
      * Downloads a matrix data as an Excel file.
      *
@@ -52,6 +54,8 @@ export declare class ExcelService implements ExcelServiceIf {
     createExcelBlob(matrix: Array<Array<any>>, author?: string, options?: ExcelExportOptionsIf): Promise<Blob>;
     private generateMap;
     private getX1WorksheetsSheet1Xml;
+    /** A formula cell: `<f>` plus the cached value with its type (`str`, `b`, `e`; numbers and dates without). */
+    private formulaCellXml;
     /** Number format → cell style index (1-based; 0 = default), filled by withNumberFormats() before the sheet is written. */
     private numberFormatStyles;
     /** Adds one cell style per number format used in the matrix (`<numFmts>` + `<cellXfs>`); unchanged without formats. */

package/lib/table/service/excel-service.if.d.ts

@@ -15,7 +15,42 @@ export interface ExcelServiceIf {
      * otherwise a service gets plain numbers (since 1.1.95).
      */
     readonly supportsNumberFormats?: boolean;
+    /**
+     * True if the service understands cells of the form {@link ExcelFormulaCellIf} (`{ formula, value }`). Only then
+     * {@link TableApi.downloadExcel} with `{ cellFormulas: true }` exports cell formulas as formulas (since 1.1.99).
+     */
+    readonly supportsFormulas?: boolean;
+}
+/**
+ * A cell of an Excel matrix with a formula (`<f>`) and its calculated value (`<v>`, shown until Excel recalculates).
+ * Understood by {@link ExcelService}; {@link TableApi.downloadExcel} writes them for cell formulas with
+ * `{ cellFormulas: true }`.
+ *
+ * @example
+ * await new ExcelService().downloadExcel([[2, 3, { formula: "A1*B1", value: 6 }]], "sheet.xlsx");
+ *
+ * @since 1.1.99
+ * @category Export & clipboard
+ */
+export interface ExcelFormulaCellIf {
+    /** The formula without `=`, with Excel's function names (`"SUM(D2:D4)"`, `"_xlfn.XLOOKUP(…)"`). */
+    formula: string;
+    /** The calculated value: a number, text, boolean, `Date` or an error value. */
+    value: unknown;
 }
+/**
+ * True for a cell of the form {@link ExcelFormulaCellIf}.
+ *
+ * @param {unknown} cell - a cell of an Excel matrix
+ * @returns {boolean} whether it is a formula cell
+ *
+ * @example
+ * isExcelFormulaCell({ formula: "A1*2", value: 4 });   // true
+ *
+ * @since 1.1.99
+ * @category Export & clipboard
+ */
+export declare function isExcelFormulaCell(cell: unknown): cell is ExcelFormulaCellIf;
 /**
  * A cell of an Excel matrix with a number format, e.g. a share shown as percentage. Understood by
  * {@link ExcelService} (`supportsNumberFormats`).