@guiexpert/table 1.1.90 → 1.1.92

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

@@ -1,10 +1,10 @@
-import { SizeIf } from '../../common/size.if';
-import { CellRendererIf } from '../../../renderer/cell-render.if';
-import { AreaObjectMapType } from '../../common/area-map.type';
-import { BooleanFunction } from '../../common/boolean-function';
-import { SortState } from '../../common/sort-state.type';
-import { GetEditRenderer } from '../../../renderer/edit/edit-cell-renderer.type';
-import { editInputPipe } from '../../../renderer/edit/edit-input-pipe.if';
+import { SizeIf } from '../../common/size.if.js';
+import { CellRendererIf } from '../../../renderer/cell-render.if.js';
+import { AreaObjectMapType } from '../../common/area-map.type.js';
+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';
 
 /**
  * Represents a function that compares two values for sorting purposes.
@@ -21,132 +21,99 @@ import { editInputPipe } from '../../../renderer/edit/edit-input-pipe.if';
  * @param f Optional. The direction. It is not necessary to use this value in the comparator, as this number is used as a factor (1 or -1) in the outer sort method.
  *
  * @returns A number indicating the relative order of 'valueA' and 'valueB'.
+ *
+ * @category Columns
  */
 export type ValueRowSortComparator = (valueA: any, valueB: any, rowA?: any, rowB?: any, f?: number) => number;
 /**
- * Represents a column definition of one table column.
+ * Describes one column: which property it shows, header label, width, CSS classes, renderers,
+ * sorting, editing and visibility. Create it with {@link ColumnDef} – `new ColumnDef(property, label, width, classes)`
+ * or {@link ColumnDef.create} with named parameters.
+ *
+ * Column indices (e.g. in {@link AreaModelIf.getValueAt}) are positions in the `columnDefs` array –
+ * fixed columns and hidden columns included.
+ *
+ * @example
+ * const columnDefs: ColumnDefIf[] = [
+ *   new ColumnDef("id", "ID", px80, allRight),
+ *   ColumnDef.create({
+ *     property: "total", headerLabel: "Total", width: px120,
+ *     headerClasses: ["ge-table-text-align-right"], bodyClasses: ["ge-table-text-align-right"],
+ *     sortable: TrueFn, sortState: "desc"
+ *   })
+ * ];
+ *
+ * @see Training: [Columns with ColumnDef](https://gui.expert/training/column-definitions/)
+ *
+ * @category Columns
  */
 export interface ColumnDefIf {
-    /**
-     * Represents a property name of the table row element.
-     * @typedef {String} VariableProperty
-     */
+    /** Property of the row object shown in this column (`"customer"`). With nested objects a path like `"address.city"`. */
     property: string;
-    /**
-     * Represents the label for a header.
-     *
-     * @typedef {string} headerLabel
-     */
+    /** Text of the header cell (used when the header is built from the column definitions). */
     headerLabel: string;
-    /**
-     * Represents the size of a column along the width dimension.
-     *
-     * @typedef {number} Width
-     */
+    /** Width of the column: `px120`, `new Size(10, "%")` or `new Size(1, "weight")`. See {@link SizeUnitType}. */
     width: SizeIf;
-    /**
-     * Represents the minimum width of a column.
-     *
-     * @typedef {SizeIf} minWidth
-     * @property {number} width - The minimum width value.
-     * @property {string} unit - The unit of measurement for the minimum width value.
-     *                           Default value is 'px' if not specified.
-     */
+    /** Lower limit for percentage widths (`"%"`). Not applied to pixel widths or to resizing with the mouse. */
     minWidth: SizeIf;
-    /**
-     * Represents the maximum width of a column.
-     *
-     * @typedef {number} SizeIf
-     */
+    /** Upper limit for percentage widths (`"%"`). Not applied to pixel widths or to resizing with the mouse. */
     maxWidth: SizeIf;
     /**
-     * @typedef {Object} AreaObjectMapType
-     * @template T
-     * @property {Object.<string, T>} map - A mapping of strings to values of type T
+     * Cell renderers per area – `rendererMap.header`, `.body`, `.footer`.
+     * Without a renderer the value is shown as text.
+     *
+     * @example
+     * column.rendererMap.body = new NumberCellProgressBarCellRenderer(20, false);
+     * column.rendererMap.footer = new EuroRenderer();     // an own CellRendererIf
+     *
+     * @see Training: [Cell renderers](https://gui.expert/training/cell-renderers/)
      */
     rendererMap: AreaObjectMapType<CellRendererIf>;
     /**
-     * Represents an object that maps an area to a collection of objects.
-     *
-     * @typedef {Object.<string, string[]>} AreaObjectMapType
+     * CSS classes per area – `classes.header`, `.body`, `.footer`. The constants {@link bodyLeft}, {@link allRight} …
+     * are ready-made maps for the alignment.
      */
     classes: AreaObjectMapType<string[]>;
-    /**
-     * Determines whether or not a column can be sorted.
-     *
-     * @param {boolean} sortable - Specifies if an item is sortable.
-     * @returns {boolean} - Indicating whether the item is sortable or not.
-     */
+    /** The column can be sorted by a double-click on its header (e.g. `TrueFn`). */
     sortable?: BooleanFunction;
-    /**
-     * Determines if the sort icon is visible.
-     *
-     * @typedef {BooleanFunction} sortIconVisible
-     * @returns {boolean} Indicates whether the sort icon is visible.
-     */
+    /** Show the sort icon in the header. Default: follows `sortable` resp. `sortState`. */
     sortIconVisible?: BooleanFunction;
     /**
-     * Represents a function that compares two values for sorting purposes.
-     * The function takes two values and optionally their corresponding row objects,
-     * compares them, and returns a number.
-     * If the result is negative, it means 'valueA' comes before 'valueB' in the sorted order.
-     * If the result is positive, it means 'valueB' comes before 'valueA' in the sorted order.
-     * If the result is zero, it means the two values are considered equal for sorting purposes.
+     * Own comparison of two cell values (and their rows), like for `Array.prototype.sort`.
      *
-     * @see ValueRowSortComparator
+     * @example
+     * sortComparator: (a: string, b: string) => a.localeCompare(b, "de")     // "Müller" before "Nordlicht"
+     *
+     * @see Training: [Sorting](https://gui.expert/training/sorting/)
      */
     sortComparator?: ValueRowSortComparator;
     /**
-     * Represents the state of sorting for a list.
-     *
-     * @typedef {Object} SortState
-     *
-     * @property {string} [sortKey] - The key to sort the list by. If not provided, no sorting will be applied.
-     * @property {boolean} [reverse] - Indicates whether the list should be sorted in reverse order. Defaults to false.
+     * The sort icon shown in the header: `"asc"`, `"desc"` or `""` (none). It only sets the icon –
+     * sort the rows once with {@link TableModelIf.doSort} to match it.
      */
     sortState?: SortState;
-    /**
-     * Represents the order of multiple sort states.
-     *
-     * @typedef {SortState[]} SortStatesOrder
-     */
+    /** Order of the sort states on repeated double-clicks. Default: `TableOptions.sortOrder` (`["asc", "desc"]`). */
     sortStatesOrder?: SortState[];
     /**
-     * Determines if a column is editable or not.
+     * The cells of this column can be edited (double-click or F2), e.g. `TrueFn`.
      *
-     * @param {any} variable - The variable to check.
-     * @returns {boolean} - Returns true if the variable is editable, false otherwise.
+     * @see Training: [Inline editing](https://gui.expert/training/inline-editing/)
      */
     editable?: BooleanFunction;
     /**
-     * Determines if the column is visible or not.
+     * Whether the column is shown. Hidden columns are not rendered, copied or exported.
      *
-     * @typedef {Function} isVisible
-     * @returns {boolean} - If the element is visible, returns true. Otherwise, returns false.
+     * @example
+     * ColumnDef.create({ property: "category", headerLabel: "Category", isVisible: FalseFn })
      */
     isVisible?: BooleanFunction;
     /**
-     * Retrieves the edit renderer for the column.
+     * The editor of this column. Default: `TableOptions.getEditRenderer` (a text input, {@link InputCellRenderer}).
      *
-     * @name getEditRenderer
-     * @function
-     * @param {HTMLElement} element - The element for which to retrieve the edit renderer.
-     * @returns {EditRenderer | null} - The edit renderer for the specified element, or null if not found.
+     * @example
+     * getEditRenderer: () => new SelectCellRenderer(["open", "paid"].map(s => new ValueLabel(s, s)))
      */
     getEditRenderer?: GetEditRenderer;
-    /**
-     * Represents an edit input pipe.
-     *
-     * @typedef {object} editInputPipe
-     * @property {string} name - The name of the edit input pipe.
-     * @property {number} id - The unique identifier of the edit input pipe.
-     * @property {boolean} isActive - Indicates whether the edit input pipe is active.
-     * @property {function} execute - Executes the edit input pipe operation.
-     * @property {function} addFilter - Adds a filter to the edit input pipe.
-     * @property {function} removeFilter - Removes a filter from the edit input pipe.
-     * @property {function} clearFilters - Clears all filters from the edit input pipe.
-     * @property {function} setPriority - Sets the priority of the edit input pipe.
-     * @property {function} getStatus - Retrieves the current status of the edit input pipe.
-     */
+    /** Converts the text of the editor before it is written into the model, e.g. {@link editInputPipeForNumber}. */
     editInputPipe?: editInputPipe;
 }

