@guiexpert/table 1.1.90 → 1.1.92

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

@@ -1,25 +1,66 @@
-import { GeMouseEvent } from './data/common/event/ge-mouse-event';
-import { GeModelChangeEvent } from './data/common/event/ge-model-change-event';
-import { GeScrollEvent } from './data/common/event/ge-scroll-event';
-import { SelectionModelIf } from './selection/selection-model.if';
-import { FocusModelIf } from './focus/focus-model.if';
-import { EventFocusChangedListenerIf } from './focus/event-focus-changed-listener.if';
-import { EventSelectionChangedListenerIf } from './selection/event-selection-changed-listener.if';
+import { GeMouseEvent } from './data/common/event/ge-mouse-event.js';
+import { GeModelChangeEvent } from './data/common/event/ge-model-change-event.js';
+import { GeScrollEvent } from './data/common/event/ge-scroll-event.js';
+import { GeStateChangeEvent } from './data/common/event/ge-state-change-event.js';
+import { SelectionModelIf } from './selection/selection-model.if.js';
+import { FocusModelIf } from './focus/focus-model.if.js';
+import { EventFocusChangedListenerIf } from './focus/event-focus-changed-listener.if.js';
+import { EventSelectionChangedListenerIf } from './selection/event-selection-changed-listener.if.js';
 
 /**
- * Interface representing an event listener.
+ * Receives the events of a table – the fifth argument of `new TableScope(…)`.
+ * Extend {@link EventAdapter} and override only the methods you need.
  *
- * @interface
+ * In the framework wrappers the same events arrive as callback props (`mouseClicked`, `selectionChanged` …),
+ * Vue events, Angular outputs or bubbling `CustomEvent`s of the Web Component.
+ *
+ * @example
+ * class OrderEvents extends EventAdapter {
+ *   override onMouseClicked(evt: GeMouseEvent): void {
+ *     if (evt.areaIdent === "body" && evt.clickCount === 2) {
+ *       const order = tableModel.getBodyModel().getRowByIndex(evt.rowIndex);   // displayed row → object
+ *       console.log("double-click on", order);
+ *     }
+ *   }
+ *   override onSelectionChanged(model: SelectionModelIf): void {
+ *     console.log(model.getRanges());
+ *   }
+ * }
+ * new TableScope(host, tableModel, new SimpleDomService(), new TableOptions(), new OrderEvents()).firstInit();
+ *
+ * @see Training: [Events and a context menu of your own](https://gui.expert/training/events-and-context-menu/)
+ *
+ * @category Events
  */
 export interface EventListenerIf extends EventFocusChangedListenerIf, EventSelectionChangedListenerIf {
+    /** Right-click on the table. Call `evt.originalEvent?.preventDefault()` to suppress the browser menu (e.g. for an own menu). */
     onContextmenu(evt: GeMouseEvent): void;
+    /** The mouse moved over the table (cell under the mouse in `evt`). Called often – keep it cheap. */
     onMouseMoved(evt: GeMouseEvent): void;
+    /** A drag with the mouse ended (column resize, column move or range selection). */
     onMouseDraggingEnd(evt: GeMouseEvent): void;
+    /** The mouse is being dragged; `evt.draggingX` / `evt.draggingY` hold the distance. */
     onMouseDragging(evt: GeMouseEvent): void;
+    /**
+     * A click on the table. A double-click on the same cell is reported again with `clickCount === 2`
+     * (after the first click with `clickCount === 1`).
+     */
     onMouseClicked(evt: GeMouseEvent): void;
+    /** Checked rows changed (row checkboxes, tree checkboxes) – the argument holds all checked rows. */
     onCheckboxChanged(evt: any[]): void;
+    /** Cells were edited – `evt.cells` holds row and column index of each; the new value is already in the model (your row object). */
     onModelChanged(evt: GeModelChangeEvent): void;
+    /** The table was scrolled. */
     onScroll(evt: GeScrollEvent): void;
+    /** The selection changed – read it from {@link SelectionModelIf.getRanges}. */
     onSelectionChanged(model: SelectionModelIf): void;
+    /** The focused cell changed – read it from {@link FocusModelIf.getFocus}. */
     onFocusChanged(model: FocusModelIf): void;
+    /**
+     * The state of the table changed (column layout, sorting, scroll position, tree, checked or selected rows,
+     * header groups, custom data) – reported once after the changes settled, see {@link GeStateChangeEvent}.
+     * Save `evt.state` e.g. on your server and pass it back as {@link TableOptionsIf.initialState}.
+     * @since 1.1.92
+     */
+    onStateChanged?(evt: GeStateChangeEvent): void;
 }

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

