@guiexpert/table 1.1.97 → 1.1.99

package/lib/table/rtl/table-direction.type.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The writing direction of a table ({@link TableOptionsIf.direction}):
+ *
+ * - `"ltr"` (default): left to right – the first column on the left.
+ * - `"rtl"`: right to left (Arabic, Hebrew, Persian, Urdu …) – the first column on the right, horizontal scrolling,
+ *   fixed columns, tree indent, resize handles and arrow keys mirrored.
+ * - `"auto"`: the direction of the page where the table is created (`dir="rtl"` on `<html>`, a parent element or the
+ *   host itself → `"rtl"`).
+ *
+ * @example
+ * const tableOptions: TableOptionsIf = { ...new TableOptions(), direction: "rtl" };
+ *
+ * @since 1.1.98
+ * @category Options
+ */
+export type TableDirection = "ltr" | "rtl" | "auto";
+/**
+ * A resolved writing direction – what {@link TableApi.getDirection} returns (`"auto"` is already decided).
+ *
+ * @since 1.1.98
+ * @category Options
+ */
+export type ResolvedTableDirection = "ltr" | "rtl";

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/convenience-dom.service.d.ts

@@ -10,6 +10,7 @@ import { SideIdent } from '../data/side-ident.type.js';
 import { SortState } from '../data/common/sort-state.type.js';
 import { SortedOptionsIf } from '../data/options/sorted-options.if.js';
 import { HtmlStyle } from './data/html-style.type.js';