package/lib/table/data/tablemodel/column/column-visibility.d.ts

@@ -0,0 +1,11 @@
+import { ColumnDefIf } from './column-def.if.js';
+
+/** Sets the API visibility of a column and rebuilds its `isVisible`. */
+export declare function setApiColumnVisibility(columnDef: ColumnDefIf, visible: boolean): void;
+/** Sets the header group visibility of a column and rebuilds its `isVisible`. */
+export declare function setGroupColumnVisibility(columnDef: ColumnDefIf, isVisible: (() => boolean) | undefined): void;
+/**
+ * Whether the column is shown apart from a collapsed header group: hidden with `setColumnVisible(…, false)` or by its
+ * own `isVisible` (e.g. `FalseFn` in the code) → false.
+ */
+export declare function isApiColumnVisible(columnDef: ColumnDefIf): boolean;

package/lib/table/data/tablemodel/cover-grid-table-model.d.ts

@@ -1,14 +1,15 @@
-import { CoverGridBodyModel } from './areamodel/cover-grid-body-model';
-import { AreaModelIf } from './areamodel/area-model.if';
-import { FilterFunction } from '../common/filter-function';
-import { SortItem } from '../common/sort-item';
-import { AreaIdent } from './area-ident.type';
-import { TableModelIf } from './table-model.if';
-import { TableScope } from '../../table-scope';
-import { ColumnDefIf } from './column/column-def.if';
-import { Padding } from './padding';
-import { SelectionModelIf } from '../../selection/selection-model.if';
+import { CoverGridBodyModel } from './areamodel/cover-grid-body-model.js';
+import { AreaModelIf } from './areamodel/area-model.if.js';
+import { FilterFunction } from '../common/filter-function.js';
+import { SortItem } from '../common/sort-item.js';
+import { AreaIdent } from './area-ident.type.js';
+import { TableModelIf } from './table-model.if.js';
+import { TableScope } from '../../table-scope.js';
+import { ColumnDefIf } from './column/column-def.if.js';
+import { Padding } from './padding.js';
+import { SelectionModelIf } from '../../selection/selection-model.if.js';
 