@@ -1,7 +1,8 @@
-import { CoverGridTableModel } from '../data/tablemodel/cover-grid-table-model';
-import { CellRendererIf } from '../renderer/cell-render.if';
-import { TableOptionsIf } from '../data/options/table-options.if';
+import { CoverGridTableModel } from '../data/tablemodel/cover-grid-table-model.js';
+import { CellRendererIf } from '../renderer/cell-render.if.js';
+import { TableOptionsIf } from '../data/options/table-options.if.js';
 
+/** @category Table model */
 export declare class CoverGridFactory {
     static createCoverGridModel<T>(items: T[], cellRenderer: CellRendererIf, coverWidth?: number, coverHeight?: number, width?: number, firstRowPaddingTop?: number): CoverGridTableModel<T>;
     static createCoverGrisDefaultOptions(defaultRowHeight: number, getStorageKeyFn?: () => string): TableOptionsIf;

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

@@ -1,69 +1,123 @@
-import { AreaModelIf } from '../data/tablemodel/areamodel/area-model.if';
-import { DefaultRowHeightsIf } from '../data/options/default-row-heights.if';
-import { ColumnDefIf } from '../data/tablemodel/column/column-def.if';
-import { GetT } from '../data/common/get-t';
-import { TableOptionsIf } from '../data/options/table-options.if';
-import { TableModelIf } from '../data/tablemodel/table-model.if';
-import { TableModel } from '../data/tablemodel/table-model';
-import { SelectionModelIf } from '../selection/selection-model.if';
+import { AreaModelIf } from '../data/tablemodel/areamodel/area-model.if.js';
+import { DefaultRowHeightsIf } from '../data/options/default-row-heights.if.js';
+import { ColumnDefIf } from '../data/tablemodel/column/column-def.if.js';
+import { GetT } from '../data/common/get-t.js';
+import { TableOptionsIf } from '../data/options/table-options.if.js';
+import { TableModelIf } from '../data/tablemodel/table-model.if.js';
+import { TableModel } from '../data/tablemodel/table-model.js';
+import { SelectionModelIf } from '../selection/selection-model.if.js';
 
-export type CreateTableModelPara = {
+/**
+ * Parameters of {@link TableFactory.createTableModel} – pass any subset (`Partial<CreateTableModelPara>`).
+ *
+ * Three typical combinations:
+ *
+ * | You have … | Pass | Training |
+ * |---|---|---|
+ * | an array of objects | `rows` (+ `properties` or `columnDefs`) | [chapter 12](https://gui.expert/training/array-to-table-model/), [13](https://gui.expert/training/column-definitions/) |
+ * | rows of values (CSV, matrix) | `headerData`, `bodyData`, `footerData`, `columnSizes` | [chapter 14](https://gui.expert/training/array-of-arrays/) |
+ * | own area models | `headerAreaModel`, `bodyAreaModel`, `footerAreaModel` + `columnDefs` | [chapter 15–17](https://gui.expert/training/custom-area-model/) |
+ *
+ * Everything not given is derived: column definitions from `properties` or the keys of the first row
+ * (header label = key in upper case, width 200 px), area models from the data, row heights from
+ * `tableOptions.defaultRowHeights`.
+ *
+ * @example
+ * const tableModel = TableFactory.createTableModel({
+ *   rows: orders,                                   // Order[]
+ *   columnDefs: [new ColumnDef("id", "ID", px80, allRight), new ColumnDef("customer", "Customer", px180)],
+ *   fixedLeftColumnCount: 1,
+ *   tableOptions
+ * });
+ *
+ * @category Table model
+ */
+export interface CreateTableModelPara {
+    /** Model of the header. Default: one header row from the `headerLabel`s of `columnDefs`, or `headerData`. */
     headerAreaModel: AreaModelIf;
+    /** Model of the body. Default: built from `rows` (objects or tree rows) or `bodyData`. See {@link AreaModel} for own models. */
     bodyAreaModel: AreaModelIf;
+    /** Model of the footer. Default: `footerData`, otherwise no footer. Totals that follow the filter: an own {@link AreaModel}. */
     footerAreaModel: AreaModelIf;
+    /** Number of columns fixed on the left (side "west"). Default 0. */
     fixedLeftColumnCount: number;
+    /** Number of columns fixed on the right (side "east"). Default 0. */
     fixedRightColumnCount: number;
+    /** Show a checkbox column for every row. Default false. */
     rowCheckboxVisible: 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}. */
     columnDefs: ColumnDefIf[];
+    /** Column widths in px – the simple alternative to `columnDefs` (e.g. with `bodyData`). */
     columnSizes: number[];
+    /** A width in px for all columns; -1 (default) = use the column definitions. */
     overridingColumnWidth: number;
+    /** Number of columns. Default: derived from `columnDefs`, `headerData` or `columnSizes`. */
     columnCount: number;
+    /** Width of the parent element in px, used for percentage column widths before the first render (default 400). */
     parentSize: number;
+    /** Selection model factory. Default: `tableOptions.getSelectionModel`. */
     getSelectionModel: GetT<SelectionModelIf>;
+    /** The rows as objects (`T[]`) or tree rows from {@link TreeFactory.buildTreeRows}. */
     rows: any[];
+    /** Which properties of `rows` become columns, in this order (ignored if `columnDefs` is given). */
     properties: string[];
+    /** The body as rows of values (`any[][]`). */
     bodyData: any[][];
+    /** Header rows as values – several rows are possible. */
     headerData: string[][];
+    /** Footer rows as values (static – they don't follow filter or edits). */
     footerData: string[][];
+    /** Options of the table; the factory reads `defaultRowHeights`, `getSelectionModel` and `showCheckboxWihoutExtraColumn`. */
     tableOptions: TableOptionsIf;
-};
+}
+/**
+ * Creates {@link TableModelIf table models} from data – the usual way to start a table.
+ *
+ * - {@link createTableModel} – the universal entry point with named parameters ({@link CreateTableModelPara}).
+ * - {@link buildByTypedRows} – rows + column definitions (+ options, fixed columns).
+ * - {@link createByObjectArray} – rows + header/footer rows as data.
+ * - {@link createByAreaModels} – three area models of your own.
+ *
+ * Trees: build the rows with {@link TreeFactory.buildTreeRows} first, then pass them as `rows`.
+ *
+ * @example
+ * // all keys of the first row become columns
+ * const simple = TableFactory.createTableModel({ rows: orders });
+ *
+ * // choose and order the columns – typed
+ * const properties: (keyof Order)[] = ["id", "date", "customer", "total"];
+ * const selected = TableFactory.createTableModel({ rows: orders, properties });
+ *
+ * // rows of values with a header and a footer row
+ * const csv = TableFactory.createTableModel({
+ *   headerData: [["ID", "City"]],
+ *   bodyData: [[1, "Berlin"], [2, "Paris"]],
+ *   footerData: [["", "2 rows"]],
+ *   columnSizes: [80, 160]
+ * });
+ *
+ * @see Training: [Array&lt;T&gt; → TableModel](https://gui.expert/training/array-to-table-model/),
+ *   [Array of arrays](https://gui.expert/training/array-of-arrays/)
+ *
+ * @category Table model
+ */
 export declare class TableFactory {
     /**
-     * TableFactory
-     *
-     * This class is responsible for creating table models based on various
-     * parameters and configurations. TableFactory provides different methods
-     * to create these models that must comply with TableModelIf interface.
-     *
-     * Methods:
-     *
-     * createTableModel(p: Partial<{...}>): TableModelIf
-     * Receives a set of parameters as a Partial object with a number of properties
-     * and returns an instance of an object that complies to TableModelIf interface.
-     * Refer to the method's documentation for details.
-     *
-     * buildByTypedRowsParam(param: {rows: T[]; columnDefs: ColumnDefIf[]; tableOptions?: TableOptionsIf; fixedLeftColumnCount?: number; fixedRightColumnCount?: number}): TableModelIf
-     * Receives a parameter object with essential properties needed to build the table model,
-     * including rows (type T array), column definitions (ColumnDefIf array),
-     * optional table options (TableOptionsIf object), and optional fixed column counts,
-     * and returns an instance of TableModelIf.
+     * Creates a table model from any subset of {@link CreateTableModelPara}.
+     * Missing parts are derived (see {@link CreateTableModelPara}).
      *
-     * buildByTypedRows(rows: T[], columnDefs: ColumnDefIf[], tableOptions?: TableOptionsIf, fixedLeftColumnCount?: number, fixedRightColumnCount?: number): TableModelIf
-     * Similar to `buildByTypedRowsParam` but accepts separate parameters instead of a single parameter object.
+     * @param p - rows, column definitions, area models, fixed columns, options …
+     * @returns the table model for `new TableScope(host, tableModel, …)` or the `tableModel` input of a framework wrapper
      *
-     * createByObjectArrayParam(param: {rows: T[]; header?: string[][]; footer?: string[][]; fixedLeftColumnCount?: number; fixedRightColumnCount?: number; rowCheckboxVisible?: boolean; defaultRowHeights?: DefaultRowHeightsIf; columnDefs?: ColumnDefIf[]; columnSizes?: number[]}): TableModelIf
-     * Similar to `createTableModel` but accepts an object parameter with properties required to create a table, including row data, header and footer multi-line data, fixed column counts, visibility of row checkbox, default row heights, column definitions, and column sizes, and returns a TableModelIf instance.
-     *
-     * createByAreaModels(headerAreaModel: AreaModelIf, bodyAreaModel: AreaModelIf, footerAreaModel: AreaModelIf, fixedLeftColumnCount: number, fixedRightColumnCount: number, rowCheckboxVisible: boolean, defaultRowHeights: DefaultRowHeightsIf): TableModelIf
-     * Accepts area models for header, body, and footer, along with fixed column counts, visibility of row checkbox, and default row heights, to create a table model.
-     *
-     * createByAreaModelsParam(param: {headerAreaModel?: AreaModelIf; bodyAreaModel: AreaModelIf; footerAreaModel?: AreaModelIf; fixedLeftColumnCount?: number; fixedRightColumnCount?: number; rowCheckboxVisible?: boolean; defaultRowHeights?: DefaultRowHeightsIf; columnDefs?: ColumnDefIf[]; columnSizes?: number[]; overridingColumnWidth?: number; columnCount?: number}): TableModelIf
-     * Similar to `createByAreaModels` but accepts an object parameter with the required and optional properties to create the table model.
-     *
-     * createByObjectArray(rows: T[], header: string[][], footer: string[][], fixedLeftColumnCount: number, fixedRightColumnCount: number, rowCheckboxVisible: boolean, defaultRowHeights: DefaultRowHeightsIf): TableModelIf
-     * Allows to create a table model utilizing object array data for rows, header, and footer along with the specified configurations.
-     * Please consult each method's documentation for detailed explanation of their functionality.
+     * @example
+     * const tableModel = TableFactory.createTableModel({
+     *   rows: orders,
+     *   columnDefs,
+     *   fixedLeftColumnCount: 1,
+     *   footerAreaModel: new OrderTotalsFooterModel(() => tableModel.getBodyModel())
+     * });
      */
     static createTableModel(p: Partial<CreateTableModelPara>): TableModelIf;
     /**
@@ -156,16 +210,8 @@ export declare class TableFactory {
      *   rowCheckboxVisible: true,
      *   defaultRowHeights: new DefaultRowHeights(40, 50, 40),
      *   columnDefs: [
-     *     {
-     *       property: 'name',
-     *       headerLabel: 'Name',
-     *       width: 100
-     *     },
-     *     {
-     *       property: 'age',
-     *       headerLabel: 'Age',
-     *       width: 50
-     *     }
+     *     new ColumnDef('name', 'Name', px100),
+     *     new ColumnDef('age', 'Age', px50)
      *   ],
      *   columnSizes: [100, 50]
      * };
@@ -307,19 +353,12 @@ export declare class TableFactory {
      *
      * Note: You need to import the `AreaModelArrayOfArrays` and `AreaModelHidden` classes from the respective package/module before using this method.
      *
-     * @example
-     * ```typescript
-     * // Given the following array of objects:
-     * const rows = [{field1: 'data11', field2: 'data12'}, {field1: 'data21', field2: 'data22'}];
-     *
-     * // And a set of column definitions:
-     * const columnDefs: ColumnDefIf[] = [{headerLabel: 'Field 1', property: 'field1'}, {headerLabel: 'Field 2', property: 'field2'}];
-     *
-     * // You can create a TableModel like following:
-     * let tableModel = TableFactory.createByObjectArray(rows, undefined, undefined, 0, 0, false, new DefaultRowHeights(), columnDefs);
-     * ```
+     * Simpler with named parameters: {@link createTableModel}.
      *
-     * Reference: For more details regarding the `DefaultRowHeightsIf`, `ColumnDefIf`, `AreaModelIf`, and `AreaModelArrayOfArrays` classes/interfaces, please refer to the respective API documents.
+     * @example
+     * const rows = [{ field1: "data11", field2: "data12" }, { field1: "data21", field2: "data22" }];
+     * const columnDefs: ColumnDefIf[] = [new ColumnDef("field1", "Field 1"), new ColumnDef("field2", "Field 2")];
+     * const tableModel = TableFactory.createByObjectArray(rows, undefined, undefined, 0, 0, false, new DefaultRowHeights(), columnDefs);
      */
     static createByObjectArray<T>(rows: T[], header: string[][] | undefined, footer: string[][] | undefined, fixedLeftColumnCount: number | undefined, fixedRightColumnCount: number | undefined, rowCheckboxVisible: boolean | undefined, defaultRowHeights: DefaultRowHeightsIf | undefined, columnDefs: ColumnDefIf[], columnSizes?: number[]): TableModel;
 }

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