+import { ResolvedTableDirection } from '../rtl/table-direction.type.js';
 
 /** @category DOM */
 export interface AddColumnDivPara {
@@ -37,7 +38,54 @@ export declare class ConvenienceDomService {
     readonly domService: DomServiceIf;
     /** Width of the focus frame of a cell in px (WCAG 2.4.7: visible focus, not only a color). @since 1.1.91 */
     static focusBorderWidthInPx: number;
+    /** Right-to-left: `left` is written as `right` and vice versa (see {@link setDirection}). */
+    private rtl;
+    /** The physical CSS property of the inline start (`left`, right-to-left `right`). */
+    private startKey;
+    /** The physical CSS property of the inline end (`right`, right-to-left `left`). */
+    private endKey;
     constructor(domService: DomServiceIf);
+    /**
+     * Sets the writing direction of the table. All positions of the table are computed from the **start** of a row
+     * (x = 0 is the first column); in right-to-left this service writes them as `right` instead of `left` – in
+     * {@link setStyle}, {@link applyStyle}, {@link applyStyleInPx} and all `add…` methods – so that the whole table is
+     * mirrored. Called once by the table before anything is positioned.
+     *
+     * @param {ResolvedTableDirection} direction - `"ltr"` or `"rtl"`
+     *
+     * @example
+     * const dom = new ConvenienceDomService(new SimpleDomService());
+     * dom.setDirection("rtl");
+     * const div = document.createElement("div");
+     * dom.setStyle(div, "left", "20px"); // div.style.right = "20px"
+     *
+     * @since 1.1.98
+     */
+    setDirection(direction: ResolvedTableDirection): void;
+    /**
+     * The writing direction set with {@link setDirection} (default `"ltr"`).
+     *
+     * @returns {ResolvedTableDirection} `"ltr"` or `"rtl"`
+     * @since 1.1.98
+     */
+    getDirection(): ResolvedTableDirection;
+    /**
+     * The physical CSS property for a logical position key: in right-to-left `left` ↔ `right`, everything else as is.
+     *
+     * @param {string} key - a CSS property
+     * @returns {string} the property to write
+     * @since 1.1.98
+     */
+    toPhysicalStyleKey(key: string): string;
+    /**
+     * The position of an element from the inline start in px, as written by this service (`style.left`, right-to-left
+     * `style.right`); 0 if it has none.
+     *
+     * @param {HTMLElement} ele - an element positioned by this service
+     * @returns {number} px
+     * @since 1.1.98
+     */
+    getInlineStart(ele: HTMLElement): number;
     setStyle(el: any, style: string, value: any): any;
     applyStyle(ele: HTMLDivElement, style: HtmlStyle): HTMLDivElement;
     applyDisplayNoneStyle(ele: HTMLDivElement): HTMLDivElement;
@@ -46,7 +94,7 @@ export declare class ConvenienceDomService {
     applyStylePosistionRelative(ele: HTMLDivElement): HTMLDivElement;
     applyStylePosistionAbsolute(ele: HTMLDivElement): HTMLDivElement;
     applyStyleFullSize(ele: HTMLDivElement): HTMLDivElement;
-    applyStyleOverflowAuto(overflowX: "scroll" | "auto" | undefined, overflowY: "scroll" | "auto" | undefined, ele: HTMLDivElement): HTMLDivElement;
+    applyStyleOverflowAuto(overflowX: "auto" | "scroll" | undefined, overflowY: "auto" | "scroll" | undefined, ele: HTMLDivElement): HTMLDivElement;
     applyStyleNoPadding(ele: HTMLDivElement): HTMLDivElement;
     appendRelativeChildDiv(parent: HTMLDivElement): DivScope;
     appendText(parent: HTMLDivElement, text: string): HTMLElement;

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

@@ -0,0 +1,23 @@
+/**
+ * Options of an Excel export ({@link ExcelService.downloadExcel}, {@link ExcelService.createExcelBlob}).
+ *
+ * @example
+ * // an Arabic sheet: column A on the right, like the table
+ * await new ExcelService().downloadExcel(matrix, "sales.xlsx", "", { rightToLeft: true });
+ *
+ * @since 1.1.98
+ * @category Export & clipboard
+ */
+export interface ExcelExportOptionsIf {
+    /**
+     * The worksheet runs from right to left (`<sheetView rightToLeft="1">`): column A on the right.
+     * {@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

@@ -1,3 +1,4 @@
+import { ExcelExportOptionsIf } from './excel-export-options.if.js';
 import { ExcelServiceIf } from './excel-service.if.js';
 
 /**
@@ -26,26 +27,35 @@ 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.
      *
      * @param {Array<Array<any>>} matrix - A 2D array representing the data to be included in the Excel file. Each inner array corresponds to a row in the sheet.
      * @param {string} [filename='file.xlsx'] - The name of the Excel file to be downloaded. Defaults to 'file.xlsx'.
      * @param {string} [author=''] - The author's name to include as metadata in the Excel file. Optional parameter.
+     * @param {ExcelExportOptionsIf} [options] - e.g. `{ rightToLeft: true }` for a sheet from right to left (since 1.1.98)
      * @return {void} Does not return a value.
      * @throws {Error} Throws an error if the input matrix is not a valid 2D array or if the filename is an empty string.
      */
-    downloadExcel(matrix: Array<Array<any>>, filename?: string, author?: string): Promise<void>;
+    downloadExcel(matrix: Array<Array<any>>, filename?: string, author?: string, options?: ExcelExportOptionsIf): Promise<void>;
     /**
      * Creates the .xlsx file as a Blob (compressed), e.g. to upload it instead of downloading it.
      *
      * @example
      * const blob = await new ExcelService().createExcelBlob([["Name", "City"], ["Ann", "Berlin"]]);
      * await fetch("/api/upload", { method: "POST", body: blob });
+     *
+     * @example
+     * // a sheet from right to left (column A on the right), since 1.1.98
+     * const rtlBlob = await new ExcelService().createExcelBlob([["المدينة"], ["الرياض"]], "", { rightToLeft: true });
      */
-    createExcelBlob(matrix: Array<Array<any>>, author?: string): Promise<Blob>;
+    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

@@ -1,3 +1,5 @@
+import { ExcelExportOptionsIf } from './excel-export-options.if.js';
+
 /**
  * Writes an Excel file from a matrix of values. The default implementation is {@link ExcelService};
  * pass your own as last argument of the `TableScope` constructor to change how {@link TableApi.downloadExcel} exports.
@@ -6,14 +8,49 @@
  */
 export interface ExcelServiceIf {
     /** Creates the file from `matrix` (rows of values) and hands it to the browser as download. */
-    downloadExcel(matrix: Array<Array<any>>, filename: string, author?: string): void | Promise<void>;
+    downloadExcel(matrix: Array<Array<any>>, filename: string, author?: string, options?: ExcelExportOptionsIf): void | Promise<void>;
     /**
      * True if the service understands cells of the form {@link ExcelFormattedValueIf} (`{ value, numberFormat }`).
      * Only then {@link TableApi.downloadExcel} exports percentages of „Show values as“ columns with the format `0.0%`;
      * 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`).

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

@@ -0,0 +1,100 @@
+/** Rows of a sheet (like Excel): 1 … 1 048 576. */
+export declare const SHEET_MAX_ROWS = 1048576;
+/** Columns of a sheet (like Excel): A … XFD = 16 384. */
+export declare const SHEET_MAX_COLUMNS = 16384;
+/**
+ * The letters of a column (0-based): 0 → `"A"`, 25 → `"Z"`, 26 → `"AA"`, 16 383 → `"XFD"`.
+ *
+ * @param {number} columnIndex - 0-based column
+ * @returns {string} the letters (`""` for an index outside 0 … 16 383)
+ *
+ * @example
+ * columnLetter(27);   // "AB"
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export declare function columnLetter(columnIndex: number): string;
+/**
+ * The 0-based column of letters: `"A"` → 0, `"ab"` → 27 (case does not matter).
+ *
+ * @param {string} letters - column letters
+ * @returns {number} the column, `-1` if invalid or beyond `XFD`
+ *
+ * @example
+ * columnIndexOfLetter("XFD");   // 16383
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export declare function columnIndexOfLetter(letters: string): number;
+/**
+ * A parsed cell address: 0-based row and column, `$` = absolute.
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export interface CellAddressIf {
+    row: number;
+    col: number;
+    absRow: boolean;
+    absCol: boolean;
+}
+/**
+ * The address of a cell: `toCellAddress(2, 1)` → `"B3"`, with `$` for absolute parts.
+ *
+ * @param {number} row - 0-based row
+ * @param {number} col - 0-based column
+ * @param {{ absRow?: boolean, absCol?: boolean }} [abs] - `$` before the row / column
+ * @returns {string} the address, `"#REF!"` outside the sheet
+ *
+ * @example
+ * toCellAddress(0, 5, { absRow: true, absCol: true });   // "$F$1"
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export declare function toCellAddress(row: number, col: number, abs?: {
+    absRow?: boolean;
+    absCol?: boolean;
+}): string;
+/**
+ * Parses a cell address like `"B3"`, `"$B$3"`, `"b$3"`.
+ *
+ * @param {string} address - the address
+ * @returns {CellAddressIf | undefined} row, column (0-based) and the absolute parts; `undefined` if invalid
+ *
+ * @example
+ * parseCellAddress("$B3");   // { row: 2, col: 1, absRow: false, absCol: true }
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export declare function parseCellAddress(address: string): CellAddressIf | undefined;
+/**
+ * A parsed range: first and last cell (0-based, inclusive). A whole column (`"A:A"`) has the rows 0 … 1 048 575 and
+ * `wholeColumns: true`, a whole row (`"3:3"`) the columns 0 … 16 383 and `wholeRows: true`.
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export interface RangeAddressIf {
+    from: CellAddressIf;
+    to: CellAddressIf;
+    wholeColumns?: boolean;
+    wholeRows?: boolean;
+}
+/**
+ * Parses a range like `"A1:B5"`, `"$A$1:B5"`, `"A:A"`, `"B:D"`, `"3:3"` or a single cell `"C7"`. The corners are
+ * sorted (`"B5:A1"` = `"A1:B5"`).
+ *
+ * @param {string} address - the range
+ * @returns {RangeAddressIf | undefined} the range; `undefined` if invalid
+ *
+ * @example
+ * parseRangeAddress("A:A")?.to.row;   // 1048575
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export declare function parseRangeAddress(address: string): RangeAddressIf | undefined;

package/lib/table/sheet/cell-formula-options.d.ts

@@ -0,0 +1,27 @@
+import { FormulaFunction } from '../formula/formula-options.if.js';
+import { CellFormulaOptionsIf } from './cell-formula-options.if.js';
+
+/**
+ * The defaults of {@link CellFormulaOptionsIf} (cell formulas).
+ *
+ * @example
+ * CellFormulaOptions.create(true)?.maxRangeCells;   // 10000000
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export declare class CellFormulaOptions implements CellFormulaOptionsIf {
+    functions: Record<string, FormulaFunction>;
+    isoDatesAsDates: boolean;
+    maxRangeCells: number;
+    rejectInvalidFormulas: boolean;
+    columns?: string[];
+    /**
+     * The options of {@link TableOptionsIf.cellFormulas}: `undefined`/`false` = off, `true` = the defaults, an object =
+     * the defaults overridden by its values (`undefined` keeps the default).
+     *
+     * @param {boolean | Partial<CellFormulaOptionsIf>} [option] - the option
+     * @returns {CellFormulaOptionsIf | undefined} complete options, `undefined` if off
+     */
+    static create(option?: boolean | Partial<CellFormulaOptionsIf>): CellFormulaOptionsIf | undefined;
+}

package/lib/table/sheet/cell-formula-options.if.d.ts

@@ -0,0 +1,27 @@
+import { FormulaFunction } from '../formula/formula-options.if.js';
+
+/**
+ * Cell formulas like in Excel ({@link TableOptionsIf.cellFormulas}, {@link SheetEngine}): `=B2*C2`, `=SUM(D2:D100)`.
+ * `cellFormulas: true` uses the defaults of {@link CellFormulaOptions}; an object overrides single values.
+ *
+ * @example
+ * const engine = SheetEngine.fromArrays(data, { functions: { VAT: (net) => Number(net) * 0.19 } });
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export interface CellFormulaOptionsIf {
+    /**
+     * Own functions by name (case-insensitive); they may replace built-in ones. A range argument (`A1:B5`) arrives as
+     * {@link FormulaRange}, a date as its serial number.
+     */
+    functions: Record<string, FormulaFunction>;
+    /** ISO text (`"2026-10-16"`) counts as date in arithmetic (`=A2+1`) and date functions. Default `true`. */
+    isoDatesAsDates: boolean;
+    /** Larger ranges are `#ERROR!` (`A1:XFD1048576`). Default `10_000_000`. */
+    maxRangeCells: number;
+    /** The table refuses formulas with a syntax error instead of storing them (`#ERROR!`). Default `false`. */
+    rejectInvalidFormulas: boolean;
+    /** Only these properties hold formulas (the other columns keep `=…` as text). Default: every data column. */
+    columns?: string[];
+}

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

@@ -0,0 +1,20 @@
+/** Where the data of the sheet lie in the file: rows above, columns in front, and their number. */
+export interface ExcelSheetPlacementIf {
+    dRow: number;
+    dCol: number;
+    rows: number;
+    cols: number;
+}
+/**
+ * The formula of a cell formula for an Excel file: all references moved by the offset of the sheet (header rows,
+ * leading columns – also absolute parts), whole columns/rows bounded to the data (the file holds headers and totals
+ * around them), newer functions with `_xlfn.`. `undefined` for a formula Excel cannot read: a syntax error or a field
+ * (`[price]`). Text without `=`.
+ *
+ * @param {string} input - the cell formula (with `=`)
+ * @param {ExcelSheetPlacementIf} at - where the data are in the file
+ * @returns {string | undefined} the Excel formula
+ *
+ * @internal
+ */
+export declare function toExcelFormula(input: string, at: ExcelSheetPlacementIf): string | undefined;

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

@@ -0,0 +1,19 @@
+import { FormulaNode, FormulaRefNode } from '../formula/formula-ast.if.js';
+
+/** A reference as text: `B3`, `$B$3`; whole columns/rows in ranges. */
+export declare function formatRef(ref: FormulaRefNode): string;
+/**
+ * The canonical text of a formula AST (without `=`): functions and references in capitals, `,` between arguments,
+ * texts with `""` for a quotation mark, parentheses only where needed. Used for moving formulas and the Excel export.
+ *
+ * @param {FormulaNode} ast - the syntax tree
+ * @returns {string} the formula text
+ *
+ * @example
+ * formatFormula({ kind: "binary", op: "*", left: { kind: "ref", row: 1, col: 1, absRow: false, absCol: false },
+ *   right: { kind: "literal", value: 2 } });   // "B2*2"
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export declare function formatFormula(ast: FormulaNode): string;

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

@@ -0,0 +1,17 @@
+/**
+ * The link between the body model and the cell formulas of a table ({@link TableOptionsIf.cellFormulas}): the model
+ * asks it for the value of every text input – an `=…` cell of a formula column gives its result. Set by the table.
+ *
+ * @category Internals
+ * @since 1.1.99
+ */
+export interface SheetCellsIf {
+    /** The value of a cell of an array row (`AreaModelArrayOfArrays`): the result for a formula, otherwise `input`. */
+    valueAt(row: unknown, columnIndex: number, input: string): unknown;
+    /** The value of a property of a row object: the result for a formula, otherwise `input`. */
+    valueOfProperty(row: unknown, property: string, input: string): unknown;
+    /** True if the column of this property may hold formulas. */
+    isFormulaProperty(property: string): boolean;
+    /** True if the column may hold formulas. */
+    isFormulaColumnIndex(columnIndex: number): boolean;
+}

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

@@ -0,0 +1,47 @@
+import { FormulaFunction } from '../formula/formula-options.if.js';
+import { FormulaError } from '../formula/formula-error.js';
+import { SheetFnContext } from './sheet-functions.js';
+import { SheetValue } from './sheet-values.js';
+
+/** A range a formula reads (0-based, inclusive, already cut to the sheet). */
+export interface RangeRef {
+    r1: number;
+    c1: number;
+    r2: number;
+    c2: number;
+}
+/** What the compiled formula of a cell needs from the engine. */
+export interface SheetCompileEnv {
+    /** The value of a cell (formula result or data). */
+    read(row: number, col: number): SheetValue;
+    /** Rows of the data (ranges are cut there). */
+    rowCount(): number;
+    /** The column of a data field (`[price]`), -1 if it is none. */
+    fieldColumn(name: string): number;
+    /** Own functions (upper case names). */
+    functions: Map<string, FormulaFunction>;
+    /** Largest range (cells) – larger ones are #ERROR!. */
+    maxRangeCells: number;
+    fn: SheetFnContext;
+}
+/** A compiled cell formula: evaluation and the cells it reads. */
+export interface CompiledCellFormula {
+    evaluate(): SheetValue;
+    /** Single cells read (`row * 16384 + col`). */
+    readonly singles: number[];
+    readonly ranges: RangeRef[];
+    readonly volatile: boolean;
+    /** Syntax error or unknown function – the evaluation returns it. */
+    readonly error?: FormulaError;
+}
+/** The key of a cell in maps. */
+export declare function cellKey(row: number, col: number): number;
+/**
+ * Compiles the formula of a cell (`=B2*C2`) into closures over the engine – no `eval`, no `new Function`.
+ *
+ * @param {string} source - the formula with `=`
+ * @param {number} row - the row of the cell (for `[field]`)
+ * @param {SheetCompileEnv} env - the engine
+ * @returns {CompiledCellFormula} the compiled formula
+ */
+export declare function compileCellFormula(source: string, row: number, env: SheetCompileEnv): CompiledCellFormula;