@guiexpert/table 1.1.90 → 1.1.92

package/lib/table/data/common/tree-row-if.d.ts

@@ -1,13 +1,34 @@
 /**
- * Represents a (table) row in a tree structure. It's a container object for T with additional tree node information.@template T - The type of data stored in each row.
+ * A row of a tree table: your object (`data`) plus the tree state. Created by {@link TreeFactory.buildTreeRows}.
+ *
+ * @typeParam T - the type of your objects
+ *
+ * @example
+ * // expand all first-level rows: change `expanded`, rebuild the displayed rows, repaint
+ * const treeModel = tableModel.getBodyModel() as AreaModelTree<OrderNode>;
+ * for (const row of treeModel.rows) row.expanded = true;
+ * treeModel.recalcVisibleTreeRows(); // without it the table keeps showing the old rows
+ * tableApi.repaintHard();
+ *
+ * @see Training: [Tree table with checkboxes](https://gui.expert/training/tree-table/)
+ *
+ * @category Tree & checkboxes
  */
 export interface TreeRowIf<T> {
+    /** Marker to recognise tree rows across package boundaries (see `isTreeRow()`). */
     type?: 'TreeRow' | '';
+    /** Your object. Column values are read from it (`columnDef.property`). */
     data: T;
+    /** Are the children visible? */
     expanded: boolean;
+    /** The child rows, undefined for leaves. */
     children: TreeRowIf<T>[] | undefined;
+    /** The parent row, undefined on the top level. */
     parent: TreeRowIf<T> | undefined;
+    /** Depth in the tree: 0 = top level. */
     deep: number;
+    /** Checkbox state (with `showCheckboxWihoutExtraColumn` or a checkbox column). */
     checked: boolean;
+    /** Internal, set by the filter: the row or one of its descendants matches (also below collapsed rows). */
     keep: boolean;
 }

package/lib/table/data/common/tree-row.d.ts