+/** @category Table model */
 export declare class CoverGridTableModel<T> implements TableModelIf {
     bodyModel: CoverGridBodyModel<T>;
     paddingTop: number;

package/lib/table/data/tablemodel/padding.d.ts

@@ -1,5 +1,7 @@
 /**
  * Represents padding values for the top, right, bottom, and left sides of an element.
+ *
+ * @category Table model
  */
 export declare class Padding {
     top: number;

package/lib/table/data/tablemodel/table-model.d.ts

@@ -1,15 +1,15 @@
-import { TableModelIf } from './table-model.if';
-import { Padding } from './padding';
-import { AreaIdent } from './area-ident.type';
-import { AreaModelIf } from './areamodel/area-model.if';
-import { SideIdent } from '../side-ident.type';
-import { DefaultRowHeightsIf } from '../options/default-row-heights.if';
-import { ColumnDefIf } from './column/column-def.if';
-import { FilterFunction } from '../common/filter-function';
-import { SortItem } from '../common/sort-item';
-import { SelectionModelIf } from '../../selection/selection-model.if';
-import { GetT } from '../common/get-t';
-import { TableScope } from '../../table-scope';
+import { TableModelIf } from './table-model.if.js';
+import { Padding } from './padding.js';
+import { AreaIdent } from './area-ident.type.js';
+import { AreaModelIf } from './areamodel/area-model.if.js';
+import { SideIdent } from '../side-ident.type.js';
+import { DefaultRowHeightsIf } from '../options/default-row-heights.if.js';
+import { ColumnDefIf } from './column/column-def.if.js';
+import { FilterFunction } from '../common/filter-function.js';
+import { SortItem } from '../common/sort-item.js';
+import { SelectionModelIf } from '../../selection/selection-model.if.js';
+import { GetT } from '../common/get-t.js';
+import { TableScope } from '../../table-scope.js';
 
 /**
  * This is a default implementation of TableModelIf.
@@ -30,6 +30,8 @@ import { TableScope } from '../../table-scope';
  *  |  footer/west   |  footer/center    | footer/east  |
  *  +----------------+-------------------+--------------+ </pre>
  *
+ *
+ * @category Table model
  */
 export declare class TableModel implements TableModelIf {
     readonly headerAreaModel: AreaModelIf;
@@ -50,6 +52,10 @@ export declare class TableModel implements TableModelIf {
     protected contentWidthInPx: number;
     protected padding: Padding;
     protected xPositions: number[];
+    /** false: the header is hidden (height 0), see {@link setHeaderVisible}. */
+    protected headerVisible: boolean;
+    /** false: the footer is hidden (height 0), see {@link setFooterVisible}. */
+    protected footerVisible: boolean;
     constructor(headerAreaModel: AreaModelIf, bodyAreaModel: AreaModelIf, footerAreaModel: AreaModelIf, fixedLeftColumnCount?: number, fixedRightColumnCount?: number, rowCheckboxVisible?: boolean, defaultRowHeights?: DefaultRowHeightsIf, columnDefs?: ColumnDefIf[], columnSizes?: number[], overridingColumnWidth?: number, columnCount?: number, parentSize?: number, // can be important when we have percentage widths,
     getSelectionModel?: GetT<SelectionModelIf>);
     init(): void;
@@ -62,6 +68,8 @@ export declare class TableModel implements TableModelIf {
     getColumnCount(): number;
     /**
      * Sets the width in pixel of a column (by columnIndex) in a table.
+     * The width is also stored in the column's ColumnDef (`width` = the new px size), so it survives a host resize
+     * (the widths are recalculated from the ColumnDefs then).
      *
      * @param {number} columnIndex - The index of the column.
      * @param {number} width - The desired width of the column.
@@ -201,16 +209,67 @@ export declare class TableModel implements TableModelIf {
      */
     getBodyModel(): AreaModelIf;
     /**
-     * Checks if the footer is visible.
+     * Checks if the footer is visible: it has rows and is not hidden with {@link setFooterVisible}.
      *
      * @returns {boolean} True if the footer is visible, false otherwise.
      */
     isFooterVisibe(): boolean;
     /**
-     * Checks if the header area is visible.
+     * Checks if the header area is visible: it has rows and is not hidden with {@link setHeaderVisible}.
      * @return {boolean} Returns true if the header area is visible, otherwise false.
      */
     isHeaderVisibe(): boolean;
+    /**
+     * Shows or hides the header. A hidden header takes no space (the body moves up); its area model and rows stay
+     * unchanged, so showing it again restores it. Only changes the model – {@link TableApi.setHeaderVisible} also
+     * repaints the table.
+     *
+     * @param {boolean} visible - false hides the header
+     *
+     * @example
+     * tableModel.setHeaderVisible?.(false);
+     */
+    setHeaderVisible(visible: boolean): void;
+    /**
+     * Shows or hides the footer. A hidden footer takes no space; its area model and rows stay unchanged.
+     * Only changes the model – {@link TableApi.setFooterVisible} also repaints the table.
+     *
+     * @param {boolean} visible - false hides the footer
+     *
+     * @example
+     * tableModel.setFooterVisible?.(false);
+     */
+    setFooterVisible(visible: boolean): void;
+    /**
+     * Shows or hides a column. The column keeps its definition, position and width – a hidden column has the width 0
+     * ({@link getColumnWidth}), is not rendered, copied or exported; showing it again restores its width.
+     *
+     * Works through {@link ColumnDefIf.isVisible}: it is replaced by {@link TrueFn} / {@link FalseFn} (an own
+     * `isVisible` function of the column is replaced, too). Columns without a column definition can't be hidden.
+     * With header groups ({@link AreaModelCellGroups}) the column is shown only if neither this method nor a collapsed
+     * group hides it – expanding the group does not bring back a column hidden here, and vice versa.
+     * Weight widths (`new Size(1, "weight")`) are shared among the shown columns.
+     * Recalculates the content width, the padding (fixed columns) and the x positions. Only changes the model –
+     * {@link TableApi.setColumnVisible} also repaints the table.
+     *
+     * @param {number | string | ColumnDefIf} column - column index (fixed columns included), property or column definition
+     * @param {boolean} visible - false hides the column
+     * @returns {boolean} false if there is no such column definition
+     *
+     * @example
+     * tableModel.setColumnVisible?.("category", false);
+     */
+    setColumnVisible(column: number | string | ColumnDefIf, visible: boolean): boolean;
+    /**
+     * Whether a column is shown ({@link ColumnDefIf.isVisible}). Columns without a column definition are always shown.
+     *
+     * @param {number | string | ColumnDefIf} column - column index, property or column definition
+     * @returns {boolean} false for hidden and for unknown columns
+     *
+     * @example
+     * const hidden = tableModel.isColumnVisible?.("category") === false;
+     */
+    isColumnVisible(column: number | string | ColumnDefIf): boolean;
     /**
      * Checks whether the row checkbox is visible.
      *
@@ -281,6 +340,8 @@ export declare class TableModel implements TableModelIf {
      * @return {number} - The converted size value in pixels. returns -1 if unit is not '%' or 'px'.
      */
     private sizeToPixel;
+    /** The column definition for a column index, a property or a column definition of this model. */
+    private findColumnDef;
     private arrayMove;
     private recalcContentWidthInPx;
     private calcXPositions;

package/lib/table/data/tablemodel/table-model.if.d.ts

@@ -1,11 +1,11 @@
-import { Padding } from './padding';
-import { AreaIdent } from './area-ident.type';
-import { ColumnDefIf } from './column/column-def.if';
-import { AreaModelIf } from './areamodel/area-model.if';
-import { FilterFunction } from '../common/filter-function';
-import { SortItem } from '../common/sort-item';
-import { SelectionModelIf } from '../../selection/selection-model.if';
-import { TableScope } from '../../table-scope';
+import { Padding } from './padding.js';
+import { AreaIdent } from './area-ident.type.js';
+import { ColumnDefIf } from './column/column-def.if.js';
+import { AreaModelIf } from './areamodel/area-model.if.js';
+import { FilterFunction } from '../common/filter-function.js';
+import { SortItem } from '../common/sort-item.js';
+import { SelectionModelIf } from '../../selection/selection-model.if.js';
+import { TableScope } from '../../table-scope.js';
 
 /**
  * The TableModelIf is on one hand a container for the header, body, and footer models
@@ -24,6 +24,8 @@ import { TableScope } from '../../table-scope';
  *  |  footer/west   |  footer/center    | footer/east  |
  *  +----------------+-------------------+--------------+</pre>
  *
+ *
+ * @category Table model
  */
 export interface TableModelIf {
     /**
@@ -111,6 +113,48 @@ export interface TableModelIf {
      * @returns {boolean} Returns true if the footer is visible, otherwise returns false.
      */
     isFooterVisibe(): boolean;
+    /**
+     * Optional: shows or hides the header (height 0, the rows stay in the model). Implemented by {@link TableModel};
+     * {@link TableApi.setHeaderVisible} uses it and repaints.
+     *
+     * @param {boolean} visible - false hides the header
+     *
+     * @example
+     * tableModel.setHeaderVisible?.(false);
+     */
+    setHeaderVisible?(visible: boolean): void;
+    /**
+     * Optional: shows or hides the footer (height 0, the rows stay in the model). Implemented by {@link TableModel};
+     * {@link TableApi.setFooterVisible} uses it and repaints.
+     *
+     * @param {boolean} visible - false hides the footer
+     *
+     * @example
+     * tableModel.setFooterVisible?.(false);
+     */
+    setFooterVisible?(visible: boolean): void;
+    /**
+     * Optional: shows or hides a column (width 0, definition, position and width are kept). Implemented by
+     * {@link TableModel}; {@link TableApi.setColumnVisible} uses it and repaints.
+     *
+     * @param {number | string | ColumnDefIf} column - column index, property or column definition
+     * @param {boolean} visible - false hides the column
+     * @returns {boolean} false if there is no such column definition
+     *
+     * @example
+     * tableModel.setColumnVisible?.(3, false);
+     */
+    setColumnVisible?(column: number | string | ColumnDefIf, visible: boolean): boolean;
+    /**
+     * Optional: whether a column is shown. Implemented by {@link TableModel}.
+     *
+     * @param {number | string | ColumnDefIf} column - column index, property or column definition
+     * @returns {boolean} false for hidden and for unknown columns
+     *
+     * @example
+     * tableModel.isColumnVisible?.("category");
+     */
+    isColumnVisible?(column: number | string | ColumnDefIf): boolean;
     /**
      * Determines if the row checkbox is visible.
      *

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

@@ -1,12 +1,18 @@
-import { ConvenienceDomService } from './service/convenience-dom.service';
-import { DivScope } from './data/div-scope.type';
-import { TableModelIf } from './data/tablemodel/table-model.if';
-import { TableOptionsIf } from './data/options/table-options.if';
-import { GeoData } from './data/geo-data';
+import { ConvenienceDomService } from './service/convenience-dom.service.js';
+import { DivScope } from './data/div-scope.type.js';
+import { TableModelIf } from './data/tablemodel/table-model.if.js';
+import { TableOptionsIf } from './data/options/table-options.if.js';
+import { GeoData } from './data/geo-data.js';
+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';
 
 /**
  * Represents a store for HTML elements.
  * @class
+ *
+ * @category Internals
  */
 export declare class EleScope {
     readonly hostElement: HTMLDivElement;
@@ -43,7 +49,49 @@ export declare class EleScope {
     protected areaBodyWestGeo: GeoData;
     protected areaBodyCenterGeo: GeoData;
     protected areaBodyEastGeo: GeoData;
+    /** The IDs this table uses for ARIA references (prefix from the host id). @since 1.1.91 */
+    readonly ariaIds: AriaIds;
+    /** The overlay layer over the body ("Loading…", "No rows to show"). @since 1.1.92 */
+    readonly tableOverlay: TableOverlay;
     constructor(hostElement: HTMLDivElement, tableModel: TableModelIf, dom: ConvenienceDomService, tableOptions: TableOptionsIf);
+    /**
+     * Shows the overlay that fits the current state (requested by the API, or "no rows" for an empty body).
+     * Overwritten in {@link RenderScope}.
+     *
+     * @since 1.1.92
+     */
+    protected updateOverlay(): void;
+    /** The values of the host attributes before the table changed them (restored by {@link removeHostAria}). */
+    private readonly hostAttributesBefore;
+    /**
+     * Sets (or with `undefined` removes) an ARIA attribute of the host and remembers the app's own value the first
+     * time, so that {@link removeHostAria} can restore it (e.g. an `aria-label` the app set on an Angular host).
+     *
+     * @since 1.1.91
+     */
+    protected setHostAriaAttribute(key: string, value: string | undefined): void;
+    /**
+     * Gives an ARIA attribute of the host back the value it had before the table changed it (e.g. `aria-busy` after
+     * loading), or removes it if the host had none.
+     *
+     * @since 1.1.92
+     */
+    protected restoreHostAriaAttribute(key: string): void;
+    /**
+     * Removes the ARIA attributes the table has set on the host element (see {@link initHostAria}).
+     *
+     * @since 1.1.91
+     */
+    protected removeHostAria(): void;
+    /**
+     * Sets the static ARIA attributes of the host element: `role="grid"` (a tree body: `"treegrid"`) and its name
+     * and description from the table options. Counts and the active cell follow with every render pass.
+     *
+     * @since 1.1.91
+     */
+    protected initHostAria(): void;
+    /** The element that holds the rows of an area (`DivScope.child`). */
+    protected getAreaChild(area: AreaIdent, side: SideIdent): HTMLDivElement;
     /**
      * Adjusts the containers and rows of the table based on the current state.
      *

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

@@ -1,16 +1,24 @@
-import { GeModelChangeEvent } from './data/common/event/ge-model-change-event';
-import { GeMouseEvent } from './data/common/event/ge-mouse-event';
-import { GeScrollEvent } from './data/common/event/ge-scroll-event';
-import { EventListenerIf } from './event-listener.if';
-import { SelectionModelIf } from './selection/selection-model.if';
-import { FocusModelIf } from './focus/focus-model.if';
+import { GeModelChangeEvent } from './data/common/event/ge-model-change-event.js';
+import { GeMouseEvent } from './data/common/event/ge-mouse-event.js';
+import { GeScrollEvent } from './data/common/event/ge-scroll-event.js';
+import { EventListenerIf } from './event-listener.if.js';
+import { SelectionModelIf } from './selection/selection-model.if.js';
+import { FocusModelIf } from './focus/focus-model.if.js';
+import { GeStateChangeEvent } from './data/common/event/ge-state-change-event.js';
 
 /**
- * EventAdapter class implements the EventListenerIf interface.
- * It provides empty implementations for all the event listener methods.
+ * Empty implementation of {@link EventListenerIf} – extend it and override only the events you need.
  *
- * @class
- * @implements {EventListenerIf}
+ * @example
+ * class TreeEvents extends EventAdapter {
+ *   override onCheckboxChanged(rows: any[]): void {
+ *     console.log(`${rows.length} rows checked`);
+ *   }
+ * }
+ *
+ * @see Training: [Events and a context menu of your own](https://gui.expert/training/events-and-context-menu/)
+ *
+ * @category Events
  */
 export declare class EventAdapter implements EventListenerIf {
     onCheckboxChanged(_evt: any[]): void;
@@ -23,4 +31,6 @@ export declare class EventAdapter implements EventListenerIf {
     onScroll(_evt: GeScrollEvent): void;
     onSelectionChanged(_model: SelectionModelIf): void;
     onFocusChanged(_model: FocusModelIf): void;
+    /** @since 1.1.92 */
+    onStateChanged(_evt: GeStateChangeEvent): void;
 }

package/lib/table/event-checkbox-changed-handler.d.ts

@@ -1,5 +1,6 @@
-import { EventAdapter } from './event-adapter';
+import { EventAdapter } from './event-adapter.js';
 
+/** @category Events */
 export declare class EventCheckboxChangedHandler extends EventAdapter {
     private readonly onCheckboxChangedCallback;
     constructor(onCheckboxChangedCallback: (evt: any[]) => void);