@guiexpert/table 1.1.97 → 1.1.99

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;
 }

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/ele-scope.d.ts

@@ -7,6 +7,7 @@ import { AriaIds } from './aria/aria-ids.js';
 import { AreaIdent } from './data/tablemodel/area-ident.type.js';
 import { SideIdent } from './data/side-ident.type.js';
 import { TableOverlay } from './overlay/table-overlay.js';
+import { ResolvedTableDirection } from './rtl/table-direction.type.js';
 
 /**
  * Represents a store for HTML elements.
@@ -53,7 +54,43 @@ export declare class EleScope {
     readonly ariaIds: AriaIds;
     /** The overlay layer over the body ("Loading…", "No rows to show"). @since 1.1.92 */
     readonly tableOverlay: TableOverlay;
+    /**
+     * The resolved writing direction of the table ({@link TableOptionsIf.direction}; `"auto"` is decided when the table
+     * is built). @since 1.1.98
+     */
+    readonly direction: ResolvedTableDirection;
     constructor(hostElement: HTMLDivElement, tableModel: TableModelIf, dom: ConvenienceDomService, tableOptions: TableOptionsIf);
+    /**
+     * Whether the table runs from right to left ({@link TableOptionsIf.direction}).
+     *
+     * @returns {boolean} true for `"rtl"` (also a resolved `"auto"`)
+     * @since 1.1.98
+     */
+    isRtl(): boolean;
+    /**
+     * The horizontal scroll position of the body as distance from the **start** (≥ 0) – `scrollLeft`, in
+     * right-to-left `-scrollLeft`.
+     *
+     * @returns {number} px
+     * @since 1.1.98
+     */
+    getViewportScrollLeft(): number;
+    /**
+     * Sets the horizontal scroll position of the body as distance from the **start** (see {@link getViewportScrollLeft}).
+     *
+     * @param {number} x - px from the start
+     * @since 1.1.98
+     */
+    setViewportScrollLeft(x: number): void;
+    /**
+     * A client x coordinate (e.g. `PointerEvent.clientX`) as x in the host from the start of its padding box – the
+     * coordinates in which the table positions everything (right-to-left: from the right edge).
+     *
+     * @param {number} clientX - x in client (viewport) coordinates
+     * @returns {number} px from the start
+     * @since 1.1.98
+     */
+    clientXToHostX(clientX: number): number;
     /**
      * Shows the overlay that fits the current state (requested by the API, or "no rows" for an empty body).
      * Overwritten in {@link RenderScope}.

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/rtl/rtl-util.d.ts

@@ -0,0 +1,126 @@
+import { ResolvedTableDirection, TableDirection } from './table-direction.type.js';
+
+/**
+ * Decides the direction of a table: `"rtl"` and `"ltr"` as given, `"auto"` from the computed `direction` of the host
+ * (inherited from `<html dir="rtl">` or any parent) – for a host that is not in the document yet from the nearest
+ * `dir` attribute of the host or a parent. Missing (`undefined`) = `"ltr"`.
+ *
+ * Must be called before the table sets the `dir` attribute of the host.
+ *
+ * @param {TableDirection | undefined} direction - the option ({@link TableOptionsIf.direction})
+ * @param {HTMLElement} [host] - the host element of the table (needed for `"auto"`)
+ * @returns {ResolvedTableDirection} `"ltr"` or `"rtl"`
+ *
+ * @example
+ * resolveTableDirection("auto", document.getElementById("table")!); // "rtl" on a page with <html dir="rtl">
+ *
+ * @since 1.1.98
+ * @category Utilities
+ */
+export declare function resolveTableDirection(direction: TableDirection | undefined, host?: HTMLElement): ResolvedTableDirection;
+/**
+ * The horizontal scroll position of an element as distance from the **start** (≥ 0): in left-to-right `scrollLeft`,
+ * in right-to-left `-scrollLeft` (browsers report 0 at the right start and negative values when scrolled to the left,
+ * CSSOM View).
+ *
+ * @param {{ scrollLeft: number }} element - a scroll container
+ * @param {boolean} rtl - the container is right-to-left
+ * @returns {number} px from the start
+ *
+ * @example
+ * const fromStart = getLogicalScrollLeft(tableApi.getTableScope().scrollViewport, tableApi.getDirection() === "rtl");
+ *
+ * @since 1.1.98
+ * @category Utilities
+ */
+export declare function getLogicalScrollLeft(element: {
+    scrollLeft: number;
+}, rtl: boolean): number;
+/**
+ * Sets the horizontal scroll position of an element as distance from the **start** (see {@link getLogicalScrollLeft}).
+ *
+ * @param {{ scrollLeft: number }} element - a scroll container
+ * @param {number} x - px from the start
+ * @param {boolean} rtl - the container is right-to-left
+ *
+ * @example
+ * setLogicalScrollLeft(tableApi.getTableScope().scrollViewport, 0, true); // back to the (right) start
+ *
+ * @since 1.1.98
+ * @category Utilities
+ */
+export declare function setLogicalScrollLeft(element: {
+    scrollLeft: number;
+}, x: number, rtl: boolean): void;
+/**
+ * The horizontal scroll position for `element.scrollTo(…)` – physical, i.e. negative in right-to-left.
+ *
+ * @param {number} x - px from the start
+ * @param {boolean} rtl - right-to-left
+ * @returns {number} the value for `scrollLeft` / `scrollTo()`
+ *
+ * @example
+ * tableApi.getTableScope().scrollViewport.scrollTo(toPhysicalScrollLeft(200, true), 0); // 200 px from the right start
+ *
+ * @since 1.1.98
+ * @category Utilities
+ */
+export declare function toPhysicalScrollLeft(x: number, rtl: boolean): number;
+/**
+ * Whether a scroll container can still scroll horizontally by `dx` (physical: `dx > 0` = to the right) – for
+ * left-to-right and right-to-left containers alike.
+ *
+ * @param {{ scrollLeft: number, scrollWidth: number, clientWidth: number }} element - a scroll container
+ * @param {number} dx - physical delta (e.g. `WheelEvent.deltaX`)
+ * @param {boolean} rtl - the container is right-to-left
+ * @returns {boolean} true if a scroll by `dx` would move the content
+ *
+ * @example
+ * host.addEventListener("wheel", e => {
+ *   const takesIt = canScrollHorizontally(host, e.deltaX, getComputedStyle(host).direction === "rtl");
+ *   console.info(takesIt ? "the element scrolls itself" : "pass it on");
+ * });
+ *
+ * @since 1.1.98
+ * @category Utilities
+ */
+export declare function canScrollHorizontally(element: {
+    scrollLeft: number;
+    scrollWidth: number;
+    clientWidth: number;
+}, dx: number, rtl: boolean): boolean;
+/**
+ * A client x coordinate (e.g. `PointerEvent.clientX`) as position in a box measured from the box's **start**:
+ * left-to-right from its left edge, right-to-left from its right edge.
+ *
+ * @param {number} clientX - x in client (viewport) coordinates
+ * @param {number} boxLeft - the left edge of the box in client coordinates
+ * @param {number} boxWidth - the width of the box
+ * @param {boolean} rtl - right-to-left
+ * @returns {number} px from the start of the box
+ *
+ * @example
+ * host.addEventListener("pointerdown", e => {
+ *   const r = host.getBoundingClientRect();
+ *   console.info(toLogicalX(e.clientX, r.left + host.clientLeft, host.clientWidth, true)); // px from the right edge
+ * });
+ *
+ * @since 1.1.98
+ * @category Utilities
+ */
+export declare function toLogicalX(clientX: number, boxLeft: number, boxWidth: number, rtl: boolean): number;
+/**
+ * Swaps the arrow keys "left" and "right" in a harmonized shortcut (e.g. `"cmd left"` → `"cmd right"`) – the
+ * keyboard handling of a right-to-left table, so that → moves backwards in reading direction.
+ *
+ * @param {string} shortcut - a harmonized shortcut (`harmonizeShortcut`)
+ * @returns {string} the shortcut with swapped arrow keys
+ *
+ * @example
+ * mirrorArrowKeys("left");       // "right"
+ * mirrorArrowKeys("cmd right");  // "cmd left"
+ *
+ * @since 1.1.98
+ * @category Keyboard
+ */
+export declare function mirrorArrowKeys(shortcut: string): string;