@@ -1,8 +1,10 @@
-import { TreeRowIf } from './tree-row-if';
+import { TreeRowIf } from './tree-row-if.js';
 
 /**
  * Represents a (table) row in a tree structure. It's a container object for T with additional tree node information.
  * @template T - The type of data stored in the row.
+ *
+ * @category Tree & checkboxes
  */
 export declare class TreeRow<T> implements TreeRowIf<T> {
     data: T;

package/lib/table/data/common/value-label.d.ts

@@ -1,5 +1,6 @@
-import { ValueLabelIf } from './value-label.if';
+import { ValueLabelIf } from './value-label.if.js';
 
+/** @category Columns */
 export declare class ValueLabel implements ValueLabelIf {
     value: any;
     label: string;

package/lib/table/data/common/value-label.if.d.ts

@@ -1,3 +1,4 @@
+/** @category Columns */
 export interface ValueLabelIf {
     value: any;
     label: string;

package/lib/table/data/div-scope.type.d.ts

@@ -6,6 +6,8 @@
  *   child: HTMLDivElement,
  *   cache: { [key: number]: HTMLDivElement }
  * }} DivScope
+ *
+ * @category Area models
  */
 export type DivScope = {
     parent: HTMLDivElement;

package/lib/table/data/event/mouse-target-data.d.ts

@@ -1,6 +1,6 @@
-import { AreaIdent } from '../tablemodel/area-ident.type';
-import { AreaModelIf } from '../tablemodel/areamodel/area-model.if';
-import { TableScope } from '../../table-scope';
+import { AreaIdent } from '../tablemodel/area-ident.type.js';
+import { AreaModelIf } from '../tablemodel/areamodel/area-model.if.js';
+import { TableScope } from '../../table-scope.js';
 
 /**
  * The MouseTargetData class is used to process and provide information about user interaction, especially mouse events, with specific areas and elements of a table built using HTML Div elements, Span elements, and Input elements.
@@ -25,6 +25,8 @@ import { TableScope } from '../../table-scope';
  *
  * @example
  * const mouseTarget = new MouseTargetData(eventTarget, tableScope);
+ *
+ * @category Internals
  */
 export declare class MouseTargetData {
     rowIdx: number;

package/lib/table/data/geo-data.d.ts

@@ -1,5 +1,7 @@
 /**
  * Represents geometric data with left, width, height, top coordinates and an optional index.
+ *
+ * @category Utilities
  */
 export declare class GeoData {
     left: number;

package/lib/table/data/options/auto-restore-options.d.ts

@@ -1,12 +1,55 @@
-import { AutoRestoreOptionsIf } from './auto-restore-options.if';
+import { AutoRestoreOptionsIf } from './auto-restore-options.if.js';
 
+/**
+ * Defaults for {@link TableOptionsIf.autoRestoreOptions}: everything off. Spread it and switch on what the table
+ * should remember in `localStorage` (one key per table) – see {@link AutoRestoreOptionsIf} for all flags.
+ *
+ * @example
+ * const tableOptions: TableOptionsIf = {
+ *   ...new TableOptions(),
+ *   autoRestoreOptions: {
+ *     ...new AutoRestoreOptions<Order>(),
+ *     getStorageKeyFn: () => "orders-table",          // unique per table
+ *     autoRestoreSortingState: true,
+ *     autoRestoreScrollPosition: true,
+ *     autoRestoreColumnLayout: true                     // widths, order, visibility (since 1.1.92)
+ *   }
+ * };
+ *
+ * @example
+ * // trees: remember expanded nodes – needs a stable id per node
+ * const treeOptions: TableOptionsIf = {
+ *   ...new TableOptions(),
+ *   autoRestoreOptions: {
+ *     ...new AutoRestoreOptions<OrderNode>(),
+ *     getStorageKeyFn: () => "order-tree",
+ *     getRowId: (node: OrderNode) => node.id,
+ *     autoRestoreCollapsedExpandedState: true
+ *   }
+ * };
+ *
+ * @see Training: [Remember the state](https://gui.expert/training/persist-state/)
+ *
+ * @category Options
+ */
 export declare class AutoRestoreOptions<T> implements AutoRestoreOptionsIf<T> {
     autoRestoreSortingState: boolean;
     autoRestoreCollapsedExpandedState: boolean;
     autoRestoreScrollPosition: boolean;
     autoRestoreCheckedState: boolean;
     autoRestoreSelectedState: boolean;
+    /** @since 1.1.92 */
+    autoRestoreColumnLayout: boolean;
+    /** @since 1.1.92 */
+    autoRestoreHeaderGroupState: boolean;
+    /** @since 1.1.92 */
+    autoRestoreCustomState: boolean;
     getStorageKeyFn: undefined;
+    /** @deprecated since 1.1.92 – never used by the table. */
     isSame: (r1: T, r2: T, options: AutoRestoreOptionsIf<T>) => boolean;
+    /**
+     * Default: the property `id`, then `uuid`, then the JSON of the row. The table itself uses only `id` / `uuid` of
+     * this default (since 1.1.92): rows without them are not stored – the JSON would write whole rows into the storage.
+     */
     getRowId: (row: T) => string | number;
 }

package/lib/table/data/options/auto-restore-options.if.d.ts

@@ -1,73 +1,123 @@
+import { StateStorageIf } from '../../state/state-storage.if.js';
+
 /**
- * `IsSameFn` is a type alias for a function used within the `AutoRestoreOptionsIf` interface. The function is designed to compare
- * two instances of a generic type `T`, in conjunction with supplied options of type `AutoRestoreOptionsIf<T>`.
+ * `IsSameFn` compares two rows with the help of {@link AutoRestoreOptionsIf.getRowId}.
  *
- * This function is used for determining if two instances of `T` are considered the same when restoring the state of an application.
- * This helps in preserving specific states of the application, like sorting or selected state, across different stages or conditions
- * based on the developer's implementation. By default, this function uses strict equality check (`===`) if not provided.
+ * @deprecated since 1.1.92 – never used by the table; rows are compared by {@link AutoRestoreOptionsIf.getRowId}.
  *
- * @typedef
- * @typeparam T - The type of the objects that the function is comparing.
- *
- * @param {T} r1 - The first object instance of type `T`.
- * @param {T} r2 - The second object instance of type `T`.
- * @param {AutoRestoreOptionsIf<T>} optionsIf - The options that dictate the behavior of auto-restoring.
- *
- * @returns {boolean} - Returns `true` if the two instances are considered the same, `false` otherwise.
+ * @typeparam T - The type of the rows.
+ * @category Options
  */
 export type IsSameFn<T> = (r1: T, r2: T, optionsIf: AutoRestoreOptionsIf<T>) => boolean;
 /**
- * GetRowIdFn is a type alias for a function that accepts an instance of type T and returns a unique identifier
- * (either a string or a number) for that instance. It is used for restoring state in conjunction with the
- * AutoRestoreOptionsIf interface.
- * @typedef
- * @typeparam T - The type of the object that the function is going to use.
+ * Returns a unique, stable id for a row – used to remember expanded tree nodes, checked and selected rows and the
+ * first visible row ({@link AutoRestoreOptionsIf}, {@link TableStateIf}).
+ *
+ * Tree tables get the object of the node (`treeRow.data`). Models without row objects (e.g. an own `AreaModel`
+ * that computes its values) get `undefined` and the displayed row index – declare the second parameter to support
+ * them: `(_row, rowIndex) => rowIndex`.
+ *
+ * @example
+ * const getRowId: GetRowIdFn<Order> = (order: Order) => order.id;
+ *
+ * @typeparam T - The type of the rows.
+ * @category Options
  */
-export type GetRowIdFn<T> = ((row: T) => string | number);
+export type GetRowIdFn<T> = ((row: T, rowIndex?: number) => string | number);
 /**
- * GetStorageKeyFn is a type alias for a function that returns a unique key (as a string) for storage.
- * It is used for restoring state in conjunction with the AutoRestoreOptionsIf interface.
- * @typedef
+ * Returns the storage key of a table – one key per table, e.g. `() => "orders"`. The state is stored under
+ * `<key>tableState`.
+ *
+ * @category Options
  */
 export type GetStorageKeyFn = (() => string);
 /**
- * The AutoRestoreOptionsIf interface is utilized to encapsulate options
- * for managing auto-restoring settings across different states of the application.
- * This interface is generic and can be used with any type.
- *
- * @interface
- * @typeparam T - Any type that this interface is going to use.
- * @property {boolean} autoRestoreSortingState - If true, the sorting state of
- * T elements will be preserved after changes in the application state.
- *
- * @property {boolean=} autoRestoreCollapsedExpandedState - Optional. If true,
- * the expanded/collapsed state of T elements will be preserved after changes in the application state.
+ * What a table remembers between page loads, and where. Everything is off by default ({@link AutoRestoreOptions});
+ * nothing is stored without {@link getStorageKeyFn} (the table warns once if a flag is set without it).
  *
- * @property {boolean=} autoRestoreScrollPosition - Optional. If true, the scroll position
- * in the list of T elements will be preserved after changes in the application state.
+ * The state is stored as one JSON value under `<key>tableState` in {@link storage} (default `localStorage`) –
+ * the same format as {@link TableApi.getState}. Columns are stored by property and rows by {@link getRowId}, so a
+ * moved column or new data never hits the wrong column or row. The stored state holds no cell values, but row ids
+ * can be personal data (e.g. an e-mail address as id) – prefer technical ids. The tree, checked rows, the selection
+ * and the first visible row need row ids; tree, checked and selected rows are computed only when their flag is set.
  *
- * @property {boolean=} autoRestoreCheckedState - Optional. If true, the checked state of
- * T elements will be preserved after changes in the application state.
+ * | Flag | Remembers | since |
+ * |---|---|---|
+ * | {@link autoRestoreSortingState} | sorted columns | |
+ * | {@link autoRestoreScrollPosition} | scroll position | |
+ * | {@link autoRestoreCollapsedExpandedState} | expanded tree nodes | |
+ * | {@link autoRestoreColumnLayout} | width, order, visibility of the columns | 1.1.92 |
+ * | {@link autoRestoreHeaderGroupState} | collapsed header groups | 1.1.92 |
+ * | {@link autoRestoreCheckedState} | checked rows | 1.1.92 (declared before, without effect) |
+ * | {@link autoRestoreSelectedState} | selection | 1.1.92 (declared before, without effect) |
+ * | {@link autoRestoreCustomState} | your data ({@link TableApi.setCustomState}) | 1.1.92 |
  *
- * @property {boolean=} autoRestoreSelectedState - Optional. If true, the selected state of
- * T elements will be preserved after changes in the application state.
+ * Before 1.1.92 sorting, scroll position and tree were stored under three keys (`<key>sortingState`,
+ * `<key>scrollState`, `<key>collapsedExpandedState`); they are read once and removed with the next save.
  *
- * @property {(row: T) => string | number} getRowId - Function for generating a unique identifier
- * for an instance of T. If not provided, each instance of T will create a new entry every time state is saved.
+ * @example
+ * const tableOptions: TableOptionsIf = {
+ *   ...new TableOptions(),
+ *   autoRestoreOptions: {
+ *     ...new AutoRestoreOptions<Order>(),
+ *     getStorageKeyFn: () => "orders",
+ *     getRowId: (order: Order) => order.id,
+ *     autoRestoreColumnLayout: true,
+ *     autoRestoreSortingState: true,
+ *     autoRestoreCheckedState: true
+ *   }
+ * };
  *
- * @property {() => string} getStorageKeyFn - Function for generating a unique key used for storage.
- * If not provided, a constant key 'autorestoreoptionsif' will be used.
+ * @typeparam T - The type of the rows.
+ * @see Training: [Remember the state](https://gui.expert/training/persist-state/)
  *
- * @property {(r1: T, r2: T, optionsIf: AutoRestoreOptionsIf<T>) => boolean} isSame - Function for checking
- * if two instances of T are considered the same when restoring state. If not provided, strict equality check (===) will be used.
+ * @category Options
  */
 export interface AutoRestoreOptionsIf<T> {
+    /** Remember the sorted columns (by property). */
     autoRestoreSortingState: boolean;
+    /** Remember expanded and collapsed nodes of a tree table (by {@link getRowId}). */
     autoRestoreCollapsedExpandedState?: boolean;
+    /** Remember the scroll position (and the id of the first visible row). */
     autoRestoreScrollPosition?: boolean;
+    /** Remember the checked rows (by {@link getRowId}). Since 1.1.92 (before: declared without effect). */
     autoRestoreCheckedState?: boolean;
+    /**
+     * Remember the selection: rows by {@link getRowId}, columns by property. Restored in the current row order.
+     * Since 1.1.92 (before: declared without effect).
+     */
     autoRestoreSelectedState?: boolean;
+    /**
+     * Remember width, order and visibility of the columns (by property). Widths are stored only for columns that were
+     * resized, so `%` and weight columns stay responsive.
+     * @since 1.1.92
+     */
+    autoRestoreColumnLayout?: boolean;
+    /**
+     * Remember collapsed and expanded header groups ({@link CellGroupIf.toggle}).
+     * @since 1.1.92
+     */
+    autoRestoreHeaderGroupState?: boolean;
+    /**
+     * Remember the data set with {@link TableApi.setCustomState} (e.g. a filter text).
+     * @since 1.1.92
+     */
+    autoRestoreCustomState?: boolean;
+    /**
+     * A unique, stable id per row (tree: per node). With the default of {@link AutoRestoreOptions} the table uses the
+     * property `id`, then `uuid`; rows without them are not stored (since 1.1.92 – the JSON of the row would write
+     * personal data into the storage; the table warns once).
+     */
     getRowId?: undefined | GetRowIdFn<T>;
+    /** The storage key of this table, e.g. `() => "orders"`. Without it nothing is stored. */
     getStorageKeyFn?: undefined | GetStorageKeyFn;
+    /**
+     * @deprecated since 1.1.92 – never used; rows are compared by {@link getRowId}.
+     */
     isSame?: undefined | IsSameFn<T>;
+    /**
+     * Where the state is stored. Default: `localStorage`; `sessionStorage` or an own {@link StateStorageIf} also work.
+     * @since 1.1.92
+     */
+    storage?: StateStorageIf;
 }

package/lib/table/data/options/default-row-heights.d.ts

@@ -1,8 +1,26 @@
-import { DefaultRowHeightsIf } from './default-row-heights.if';
+import { DefaultRowHeightsIf } from './default-row-heights.if.js';
 
+/**
+ * Row heights of header, body and footer in px – default 34 each. Used in {@link TableOptionsIf.defaultRowHeights}
+ * and {@link CreateTableModelPara.defaultRowHeights}.
+ *
+ * @example
+ * const tableOptions: TableOptionsIf = { ...new TableOptions(), defaultRowHeights: new DefaultRowHeights(40, 30, 36) };
+ *
+ * @category Options
+ */
 export declare class DefaultRowHeights implements DefaultRowHeightsIf {
+    /** Height of header rows in px. */
     header: number;
+    /** Height of body rows in px. */
     body: number;
+    /** Height of footer rows in px. */
     footer: number;
-    constructor(header?: number, body?: number, footer?: number);
+    constructor(
+    /** Height of header rows in px. */
+    header?: number, 
+    /** Height of body rows in px. */
+    body?: number, 
+    /** Height of footer rows in px. */
+    footer?: number);
 }

package/lib/table/data/options/default-row-heights.if.d.ts

@@ -7,6 +7,8 @@
  * @property `body`: It sets the height of the body rows present in the table. This value can be individually adjusted by developers.
  * @property `footer`: This property represents the height of the table footer row. It has a mutable value that can be modified as per requirements.
  *
+ * See {@link DefaultRowHeights} for the defaults (34 px each).
+ *
  * @example
  * // declaring a variable with default row heights
  * let rowHeights: DefaultRowHeightsIf = {
@@ -14,8 +16,9 @@
  *     body: 100,
  *     footer: 60
  * };
+
  *
- * For implementation details, refer to the `DefaultRowHeights` class.
+ * @category Options
  */
 export interface DefaultRowHeightsIf {
     header: number;

package/lib/table/data/options/default-row-id.d.ts

@@ -0,0 +1,4 @@
+/** Marks a function as the default `getRowId` of {@link AutoRestoreOptions}. */
+export declare function markDefaultGetRowId<F extends object>(fn: F): F;
+/** true for the default `getRowId` of {@link AutoRestoreOptions} (also after spreading the options). */
+export declare function isDefaultGetRowId(fn: unknown): boolean;

package/lib/table/data/options/header-group-options.d.ts

@@ -1,6 +1,7 @@
-import { IconIf } from './icon.if';
-import { HeaderGroupOptionsIf } from './header-group-options.if';
+import { IconIf } from './icon.if.js';
+import { HeaderGroupOptionsIf } from './header-group-options.if.js';
 
+/** @category Header groups */
 export declare class HeaderGroupOptions implements HeaderGroupOptionsIf {
     iconExpanded: IconIf;
     iconCollapsed: IconIf;

package/lib/table/data/options/header-group-options.if.d.ts

@@ -1,4 +1,4 @@
-import { IconIf } from './icon.if';
+import { IconIf } from './icon.if.js';
 
 /**
  * The `HeaderGroupOptionsIf` interface is part of the TypeScript project,
@@ -32,10 +32,9 @@ import { IconIf } from './icon.if';
  *     classes: ["my-collapsed-icon-class"]
  *   }
  * };
+
  *
- * This example creates an object conforming to the `HeaderGroupOptionsIf`
- * interface where `iconExpanded` and `iconCollapsed` each hold the specifications
- * for the expanded and collapsed states of a header group component respectively.
+ * @category Header groups
  */
 export interface HeaderGroupOptionsIf {
     iconExpanded: IconIf;

package/lib/table/data/options/icon.d.ts

@@ -1,5 +1,6 @@
-import { IconIf } from './icon.if';
+import { IconIf } from './icon.if.js';
 
+/** @category Options */
 export declare class Icon implements IconIf {
     content: string;
     style: string;

package/lib/table/data/options/icon.if.d.ts

@@ -10,6 +10,8 @@
  * )
  *
  * @interface
+ *
+ * @category Options
  */
 export interface IconIf {
     content: string;

package/lib/table/data/options/overlay-options.d.ts

@@ -0,0 +1,30 @@
+import { OverlayOptionsIf } from './overlay-options.if.js';
+import { GeOverlayKind } from '../../overlay/ge-overlay-kind.type.js';
+
+/**
+ * The defaults of {@link OverlayOptionsIf}: English texts, an automatic "No rows to show", a loading overlay that
+ * blocks the body and appears right away.
+ *
+ * @example
+ * const overlayOptions = OverlayOptions.create({ noRowsText: "Keine Daten" });
+ * console.log(overlayOptions.loadingText); // "Loading…"
+ *
+ * @since 1.1.92
+ * @category Overlays
+ */
+export declare class OverlayOptions implements OverlayOptionsIf {
+    loadingText: string;
+    noRowsText: string;
+    noMatchesText: string;
+    autoNoRows: boolean;
+    blockInteractionWhileLoading: boolean;
+    loadingDelayInMs: number;
+    getOverlayElement?: (kind: GeOverlayKind, text: string) => HTMLElement | undefined;
+    /**
+     * The defaults with the given fields on top (`undefined` fields keep their default).
+     *
+     * @param {Partial<OverlayOptionsIf>} [partial] - e.g. `tableOptions.overlayOptions`
+     * @returns {OverlayOptions} a new object
+     */
+    static create(partial?: Partial<OverlayOptionsIf>): OverlayOptions;
+}

package/lib/table/data/options/overlay-options.if.d.ts

@@ -0,0 +1,79 @@
+import { GeOverlayKind } from '../../overlay/ge-overlay-kind.type.js';
+
+/**
+ * Texts and behaviour of the overlays over the table body: "Loading…" ({@link TableApi.showLoadingOverlay}),
+ * "No rows to show" (empty body) and "No matching rows" (the external filter hides all rows).
+ *
+ * Set it with {@link TableOptionsIf.overlayOptions} – every field is optional there, missing ones keep their
+ * default ({@link OverlayOptions}). The overlays are plain HTML and CSS (spinner: `@keyframes`), colours come from
+ * the CSS variables `--ge-table-overlay-bg`, `--ge-table-overlay-color`, `--ge-table-spinner-color`,
+ * `--ge-table-spinner-track-color` and `--ge-table-spinner-size`.
+ *
+ * @example
+ * const tableOptions: TableOptionsIf = {
+ *   ...new TableOptions(),
+ *   overlayOptions: {
+ *     loadingText: "Lädt…",
+ *     noRowsText: "Keine Daten",
+ *     noMatchesText: "Keine Treffer",
+ *     loadingDelayInMs: 200, // fast answers show no spinner at all
+ *   },
+ * };
+ *
+ * @since 1.1.92
+ * @see Training: [Live data](https://gui.expert/training/live-data/)
+ * @category Overlays
+ */
+export interface OverlayOptionsIf {
+    /** Text of the loading overlay. Default: `"Loading…"`. */
+    loadingText: string;
+    /** Text of the overlay of an empty body. Default: `"No rows to show"`. */
+    noRowsText: string;
+    /** Text when the external filter hides all rows. Default: `"No matching rows"`. */
+    noMatchesText: string;
+    /**
+     * `true` (default): an empty body shows "No rows to show" (or "No matching rows") by itself, after every
+     * repaint. `false`: only {@link TableApi.showNoRowsOverlay} shows it.
+     */
+    autoNoRows: boolean;
+    /**
+     * `true` (default): while "Loading…" is shown, the table ignores mouse events on the body (click, double click,
+     * hover, context menu – the page still sees them) and the keyboard cannot start editing or toggle rows in the body;
+     * navigation, copying and the header still work.
+     * `false`: the loading overlay is only a picture, the table stays usable.
+     * "No rows" / "No matching rows" never block.
+     */
+    blockInteractionWhileLoading: boolean;
+    /**
+     * Waits this long (ms) before the loading overlay appears. Answers that come faster show no spinner at all
+     * (no flashing); meanwhile an automatic "No rows to show" stays as it is. Default: `0` (right away).
+     */
+    loadingDelayInMs: number;
+    /**
+     * Own content of an overlay instead of the built-in one (spinner + text). Called once each time the overlay
+     * of a kind appears; return `undefined` to keep the built-in content for that kind. The table removes the
+     * element again when the overlay disappears or changes and in {@link TableApi.destroy}.
+     *
+     * The overlay is hidden from screen readers (`aria-hidden`, the table announces its text instead):
+     * put no buttons or links into it.
+     *
+     * @param {GeOverlayKind} kind - `"loading"`, `"noRows"` or `"noMatches"`
+     * @param {string} text - the text the built-in content would show
+     * @returns {HTMLElement | undefined} the element to show, or `undefined` for the default
+     *
+     * @example
+     * const tableOptions: TableOptionsIf = {
+     *   ...new TableOptions(),
+     *   overlayOptions: {
+     *     getOverlayElement: (kind: GeOverlayKind, text: string) => {
+     *       if (kind !== "noRows") return undefined; // built-in spinner and texts for the others
+     *       const div = document.createElement("div");
+     *       div.className = "my-empty-state";
+     *       div.textContent = `📭 ${text}`;
+     *       return div;
+     *     },
+     *   },
+     * };
+     */
+    getOverlayElement?: (kind: GeOverlayKind, text: string) => HTMLElement | undefined;
+}

package/lib/table/data/options/sorted-options.d.ts

@@ -1,6 +1,7 @@
-import { IconIf } from './icon.if';
-import { SortedOptionsIf } from './sorted-options.if';
+import { IconIf } from './icon.if.js';
+import { SortedOptionsIf } from './sorted-options.if.js';
 
+/** @category Options */
 export declare class SortedOptions implements SortedOptionsIf {
     iconAsc: IconIf;
     iconDesc: IconIf;

package/lib/table/data/options/sorted-options.if.d.ts

@@ -1,4 +1,4 @@
-import { IconIf } from './icon.if';
+import { IconIf } from './icon.if.js';
 
 /**
  * This TypeScript interface, `SortedOptionsIf`, represents the configuration options for sorting.
@@ -21,6 +21,8 @@ import { IconIf } from './icon.if';
  * Note that the `classes` property in `IconIf` expects an array of strings, each string indicating a CSS class that should be applied to the icon.
  *
  * @interface
+ *
+ * @category Options
  */
 export interface SortedOptionsIf {
     iconAsc: IconIf;

package/lib/table/data/options/table-options.d.ts

@@ -1,18 +1,35 @@
-import { DefaultRowHeightsIf } from './default-row-heights.if';
-import { TableOptionsIf } from './table-options.if';
-import { TreeOptions } from './tree-options';
-import { FilterFunction } from '../common/filter-function';
-import { SortState } from '../common/sort-state.type';
-import { SortedOptions } from './sorted-options';
-import { GetEditRenderer } from '../../renderer/edit/edit-cell-renderer.type';
-import { SelectionModelIf } from '../../selection/selection-model.if';
-import { GetT } from '../common/get-t';
-import { FocusModelIf } from '../../focus/focus-model.if';
-import { ShortcutActionIdMapping } from '../../action/shortcut-actionid-mapping.type';
-import { HeaderGroupOptions } from './header-group-options';
+import { DefaultRowHeightsIf } from './default-row-heights.if.js';
+import { TableOptionsIf } from './table-options.if.js';
+import { TreeOptions } from './tree-options.js';
+import { FilterFunction } from '../common/filter-function.js';
+import { SortState } from '../common/sort-state.type.js';
+import { SortedOptions } from './sorted-options.js';
+import { GetEditRenderer } from '../../renderer/edit/edit-cell-renderer.type.js';
+import { SelectionModelIf } from '../../selection/selection-model.if.js';
+import { GetT } from '../common/get-t.js';
+import { FocusModelIf } from '../../focus/focus-model.if.js';
+import { ShortcutActionIdMapping } from '../../action/shortcut-actionid-mapping.type.js';
+import { HeaderGroupOptions } from './header-group-options.js';
+import { AriaTextsIf } from '../../aria/aria-texts.if.js';
+import { OverlayOptionsIf } from './overlay-options.if.js';
 
 /**
- * TableOptions class provides configuration options for the table.
+ * All default options of a table – see {@link TableOptionsIf} for the meaning of each field.
+ *
+ * Use it with the spread pattern: all defaults, plus your changes.
+ *
+ * @example
+ * const tableOptions: TableOptionsIf = {
+ *   ...new TableOptions(),
+ *   hoverColumnVisible: false,
+ *   verticalBorderVisible: false,
+ *   defaultRowHeights: { header: 40, body: 30, footer: 36 },
+ *   externalFilterFunction: (order: Order) => order.total > 1000
+ * };
+ *
+ * @see Training: [TableOptions: behaviour and look](https://gui.expert/training/table-options/)
+ *
+ * @category Options
  */
 export declare class TableOptions implements TableOptionsIf {
     overflowX: "auto" | "scroll";
@@ -53,4 +70,14 @@ export declare class TableOptions implements TableOptionsIf {
      * Focus model of the table. Not set (default): every table creates its own `new FocusModel("cell")`.
      */
     getFocusModel?: GetT<FocusModelIf>;
+    /** Accessible name of the table (`aria-label`). Default: none. @since 1.1.91 */
+    ariaLabel?: string;
+    /** Id of the element that names the table (`aria-labelledby`). Default: none. @since 1.1.91 */
+    ariaLabelledBy?: string;
+    /** Id of the element that describes the table (`aria-describedby`). Default: none. @since 1.1.91 */
+    ariaDescribedBy?: string;
+    /** Own screen reader texts; missing functions use the English defaults ({@link AriaTexts}). @since 1.1.91 */
+    ariaTexts?: Partial<AriaTextsIf>;
+    /** Texts and behaviour of the "Loading…" / "No rows" overlays; missing fields use {@link OverlayOptions}. @since 1.1.92 */
+    overlayOptions?: Partial<OverlayOptionsIf>;
 }