@guiexpert/table 1.1.89 → 1.1.91

package/lib/table/aria/tree-aria-info.d.ts

@@ -0,0 +1,58 @@
+import { TreeRowIf } from '../data/common/tree-row-if.js';
+
+/**
+ * The part of {@link AreaModelTree} that {@link TreeAriaInfo} reads.
+ *
+ * @since 1.1.91
+ * @category Accessibility
+ */
+export interface TreeAriaModel {
+    getRowByIndex(rowIndex: number): TreeRowIf<unknown> | undefined;
+    getFilteredFlattenRows(): TreeRowIf<unknown>[];
+    getDisplayedRootRows(): TreeRowIf<unknown>[];
+    getDisplayedChildren(row: TreeRowIf<unknown>): TreeRowIf<unknown>[];
+    hasDisplayedChildren(row: TreeRowIf<unknown>): boolean;
+}
+/**
+ * The screen reader attributes of one tree row (`role="treegrid"`), see {@link TreeAriaInfo}.
+ *
+ * @since 1.1.91
+ * @category Accessibility
+ */
+export interface TreeAriaRowInfo {
+    /** `aria-level`: 1 for top-level rows. */
+    level: number;
+    /** `aria-setsize`: number of displayed siblings (including the row). */
+    setSize: number;
+    /** `aria-posinset`: 1-based position among the displayed siblings. */
+    posInSet: number;
+    /** `aria-expanded`: `true`/`false` for rows with displayed children, `undefined` for leaves. */
+    expanded?: boolean;
+}
+/**
+ * Computes `aria-level`, `aria-setsize`, `aria-posinset` and `aria-expanded` of the rows of a tree body
+ * ({@link AreaModelTree}). Sizes and positions count the **displayed** siblings, i.e. with an active filter only
+ * the matching ones. The positions of a group of siblings are computed once and cached until the displayed rows
+ * change (expand, collapse, filter, sort) – so the cost per rendered row is O(1), also with a million siblings.
+ *
+ * @example
+ * const info = new TreeAriaInfo();
+ * const attrs = info.get(tableModel.getBodyModel() as AreaModelTree<OrderNode>, 0);
+ * // → { level: 1, setSize: 3, posInSet: 1, expanded: true }
+ *
+ * @since 1.1.91
+ * @category Accessibility
+ */
+export declare class TreeAriaInfo {
+    private displayedRows?;
+    private positions;
+    private sizes;
+    /**
+     * The ARIA attributes of a displayed row.
+     *
+     * @param {TreeAriaModel} model - the tree body model (an {@link AreaModelTree})
+     * @param {number} rowIndex - index of the displayed row
+     * @returns {TreeAriaRowInfo | undefined} undefined if there is no such row
+     */
+    get(model: TreeAriaModel, rowIndex: number): TreeAriaRowInfo | undefined;
+}

package/lib/table/checkbox/all-rows-checkbox-model.d.ts

@@ -0,0 +1,31 @@
+import { CheckedType } from '../data/common/checked-type.js';
+import { AreaModelIf } from '../data/tablemodel/areamodel/area-model.if.js';
+import { CheckboxModelIf } from './checkbox-model.if.js';
+
+/**
+ * Checkbox model of the HEADER checkbox of a `CheckboxColumnDef`: it stands for all (filtered) rows of the body.
+ * - `isRowChecked()`: `"full"` if every body row is checked, `"semi"` if some are, `"none"` otherwise;
+ * - `checkRow(_, true)` checks all body rows, `checkRow(_, false)` unchecks all;
+ * - `getCheckedRows()` = the checked rows of the body (reported by `onCheckboxChanged`).
+ *
+ * Set by `TableModel` for a `CheckboxColumnDef` in column 0 (internal, not exported).
+ */
+export declare class AllRowsCheckboxModel<T> implements CheckboxModelIf<T> {
+    private readonly bodyAreaModel;
+    private cache?;
+    constructor(bodyAreaModel: AreaModelIf);
+    getCheckedRows(): T[];
+    setCheckedRows(rows: T[]): void;
+    addCheckedRows(rows: T[]): void;
+    checkRow(_row: T, check: boolean): void;
+    isRowChecked(_row: T): CheckedType;
+    /**
+     * Checks the given rows of the body in addition to the checked ones; an empty array unchecks all rows.
+     *
+     * @param {T[]} rows - the rows to check (`[]` = uncheck all)
+     */
+    checkAll(rows: T[]): void;
+    /** The displayed top-level tree rows (with a filter: the matching ones) – cheap, no walk over all rows. */
+    private getTopTreeRows;
+    private getBodyRows;
+}

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