@@ -1,8 +1,10 @@
-import { TreeRowIf } from '../data/common/tree-row-if';
+import { TreeRowIf } from '../data/common/tree-row-if.js';
 
 /**
  * Expanded state of a new tree row: a fixed value for all rows, or a function per row
  * (e.g. `(_data, deep) => deep < 1` → only the top level is open).
+ *
+ * @category Tree & checkboxes
  */
 export type TreeRowExpandedFn<T> = (data: T, deep: number) => boolean;
 /**
@@ -15,28 +17,68 @@ export type TreeRowExpandedFn<T> = (data: T, deep: number) => boolean;
  * @example
  * // open the first level only
  * TreeFactory.buildTreeRows(data, { expanded: (_row, deep) => deep === 0 });
+ *
+ * @category Tree & checkboxes
  */
 export interface TreeFactoryOptions<T> {
     /** Property that holds the child objects. Default: "children". */
     childrenProperty?: string;
     /** Expanded state of the rows. Default: true (everything open, as before). */
     expanded?: boolean | TreeRowExpandedFn<T>;
-    /** Maximum depth. Default: 12. */
+    /** Maximum depth of a row (0 = top level only); deeper children are skipped with a console warning. Default: 12. */
     deepMaxLimit?: number;
 }
+/**
+ * Turns hierarchical data into {@link TreeRow tree rows} for a tree table. Pass the result as `rows`
+ * to {@link TableFactory.createTableModel} – the factory then creates an {@link AreaModelTree}; the first
+ * column shows the arrows.
+ *
+ * @example
+ * interface Node { label: string; total: number; children?: Node[] }
+ *
+ * const rows = TreeFactory.buildTreeRows<Node>(nodes, {
+ *   childrenProperty: "children",
+ *   expanded: (row, deep) => deep === 0          // open only the first level
+ * });
+ * const tableModel = TableFactory.createTableModel({
+ *   rows,
+ *   columnDefs: [new ColumnDef("label", "Name", px300, bodyLeft), new ColumnDef("total", "Total", px120, allRight)]
+ * });
+ *
+ * @see Training: [Tree table with checkboxes](https://gui.expert/training/tree-table/)
+ *
+ * @category Tree & checkboxes
+ */
 export declare class TreeFactory {
     /**
      * Builds tree rows (input for `TableFactory.createTableModel({ rows })`) from nested objects.
      *
      * @param data - the top-level objects
      * @param childrenPropertyOrOptions - name of the children property (default "children") or {@link TreeFactoryOptions}
-     * @param deepMaxLimit - maximum depth (default 12; ignored when options are passed)
+     * @param deepMaxLimit - maximum depth of a row, 0 = top level only (default 12; ignored when options are passed)
      * @param expanded - expanded state of the rows (default true; ignored when options are passed)
      *
      * @example
      * const rows = TreeFactory.buildTreeRows<OrderNode>(data, { childrenProperty: "children", expanded: false });
      */
     static buildTreeRows<T>(data: T[], childrenPropertyOrOptions?: string | TreeFactoryOptions<T>, deepMaxLimit?: number, expanded?: boolean | TreeRowExpandedFn<T>): TreeRowIf<T>[];
+    /**
+     * Appends the child rows of `data` (recursively) to `parent` – used by {@link buildTreeRows}.
+     * No row deeper than `deepMaxLimit` is created: the children of a row at depth `deepMaxLimit` are
+     * skipped with a console warning.
+     *
+     * @param data - the object whose children are added
+     * @param childrenProperty - name of the children property (default "children")
+     * @param parent - the tree row of `data` (default: a new, expanded top-level row)
+     * @param deep - depth of `parent` (0 = top level)
+     * @param deepMaxLimit - maximum depth of a created row (default 12)
+     * @param expanded - expanded state of the new rows (default true)
+     * @returns `parent`
+     *
+     * @example
+     * const root = TreeFactory.buildTreeRow<OrderNode>(nodes[0], "children");
+     * console.log(root.children?.length);
+     */
     static buildTreeRow<T>(data: T, childrenProperty?: string, parent?: TreeRowIf<T>, deep?: number, deepMaxLimit?: number, expanded?: boolean | TreeRowExpandedFn<T>): TreeRowIf<T>;
     private static toExpandedFn;
 }

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