@@ -1,6 +1,7 @@
-import { CheckedType } from '../data/common/checked-type';
-import { CheckboxModelIf } from './checkbox-model.if';
+import { CheckedType } from '../data/common/checked-type.js';
+import { CheckboxModelIf } from './checkbox-model.if.js';
 
+/** @category Tree & checkboxes */
 export declare class CheckboxModel<T> implements CheckboxModelIf<T> {
     protected checkedRows: Array<T>;
     getCheckedRows(): T[];

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

@@ -1,5 +1,6 @@
-import { CheckedType } from '../data/common/checked-type';
+import { CheckedType } from '../data/common/checked-type.js';
 
+/** @category Tree & checkboxes */
 export interface CheckboxModelIf<T> {
     getCheckedRows(): T[];
     setCheckedRows(value: T[]): void;

package/lib/table/checkbox/tree-checkbox-model.d.ts

@@ -1,18 +1,33 @@
-import { CheckedType } from '../data/common/checked-type';
-import { CheckboxModelIf } from './checkbox-model.if';
-import { TreeRowIf } from '../data/common/tree-row-if';
+import { CheckedType } from '../data/common/checked-type.js';
+import { CheckboxModelIf } from './checkbox-model.if.js';
+import { TreeRowIf } from '../data/common/tree-row-if.js';
 
+/** @category Tree & checkboxes */
 export declare class TreeCheckboxModel<T extends TreeRowIf<any>> implements CheckboxModelIf<T> {
     protected allRootNodes: T[];
     constructor(allRootNodes?: T[]);
     checkRow(row: T, sel: boolean): void;
-    checkAll(_arr: T[]): void;
+    /**
+     * Unchecks the given rows and all their descendants – despite its name, like {@link CheckboxModel.checkAll}
+     * (which clears all checked rows). The parents of the given rows are updated ("semi" or "none").
+     *
+     * @param arr - the rows to uncheck together with their descendants; default: the root nodes (whole tree)
+     *
+     * @example
+     * const checkboxModel = new TreeCheckboxModel(TreeFactory.buildTreeRows<OrderNode>(nodes));
+     * checkboxModel.checkAll(); // uncheck every row of the tree
+     */
+    checkAll(arr?: T[]): void;
     getCheckedRows(): T[];
     isRowChecked(row: T): CheckedType;
+    /** True if the descendants of `row` are partly checked (stops at the first checked + unchecked pair). */
+    private hasMixedDescendants;
+    private setCheckedRecursive;
     setCheckedRows(rows: T[]): void;
     addCheckedRows(rows: T[]): void;
     private autoCheckParent;
     private areAllChildrenChecked;
     private areAllChildrenUnchecked;
+    private uncheckRecursive;
     private addSelectedRecursive;
 }

package/lib/table/color/color-rgb.d.ts

@@ -1,5 +1,6 @@
-import { ColorRgbIf } from './color-rgb.if';
+import { ColorRgbIf } from './color-rgb.if.js';
 
+/** @category Styling */
 export declare class ColorRgb implements ColorRgbIf {
     r: number;
     g: number;

package/lib/table/color/color-rgb.if.d.ts

@@ -2,6 +2,8 @@
  * Represents a color in RGB format.
  *
  * @interface
+ *
+ * @category Styling
  */
 export interface ColorRgbIf {
     r: number;

package/lib/table/color/ge-css-color-util.d.ts

@@ -1,8 +1,31 @@
-import { TwoColorGradientArgIf } from './two-color-gradient-arg.if';
-import { ThreeColorGradientArgIf } from './three-color-gradient-arg.if';
+import { TwoColorGradientArgIf } from './two-color-gradient-arg.if.js';
+import { ThreeColorGradientArgIf } from './three-color-gradient-arg.if.js';
 
+/**
+ * Colour gradients for heatmaps and conditional formatting – returns CSS colours like `rgb(244, 114, 182)`.
+ *
+ * @example
+ * const gradient = new ThreeColorGradientArg(
+ *   0, new ColorRgb(255, 255, 255),        // min → white
+ *   50, new ColorRgb(244, 114, 182),       // middle → pink
+ *   100, new ColorRgb(79, 70, 229));       // max → indigo
+ *
+ * class HeatmapModel extends AreaModelArrayOfArrays<number> {
+ *   override getCustomStyleAt(rowIndex: number, columnIndex: number) {
+ *     const value = Number(this.getValueAt(rowIndex, columnIndex));
+ *     return { "background-color": GeCssColorUtil.getThreeColorGradientRGB(value, gradient) };
+ *   }
+ * }
+ *
+ * @see Training: [Heatmaps and conditional formatting](https://gui.expert/training/heatmap/)
+ *
+ * @category Styling
+ */
 export declare class GeCssColorUtil {
+    /** Maps `value` from the range [fromSource, toSource] linearly to [fromTarget, toTarget]. */
     static normalize(value: number, fromSource: number, toSource: number, fromTarget?: number, toTarget?: number): number;
+    /** The colour for `value` between `minColor` (at `minValue`) and `maxColor` (at `maxValue`). */
     static getTwoColorGradientRGB(value: number, para: TwoColorGradientArgIf): string;
+    /** The colour for `value` on a min → middle → max gradient (e.g. red → white → green for negative / positive). */
     static getThreeColorGradientRGB(value: number, para: ThreeColorGradientArgIf): string;
 }

package/lib/table/color/three-color-gradient-arg.d.ts

@@ -1,6 +1,7 @@
-import { ColorRgbIf } from './color-rgb.if';
-import { ThreeColorGradientArgIf } from './three-color-gradient-arg.if';
+import { ColorRgbIf } from './color-rgb.if.js';
+import { ThreeColorGradientArgIf } from './three-color-gradient-arg.if.js';
 
+/** @category Styling */
 export declare class ThreeColorGradientArg implements ThreeColorGradientArgIf {
     minValue: number;
     minColor: ColorRgbIf;

package/lib/table/color/three-color-gradient-arg.if.d.ts

@@ -1,9 +1,11 @@
-import { ColorRgbIf } from './color-rgb.if';
+import { ColorRgbIf } from './color-rgb.if.js';
 
 /**
  * Interface for defining the arguments of a three-color gradient.
  *
  * @interface
+ *
+ * @category Styling
  */
 export interface ThreeColorGradientArgIf {
     minValue: number;

package/lib/table/color/two-color-gradient-arg.d.ts

@@ -1,6 +1,7 @@
-import { ColorRgbIf } from './color-rgb.if';
-import { TwoColorGradientArgIf } from './two-color-gradient-arg.if';
+import { ColorRgbIf } from './color-rgb.if.js';
+import { TwoColorGradientArgIf } from './two-color-gradient-arg.if.js';
 
+/** @category Styling */
 export declare class TwoColorGradientArg implements TwoColorGradientArgIf {
     minValue: number;
     minColor: ColorRgbIf;

package/lib/table/color/two-color-gradient-arg.if.d.ts

@@ -1,8 +1,10 @@
-import { ColorRgbIf } from './color-rgb.if';
+import { ColorRgbIf } from './color-rgb.if.js';
 
 /**
  * Interface representing arguments for a two-color gradient.
  * @interface
+ *
+ * @category Styling
  */
 export interface TwoColorGradientArgIf {
     minValue: number;

package/lib/table/crud/column-widths.d.ts

@@ -1,5 +1,6 @@
-import { ColumnWidthsIf } from './column-widths.if';
+import { ColumnWidthsIf } from './column-widths.if.js';
 
+/** @category CRUD */
 export declare class ColumnWidths implements ColumnWidthsIf {
     autoCalc: boolean;
     takeHeaderLabelsIntoAccount: boolean;

package/lib/table/crud/column-widths.if.d.ts

@@ -1,3 +1,4 @@
+/** @category CRUD */
 export interface ColumnWidthsIf {
     autoCalc: boolean;
     takeHeaderLabelsIntoAccount: boolean;

package/lib/table/crud/crud-action.d.ts

@@ -1,3 +1,4 @@
+/** @category CRUD */
 export declare class CrudAction {
     action: string;
     label: string;

package/lib/table/crud/crud-object-edit.d.ts

@@ -1,11 +1,33 @@
+/**
+ * Edit dialog (`<dialog>` with one form) for an object: one input per property, nested objects flattened
+ * (`address.city`), the id property (`idKey`) is not editable.
+ *
+ * - Works on a deep copy – the object passed in is not changed.
+ * - Values keep their type: numbers stay numbers (an empty number field becomes `null`), booleans are checkboxes
+ *   (unchecking saves `false`), `null`/`undefined` stay as they are while their text field is left empty.
+ * - Labels and values are escaped – data is shown as text, never as markup.
+ * - Save calls `onSave(editedCopy)`; Save, Cancel and Escape close and remove the dialog.
+ *
+ * @example
+ * new CrudObjectEdit('id', { id: 7, name: 'Ada', age: 36, vip: true }, 'Edit customer')
+ *   .openDialog(updated => console.info(updated)); // { id: 7, name: '…', age: 37, vip: false }
+ *
+ * @category CRUD
+ */
 export declare class CrudObjectEdit<T extends Record<string, any>> {
     private idKey;
     dialogTitle: string;
     private object;
+    /** Property path of every input (index = `data-field-index`) – a key may contain a dot itself. */
+    private fieldPaths;
     constructor(idKey: keyof T, obj: T, dialogTitle?: string);
     openDialog(onSave: (updatedObject: T) => void): void;
-    private generateForm;
+    /** The input fields for all properties of `obj` (recursive for nested objects – no nested `<form>`). */
+    private generateFields;
+    /** The value of an input, in the type of the original value. */
+    private readInput;
+    private getNestedValue;
     private setNestedValue;
-    private getCombinedKey;
-    private getLabel;
+    /** A deep copy (structuredClone; JSON as fallback for objects that cannot be cloned, e.g. with functions). */
+    private static deepCopy;
 }

package/lib/table/crud/crud-object-view.d.ts

@@ -1,3 +1,9 @@
+/**
+ * Read-only dialog (`<dialog>`) that lists all properties of an object (nested objects flattened). Labels and values
+ * are escaped – data is shown as text, never as markup.
+ *
+ * @category CRUD
+ */
 export declare class CrudObjectView<T extends Record<string, any>> {
     private object;
     constructor(obj: T);

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

@@ -1,8 +1,37 @@
-import { CrudOptionsIf } from './crud-options.if';
-import { UrlsIf } from './urls.if';
-import { CrudAction } from './crud-action';
-import { ColumnWidthsIf } from './column-widths.if';
+import { CrudOptionsIf } from './crud-options.if.js';
+import { UrlsIf } from './urls.if.js';
+import { CrudAction } from './crud-action.js';
+import { ColumnWidthsIf } from './column-widths.if.js';
 
+/**
+ * Settings and REST calls of a CRUD table ({@link CrudTableModelFactory}).
+ *
+ * The default REST calls use `fetch`:
+ * - `{id}` in a URL is replaced by the URL-encoded id (`/api/items/{id}` → `/api/items/a%2Fb`);
+ * - requests with a body (`updateItem`, `createItem`) send JSON with `Content-Type: application/json`
+ *   (unless `getHeadersInit()` already sets a `Content-Type`);
+ * - the promise is rejected for an HTTP error status (4xx/5xx) and when no URL is configured;
+ *   an empty response body (e.g. `204 No Content`) resolves with `undefined`.
+ *
+ * Every call can be replaced, e.g. to use your own HTTP client.
+ *
+ * @example
+ * const crudOptions: CrudOptions = {
+ *   ...new CrudOptions(),
+ *   urls: {
+ *     list: new UrlInfo('GET', '/api/customers'),
+ *     read: new UrlInfo('GET', '/api/customers/{id}'),
+ *     update: new UrlInfo('PUT', '/api/customers/{id}'),
+ *     create: new UrlInfo('POST', '/api/customers'),
+ *     delete: new UrlInfo('DELETE', '/api/customers/{id}'),
+ *   },
+ *   getHeadersInit: () => ({ Authorization: 'Bearer my-token' }),
+ *   getIdKey: () => 'customerId',
+ *   getEmptyItem: () => ({ name: '', vip: false, credit: 0 }),
+ * };
+ *
+ * @category CRUD
+ */
 export declare class CrudOptions implements CrudOptionsIf {
     urls: UrlsIf;
     singleRowActions: CrudAction[];
@@ -11,7 +40,9 @@ export declare class CrudOptions implements CrudOptionsIf {
     columnWidths: ColumnWidthsIf;
     calcFixedRightColumnCount: (columnCount: number) => number;
     getHeadersInit: (() => HeadersInit);
+    /** The property that holds the id of an item (default `'id'`). */
     getIdKey: () => string;
+    /** The id of an item: the value of its `getIdKey()` property (`undefined` if it has none). */
     getIdByObject: <T extends Record<string, unknown>>(o: T) => any;
     fetchList: <T>(crudOptions: CrudOptionsIf) => Promise<T[]>;
     fetchItem: <T>(crudOptions: CrudOptionsIf, id: any) => Promise<T>;

package/lib/table/crud/crud-options.if.d.ts

@@ -1,6 +1,7 @@
-import { UrlsIf } from './urls.if';
-import { CrudAction } from './crud-action';
+import { UrlsIf } from './urls.if.js';
+import { CrudAction } from './crud-action.js';
 
+/** @category CRUD */
 export interface CrudOptionsIf {
     getHeadersInit?: () => HeadersInit;
     urls: UrlsIf;

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

@@ -1,12 +1,42 @@
-import { CrudOptions } from './crud-options';
-import { CreateTableModelPara } from '../factory/table-factory';
-import { TableModelAndOptionsIf } from '../data/table-model-and-options.if';
-import { ActionEventListenerIf } from '../renderer/action/action-event-listener.if';
-import { ActionEventIf } from '../renderer/action/action-event.if';
-import { TableModelIf } from '../data/tablemodel/table-model.if';
-import { TableOptionsIf } from '../data/options/table-options.if';
-import { AreaModelObjectArrayWithColumndefs } from '../data/tablemodel/areamodel/area-model-object-array-with-columndefs';
+import { CrudOptions } from './crud-options.js';
+import { CreateTableModelPara } from '../factory/table-factory.js';
+import { TableModelAndOptionsIf } from '../data/table-model-and-options.if.js';
+import { ActionEventListenerIf } from '../renderer/action/action-event-listener.if.js';
+import { ActionEventIf } from '../renderer/action/action-event.if.js';
+import { TableModelIf } from '../data/tablemodel/table-model.if.js';
+import { TableOptionsIf } from '../data/options/table-options.if.js';
+import { AreaModelObjectArrayWithColumndefs } from '../data/tablemodel/areamodel/area-model-object-array-with-columndefs.js';
 
+/**
+ * Builds a table for a REST resource: loads the list (`crudOptions.fetchList`), derives the columns from the first item
+ * (nested objects flattened, e.g. `address.city`) and adds an "Actions" column (View / Edit / Clone / Delete) whose
+ * links open the CRUD dialogs ({@link CrudTableModelFactory.onActionEvent}). The table shows the result of a save or
+ * delete without reloading the list.
+ *
+ * @example
+ * const factory = new CrudTableModelFactory();
+ * factory.createTableModel(
+ *   {
+ *     ...new CrudOptions(),
+ *     urls: {
+ *       list: new UrlInfo('GET', '/api/customers'),
+ *       read: new UrlInfo('GET', '/api/customers/{id}'),
+ *       update: new UrlInfo('PUT', '/api/customers/{id}'),
+ *       create: new UrlInfo('POST', '/api/customers'),
+ *       delete: new UrlInfo('DELETE', '/api/customers/{id}'),
+ *     },
+ *     getEmptyItem: () => ({ name: '', vip: false }),
+ *   },
+ *   {},
+ *   ({ tableModel, tableOptions }) => {
+ *     const tableScope = new TableScope(hostDiv, tableModel, new SimpleDomService(), tableOptions, new EventAdapter());
+ *     tableScope.firstInit();
+ *   }
+ * );
+ * document.querySelector('#create')!.addEventListener('click', () => factory.openDialogForCreate());
+ *
+ * @category CRUD
+ */
 export declare class CrudTableModelFactory implements ActionEventListenerIf {
     tableModel: TableModelIf | undefined;
     bodyModel: AreaModelObjectArrayWithColumndefs<any> | undefined;
@@ -15,7 +45,33 @@ export declare class CrudTableModelFactory implements ActionEventListenerIf {
     listenActionEvent: (actionEvent: ActionEventIf) => void;
     createTableModel<T>(crudOptions: CrudOptions, p: Partial<CreateTableModelPara>, callback?: (tableModelAndOptions: TableModelAndOptionsIf) => void, listenActionEvent?: (actionEvent: ActionEventIf) => void): void;
     openDialogForCreate(): void;
+    /**
+     * Handles the actions of the action column (and `CREATE`): the listener of {@link createTableModel} is called first,
+     * then
+     * - `VIEW`: `fetchItem` → {@link CrudObjectView};
+     * - `EDIT`: `fetchItem` → {@link CrudObjectEdit} → Save: `updateItem(id, item)`, the row shows the saved values
+     *   (the response, if it is an item with id – otherwise the edited item);
+     * - `CLONE` / `CREATE`: `fetchItem` resp. `getEmptyItem()` → {@link CrudObjectEdit} → Save: `createItem(item)` – without
+     *   the id property, the server assigns it. If the response is an item with id, it is added as last row, otherwise the
+     *   list is loaded again (`fetchList`);
+     * - `DELETE`: `deleteItem(id)` → the row is removed.
+     *
+     * A failed request is logged with `console.error`; the table stays unchanged.
+     */
     onActionEvent(actionEvent: ActionEventIf): void;
+    /** `createItem` without the id property (the server assigns it), then shows the new row. */
+    private createItem;
+    /** Copies the saved values into the row with the given id (rows, filter and sort order stay as they are). */
+    private updateRow;
+    /** Appends a new row (shown as last row, also with an active filter or sort order). */
+    private addRow;
+    /** Loads the list again (`fetchList`) – after a create whose response does not contain the new item. */
+    private reloadRows;
+    private getIdKey;
+    /** The action column carries the id as text (data-id) – compare as strings. */
+    private hasId;
+    private isItemWithId;
+    private logError;
     private calcAutoColumnWidths;
     private getValueByT;
     private getPropertyValue;

package/lib/table/crud/url-info.d.ts

@@ -1,5 +1,6 @@
-import { UrlInfoIf } from './url-info.if';
+import { UrlInfoIf } from './url-info.if.js';
 
+/** @category CRUD */
 export declare class UrlInfo implements UrlInfoIf {
     method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'PATCH';
     url: string;

package/lib/table/crud/url-info.if.d.ts

@@ -1,3 +1,4 @@
+/** @category CRUD */
 export interface UrlInfoIf {
     url: string;
     method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'PATCH';

package/lib/table/crud/urls.if.d.ts

@@ -1,5 +1,6 @@
-import { UrlInfoIf } from './url-info.if';
+import { UrlInfoIf } from './url-info.if.js';
 
+/** @category CRUD */
 export interface UrlsIf {
     list: UrlInfoIf;
     create?: UrlInfoIf;

package/lib/table/css-vars.d.ts

@@ -1,3 +1,4 @@
+/** @category Styling */
 export declare class CssVars {
     static readonly themes: string[];
     static readonly vars: {

package/lib/table/data/chunk/chunk.data-event.d.ts

@@ -1,6 +1,7 @@
-import { ChunkDataIf } from './chunk.data-event.if';
-import { RequestChunk } from './request-chunk';
+import { ChunkDataIf } from './chunk.data-event.if.js';
+import { RequestChunk } from './request-chunk.js';
 
+/** @category Utilities */
 export declare class ChunkData<T> extends RequestChunk implements ChunkDataIf<T> {
     rows: T[];
     constructor(emmitDataKey: string, emmitCancelKey: string, queryId: string, // which sql

package/lib/table/data/chunk/chunk.data-event.if.d.ts

@@ -1,5 +1,6 @@
-import { RequestChunkIf } from './request-chunk.if';
+import { RequestChunkIf } from './request-chunk.if.js';
 
+/** @category Utilities */
 export interface ChunkDataIf<T> extends RequestChunkIf {
     rows: T[];
 }

package/lib/table/data/chunk/request-chunk.d.ts

@@ -1,5 +1,6 @@
-import { RequestChunkIf } from './request-chunk.if';
+import { RequestChunkIf } from './request-chunk.if.js';
 
+/** @category Utilities */
 export declare class RequestChunk implements RequestChunkIf {
     emmitDataKey: string;
     emmitCancelKey: string;

package/lib/table/data/chunk/request-chunk.if.d.ts

@@ -1,3 +1,4 @@
+/** @category Utilities */
 export interface RequestChunkIf {
     emmitDataKey: string;
     emmitCancelKey: string;

package/lib/table/data/common/aligns.d.ts

@@ -1,9 +1,21 @@
+/**
+ * CSS classes for {@link ColumnDefIf.classes}: body cells left-aligned – `new ColumnDef("city", "City", px120, bodyLeft)`.
+ * @category Columns
+ */
 export declare const bodyLeft: {
     body: string[];
 };
+/**
+ * CSS classes for {@link ColumnDefIf.classes}: body cells centered – `new ColumnDef("city", "City", px120, bodyCenter)`.
+ * @category Columns
+ */
 export declare const bodyCenter: {
     body: string[];
 };
+/**
+ * CSS classes for {@link ColumnDefIf.classes}: body cells right-aligned – `new ColumnDef("city", "City", px120, bodyRight)`.
+ * @category Columns
+ */
 export declare const bodyRight: {
     body: string[];
 };
@@ -13,6 +25,8 @@ export declare const bodyRight: {
  * @property {Array.<string>} header - The CSS class(es) for aligning text to the left in the table header.
  * @property {Array.<string>} body - The CSS class(es) for aligning text to the left in the table body.
  * @property {Array.<string>} footer - The CSS class(es) for aligning text to the left in the table footer.
+ *
+ * @category Columns
  */
 export declare const allLeft: {
     header: string[];
@@ -26,6 +40,8 @@ export declare const allLeft: {
  * @property {Array.<string>} header - The alignment classes for the table header.
  * @property {Array.<string>} body - The alignment classes for the table body.
  * @property {Array.<string>} footer - The alignment classes for the table footer.
+ *
+ * @category Columns
  */
 export declare const allCenter: {
     header: string[];
@@ -39,6 +55,8 @@ export declare const allCenter: {
  * @property {Array} header - An array containing CSS classes for aligning text right in the table header.
  * @property {Array} body - An array containing CSS classes for aligning text right in the table body.
  * @property {Array} footer - An array containing CSS classes for aligning text right in the table footer.
+ *
+ * @category Columns
  */
 export declare const allRight: {
     header: string[];

package/lib/table/data/common/area-map-factory.d.ts

@@ -1,6 +1,7 @@
-import { AreaObjectMap } from './area-map';
-import { CellRendererIf } from '../../renderer/cell-render.if';
+import { AreaObjectMap } from './area-map.js';
+import { CellRendererIf } from '../../renderer/cell-render.if.js';
 
+/** @category Columns */
 export declare class AreaMapFactory {
     /**
      * A factory that creates a new AreaObjectMap with the given body renderer.

package/lib/table/data/common/area-map.d.ts

@@ -1,4 +1,4 @@
-import { AreaObjectMapType } from './area-map.type';
+import { AreaObjectMapType } from './area-map.type.js';
 
 /**
  * An object map as container for all three areas.
@@ -6,6 +6,8 @@ import { AreaObjectMapType } from './area-map.type';
  * @template T - The type of objects stored in the map.
  * @class
  * @implements {AreaObjectMapType<T>}
+ *
+ * @category Columns
  */
 export declare class AreaObjectMap<T> implements AreaObjectMapType<T> {
     header?: T | undefined;

package/lib/table/data/common/area-map.type.d.ts

@@ -1,3 +1,4 @@
+/** @category Columns */
 export type AreaObjectMapType<T> = {
     header?: T | undefined;
     body?: T | undefined;

package/lib/table/data/common/args-adjust-columns-to-row-parent-params.d.ts

@@ -1,11 +1,13 @@
-import { AreaIdent } from '../tablemodel/area-ident.type';
-import { SideIdent } from '../side-ident.type';
-import { AreaModelIf } from '../tablemodel/areamodel/area-model.if';
-import { GeoData } from '../geo-data';
+import { AreaIdent } from '../tablemodel/area-ident.type.js';
+import { SideIdent } from '../side-ident.type.js';
+import { AreaModelIf } from '../tablemodel/areamodel/area-model.if.js';
+import { GeoData } from '../geo-data.js';
 
 /**
  * Represents the parameters required for adjusting columns to the row parent.
  * @interface ArgsAdjustColumnsToRowParentParams
+ *
+ * @category Internals
  */
 export interface ArgsAdjustColumnsToRowParentParams {
     areaIdent: AreaIdent;