@@ -1,4 +1,4 @@
-import { FocusModelIf } from './focus-model.if';
+import { FocusModelIf } from './focus-model.if.js';
 
 /**
  * `EventFocusChangedListenerIf` is an interface that defines a contract for classes that wish to listen for changes in focus in a
@@ -29,11 +29,13 @@ import { FocusModelIf } from './focus-model.if';
  * ```
  *
  * ## See Also
- * - [FocusModelIf](./FocusModel.md) for focus management.
- * - [EventAdapter](./EventAdapter.md) for a class that implements this and other listener interfaces.
+ * - {@link FocusModelIf} for focus management.
+ * - {@link EventAdapter} for a class that implements this and other listener interfaces.
  *
  * @interface
  * @method onFocusChanged - method to be called with an instance of the `FocusModelIf` interface whenever a focus event occurs
+ *
+ * @category Events
  */
 export interface EventFocusChangedListenerIf {
     onFocusChanged(model: FocusModelIf): void;

package/lib/table/focus/focus-model.d.ts

@@ -1,6 +1,6 @@
-import { FocusType } from './focus.type';
-import { FocusModelIf } from './focus-model.if';
-import { EventFocusChangedListenerIf } from './event-focus-changed-listener.if';
+import { FocusType } from './focus.type.js';
+import { FocusModelIf } from './focus-model.if.js';
+import { EventFocusChangedListenerIf } from './event-focus-changed-listener.if.js';
 
 /**
  * The `FocusModel` class is an implementation of the `FocusModelIf` interface.
@@ -40,11 +40,13 @@ import { EventFocusChangedListenerIf } from './event-focus-changed-listener.if';
  * focusModel.setFocus(2, 3);
  * ```
  *
- * @see [FocusType](./FocusType.md)
- * @see [EventFocusChangedListenerIf](./EventFocusChangedListenerIf.md)
+ * @see {@link FocusType}
+ * @see {@link EventFocusChangedListenerIf}
  *
  * @class
  * @implements {FocusModelIf}
+ *
+ * @category Selection & focus
  */
 export declare class FocusModel implements FocusModelIf {
     selectionType: FocusType;

package/lib/table/focus/focus-model.if.d.ts

@@ -1,13 +1,34 @@
-import { EventFocusChangedListenerIf } from './event-focus-changed-listener.if';
+import { EventFocusChangedListenerIf } from './event-focus-changed-listener.if.js';
 
+/**
+ * The focused cell of a table (moved by click and arrow keys; F2 edits it). The implementation is {@link FocusModel};
+ * changes are reported to {@link EventListenerIf.onFocusChanged}.
+ *
+ * @example
+ * override onFocusChanged(model: FocusModelIf): void {
+ *   const [row, col] = model.getFocus();
+ *   console.log(`focus on row ${row}, column ${col}`);
+ * }
+ *
+ * @category Selection & focus
+ */
 export interface FocusModelIf {
+    /** The registered listeners. */
     getEventFocusChangedListeners(): EventFocusChangedListenerIf[];
+    /** Get notified when the focus moves. */
     addEventFocusChangedListener(listener: EventFocusChangedListenerIf): void;
+    /** Stop notifications. */
     removeEventFocusChangedListener(listener: EventFocusChangedListenerIf): void;
+    /** No cell has the focus afterwards. */
     clear(): void;
+    /** Moves the focus to a body cell. */
     setFocus(rowIndex: number, columnIndex: number): void;
+    /** Has this cell the focus? */
     hasFocus(rowIndex: number, columnIndex: number): boolean;
+    /** `[rowIndex, columnIndex]` of the focused cell (-1 if none). */
     getFocus(): [number, number];
+    /** Did the focus change since {@link clearChanged}? */
     hasChanged(): boolean;
+    /** Resets {@link hasChanged}. */
     clearChanged(): void;
 }

package/lib/table/focus/focus.type.d.ts

@@ -25,5 +25,7 @@
  * @see FocusModel#setFocus
  * @see FocusModelIf
  * @type
+ *
+ * @category Selection & focus
  */
 export type FocusType = "none" | "cell" | "row";

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

@@ -1,14 +1,18 @@
-import { TableScope } from './table-scope';
+import { TableScope } from './table-scope.js';
 
 /**
  * Class representing an input handler for table input fields (HTMLSelectElement, HTMLTextAreaElement, HTMLInputElement).
  *
  * @class
  * @memberOf module:input
+ *
+ * @category Internals
  */
 export declare class InputHandler {
     protected tableScope: TableScope;
     constructor(tableScope: TableScope);
+    /** Escape in the cell editor cancels the editing: the old value stays, nothing is committed. */
+    private onHostElementKeyDown;
     /**
      * Handles the onHostElementChanged event.
      * In case that the element is an input field, the tableScope.updateModelValueAfterEdit() method is triggered.

package/lib/table/instanceof-workaround.d.ts

@@ -4,6 +4,8 @@
  * @param {any} row - The row to be checked.
  *
  * @return {boolean} - true if the row is a tree row, false otherwise.
+ *
+ * @category Utilities
  */
 export declare function isTreeRow(row: any): boolean;
 /**
@@ -11,6 +13,8 @@ export declare function isTreeRow(row: any): boolean;
  *
  * @param {any} model - The model object to check.
  * @return {boolean} - True if the model is an AreaModelTree, false otherwise.
+ *
+ * @category Utilities
  */
 export declare function isAreaModelTree(model: any): boolean;
 /**
@@ -18,5 +22,17 @@ export declare function isAreaModelTree(model: any): boolean;
  *
  * @param {any} o - The object to be checked.
  * @returns {boolean} - True if the object is a CheckboxColumnDef, false otherwise.
+ *
+ * @category Utilities
+ */
+/**
+ * True for a {@link CheckboxCellRenderer} – also from another copy of the core (no `instanceof`).
+ *
+ * @example
+ * isCheckboxCellRenderer(new CheckboxCellRenderer()); // true
+ *
+ * @since 1.1.91
+ * @category Utilities
  */
+export declare function isCheckboxCellRenderer(o: any): boolean;
 export declare function isCheckboxColumnDef(o: any): boolean;

package/lib/table/license-manager.d.ts

@@ -3,6 +3,8 @@
  * As it's a singleton class, it only allows one instance of itself to exist.
  *
  * Usage: LicenseManager.getInstance().setLicenseKey('Your API key');
+ *
+ * @category Table & API
  */
 export declare class LicenseManager {
     private static instance;

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

@@ -1,14 +1,18 @@
-import { TableScope } from './table-scope';
-import { GeMouseEvent } from './data/common/event/ge-mouse-event';
+import { TableScope } from './table-scope.js';
+import { GeMouseEvent } from './data/common/event/ge-mouse-event.js';
 
 /**
  * Class representing a MouseHandler.
  * @class
+ *
+ * @category Internals
  */
 export declare class MouseHandler {
     protected tableScope: TableScope;
     /**
-     * Represents the delay in milliseconds between two consecutive double clicks.
+     * Programmatic clicks (`element.click()`, `event.detail === 0`): two clicks on the same cell within this delay (ms)
+     * count as a double click. Real mouse clicks use the click count of the browser (`event.detail`), i.e. the
+     * double-click speed of the operating system.
      *
      * @type {number}
      */
@@ -17,9 +21,11 @@ export declare class MouseHandler {
     startMouseEvent?: GeMouseEvent;
     geMouseEvent?: GeMouseEvent;
     geMouseEventOld?: GeMouseEvent;
-    private expandedAll;
     private lastClickedCellKey;
+    /** The second click of a double click that was already reported (clickCount 2) – its "dblclick" is not. */
+    private reportedDoubleClick?;
     private mouseDown;
+    private repaintAfterMouseUp;
     private dragging;
     constructor(tableScope: TableScope);
     /**
@@ -39,6 +45,10 @@ export declare class MouseHandler {
      * @return {void}
      */
     private onHostElementClicked;
+    /** "area:row:column" of the cell of an event target ('' outside of a cell). */
+    private getCellKey;
+    /** A click that triggers an action on its own: row checkbox, tree arrow, "expand/collapse all", header group toggle. */
+    private isClickAction;
     /**
      * Handles the double click event on the host element.
      * This method is private.
@@ -56,12 +66,11 @@ export declare class MouseHandler {
      */
     private publishGeMouseEvent;
     /**
-     * Update the collapsed/expanded state of a tree row.
-     *
-     * @param {TreeRowIf<any>} tr - The tree row object.
-     * @returns {void}
+     * True if the click went to a form control, button, link or editable element inside the table (e.g. rendered by
+     * a custom cell renderer or the cell editor). Such a click must not repaint: the repaint re-creates the cells,
+     * the element would lose the focus and the user's input.
      */
-    private updateCollapsedExpandedState;
+    private isInteractiveCellElement;
     private getArrowColumnIndex;
     private onMouseDown;
     private onMouseMove;
@@ -69,4 +78,6 @@ export declare class MouseHandler {
     private mouseDraggingOnFrame;
     private mouseDraggingEndOnFrame;
     private mouseMoveOnFrame;
+    /** A mouse event on a blocking loading overlay ({@link TableOverlay.isEventBlocked}): the table ignores it. */
+    private isBlocked;
 }

package/lib/table/overlay/calc-overlay-kind.d.ts

@@ -0,0 +1,31 @@
+import { GeOverlayKind } from './ge-overlay-kind.type.js';
+
+/**
+ * Input of {@link calcOverlayKind}.
+ *
+ * @since 1.1.92
+ * @category Internals
+ */
+export interface OverlayKindInput {
+    /** The overlay requested by the API ({@link TableApi.showLoadingOverlay}, {@link TableApi.showNoRowsOverlay}). */
+    manual?: "loading" | "noRows";
+    /** `getRowCount()` of the body (after the filter); < 0 = unknown. */
+    rowCount: number;
+    /** `getUnfilteredRowCount()` of the body, `undefined` if the model cannot tell. */
+    unfilteredRowCount?: number;
+    /** {@link OverlayOptionsIf.autoNoRows} */
+    autoNoRows: boolean;
+}
+/**
+ * Decides which overlay the table shows. Order: a manual overlay > "no matching rows" > "no rows to show".
+ * A model that cannot tell its unfiltered row count gets "no rows" (never a wrong "no matching rows"),
+ * an unknown row count (< 0) no overlay.
+ *
+ * @example
+ * calcOverlayKind({ rowCount: 0, unfilteredRowCount: 100, autoNoRows: true }); // "noMatches"
+ * calcOverlayKind({ manual: "loading", rowCount: 0, autoNoRows: true });       // "loading"
+ *
+ * @since 1.1.92
+ * @category Internals
+ */
+export declare function calcOverlayKind(input: OverlayKindInput): GeOverlayKind;