@guiexpert/table 1.1.90 → 1.1.91

package/lib/table/data/common/args-render-cell-div.d.ts

@@ -1,6 +1,6 @@
-import { AreaModelIf } from '../tablemodel/areamodel/area-model.if';
-import { AreaIdent } from '../tablemodel/area-ident.type';
-import { SideIdent } from '../side-ident.type';
+import { AreaModelIf } from '../tablemodel/areamodel/area-model.if.js';
+import { AreaIdent } from '../tablemodel/area-ident.type.js';
+import { SideIdent } from '../side-ident.type.js';
 
 /**
  * Represents the arguments required to render a cell div.
@@ -17,6 +17,8 @@ import { SideIdent } from '../side-ident.type';
  * @property {number} top - The top position of the cell.
  * @property {HTMLDivElement} parent - The parent element of the cell.
  * @property {boolean} lastRowOfModel - Indicates if the cell is in the last row of the model.
+ *
+ * @category Internals
  */
 export interface ArgsRenderCellDiv {
     areaModel: AreaModelIf;

package/lib/table/data/common/boolean-function.d.ts

@@ -1,9 +1,17 @@
+/**
+ * A flag as function – e.g. {@link ColumnDefIf.sortable}, `editable`, `isVisible`. A function can depend on state:
+ * `isVisible: () => showDetails`. Constants: {@link TrueFn}, {@link FalseFn}.
+ *
+ * @category Columns
+ */
 export type BooleanFunction = () => boolean;
 /**
  * Represents a function that always returns true.
  *
  * @function
  * @returns {boolean} - Always returns true
+ *
+ * @category Columns
  */
 export declare const TrueFn: () => boolean;
 /**
@@ -11,5 +19,7 @@ export declare const TrueFn: () => boolean;
  *
  * @function
  * @returns {boolean} Always returns `false`.
+ *
+ * @category Columns
  */
 export declare const FalseFn: () => boolean;

package/lib/table/data/common/cell-range.d.ts

@@ -1,3 +1,14 @@
+/**
+ * A rectangle of cells: rows `r1`…`r2`, columns `c1`…`c2` (inclusive, body indices as displayed).
+ * {@link SelectionModelIf.getRanges} returns the selection as a list of them.
+ *
+ * @example
+ * const firstTenRows = new CellRange(0, 0, 9, tableModel.getColumnCount() - 1);
+ * tableApi.getSelectionModel()?.addSelection(firstTenRows);
+ * tableApi.repaint();
+ *
+ * @category Selection & focus
+ */
 export declare class CellRange {
     r1: number;
     c1: number;
@@ -5,13 +16,11 @@ export declare class CellRange {
     c2: number;
     gammaRange: boolean;
     /**
-     * Represents a constructor for a class.
-     * @constructor
-     * @param {number} r1 - The value for r1.
-     * @param {number} c1 - The value for c1.
-     * @param {number} r2 - The value for r2.
-     * @param {number} c2 - The value for c2.
-     * @param {boolean} [gammaRange=false] - The value for gammaRange. Defaults to false. gammaRange will be used for AreaModelCellGroups, but it's not implemented yet!
+     * @param r1 - first row
+     * @param c1 - first column
+     * @param r2 - last row (inclusive)
+     * @param c2 - last column (inclusive)
+     * @param gammaRange - reserved for {@link AreaModelCellGroups}, not used yet (default false)
      */
     constructor(r1: number, c1: number, r2: number, c2: number, gammaRange?: boolean);
     static create(params: {

package/lib/table/data/common/checkbox-column-def.d.ts

@@ -1,12 +1,14 @@
-import { SizeIf } from './size.if';
-import { ColumnDefIf } from '../tablemodel/column/column-def.if';
-import { CellRendererIf } from '../../renderer/cell-render.if';
-import { AreaObjectMapType } from './area-map.type';
+import { SizeIf } from './size.if.js';
+import { ColumnDefIf } from '../tablemodel/column/column-def.if.js';
+import { CellRendererIf } from '../../renderer/cell-render.if.js';
+import { AreaObjectMapType } from './area-map.type.js';
 
 /**
  * A pre-defined column definition for a checkbox representation.
  *
  * @implements {ColumnDefIf}
+ *
+ * @category Columns
  */
 export declare class CheckboxColumnDef implements ColumnDefIf {
     type: string;

package/lib/table/data/common/checked-type.d.ts

@@ -2,5 +2,7 @@
  * Represents a checked type.
  *
  * @typedef {'none' | 'semi' | 'full'} CheckedType
+ *
+ * @category Selection & focus
  */
 export type CheckedType = "none" | "semi" | "full";

package/lib/table/data/common/event/ge-cell-indices.d.ts

@@ -1,5 +1,7 @@
 /**
  * Represents the indices (position) of a cell in a table area.
+ *
+ * @category Events
  */
 export declare class GeCellIndices {
     rowIndex: number;

package/lib/table/data/common/event/ge-key-event.d.ts

@@ -2,6 +2,8 @@
  * Represents a keyboard event.
  *
  * @class GeKeyEvent
+ *
+ * @category Events
  */
 export declare class GeKeyEvent {
     status: "down" | "up";

package/lib/table/data/common/event/ge-model-change-event.d.ts

@@ -1,7 +1,21 @@
-import { GeCellIndices } from './ge-cell-indices';
+import { GeCellIndices } from './ge-cell-indices.js';
 
 /**
- * Indicates that changes have occurred in the given cells.
+ * Reported by {@link EventListenerIf.onModelChanged} after cells were edited: the row and column indices
+ * of the changed cells. The new values are already written into the area model.
+ *
+ * @example
+ * override onModelChanged(evt: GeModelChangeEvent): void {
+ *   for (const { rowIndex } of evt.cells) {
+ *     const order = tableModel.getBodyModel().getRowByIndex(rowIndex) as Order;
+ *     order.total = order.quantity * order.price;          // recalculate derived values
+ *   }
+ *   tableApi.repaint();
+ * }
+ *
+ * @see Training: [Inline editing](https://gui.expert/training/inline-editing/)
+ *
+ * @category Events
  */
 export declare class GeModelChangeEvent {
     cells: GeCellIndices[];

package/lib/table/data/common/event/ge-mouse-event.d.ts

@@ -1,21 +1,69 @@
-import { AreaIdent } from '../../tablemodel/area-ident.type';
-import { SideIdent } from '../../side-ident.type';
+import { AreaIdent } from '../../tablemodel/area-ident.type.js';
+import { SideIdent } from '../../side-ident.type.js';
 
 /**
- * Represents a mouse event in the table.
+ * A mouse event of the table: where it happened (area, side, row, column) plus the browser event.
+ * Passed to {@link EventListenerIf.onMouseClicked}, {@link EventListenerIf.onContextmenu} and the other mouse methods.
+ *
+ * `rowIndex` is the row as **displayed** (after filter and sorting) – get your object with
+ * `tableModel.getBodyModel().getRowByIndex(evt.rowIndex)`.
+ *
+ * @example
+ * override onContextmenu(evt: GeMouseEvent): void {
+ *   if (evt.areaIdent !== "body" || evt.rowIndex < 0) return;
+ *   evt.originalEvent?.preventDefault();                       // no browser menu
+ *   showMyMenu(evt.originalEvent!.clientX, evt.originalEvent!.clientY, evt.rowIndex);
+ * }
+ *
+ * @see Training: [Events and a context menu of your own](https://gui.expert/training/events-and-context-menu/)
+ *
+ * @category Events
  */
 export declare class GeMouseEvent {
+    /** Row index in the area (as displayed); -1 outside of rows. */
     rowIndex: number;
+    /** Top position of the row in px. */
     rowTop: number;
+    /** Column index (model index over west + center + east); -1 outside of columns. */
     columnIndex: number;
+    /** Left position of the column in px. */
     columnLeft: number;
+    /** `"header"`, `"body"` or `"footer"`. */
     areaIdent?: AreaIdent | undefined;
+    /** `"west"` (fixed left), `"center"` or `"east"` (fixed right). */
     sideIdent?: SideIdent | undefined;
+    /** The browser event – position, buttons, modifier keys. */
     originalEvent?: MouseEvent | undefined;
+    /** 1 = click, 2 = double-click on the same cell. */
     clickCount: number;
+    /** Horizontal distance in px while dragging. */
     draggingX: number;
+    /** Vertical distance in px while dragging. */
     draggingY: number;
+    /** Internal action of the clicked element (e.g. a tree arrow), otherwise empty. */
     action: string | null;
-    constructor(rowIndex?: number, rowTop?: number, columnIndex?: number, columnLeft?: number, areaIdent?: AreaIdent | undefined, sideIdent?: SideIdent | undefined, originalEvent?: MouseEvent | undefined, clickCount?: number, draggingX?: number, draggingY?: number, action?: string | null);
+    constructor(
+    /** Row index in the area (as displayed); -1 outside of rows. */
+    rowIndex?: number, 
+    /** Top position of the row in px. */
+    rowTop?: number, 
+    /** Column index (model index over west + center + east); -1 outside of columns. */
+    columnIndex?: number, 
+    /** Left position of the column in px. */
+    columnLeft?: number, 
+    /** `"header"`, `"body"` or `"footer"`. */
+    areaIdent?: AreaIdent | undefined, 
+    /** `"west"` (fixed left), `"center"` or `"east"` (fixed right). */
+    sideIdent?: SideIdent | undefined, 
+    /** The browser event – position, buttons, modifier keys. */
+    originalEvent?: MouseEvent | undefined, 
+    /** 1 = click, 2 = double-click on the same cell. */
+    clickCount?: number, 
+    /** Horizontal distance in px while dragging. */
+    draggingX?: number, 
+    /** Vertical distance in px while dragging. */
+    draggingY?: number, 
+    /** Internal action of the clicked element (e.g. a tree arrow), otherwise empty. */
+    action?: string | null);
     clone(): GeMouseEvent;
 }

package/lib/table/data/common/event/ge-scroll-event.d.ts

@@ -1,14 +1,40 @@
 /**
  * Scroll event containing position and size information.
+ *
+ * @category Events
  */
 export declare class GeScrollEvent {
+    /** Vertical scroll position of the viewport in px. */
     scrollTop: number;
+    /** Horizontal scroll position of the viewport in px. */
     scrollLeft: number;
+    /** Height of the whole (virtual) content in px. */
     scrollHeight: number;
+    /** Width of the whole content in px. */
     scrollWidth: number;
+    /** Visible height in px. */
     clientHeight: number;
+    /** Visible width in px. */
     clientWidth: number;
+    /** Vertical position as factor 0 (top) … 1 (bottom). */
     scrollFactorY: number;
+    /** Horizontal position as factor 0 (left) … 1 (right). */
     scrollFactorX: number;
-    constructor(scrollTop: number, scrollLeft: number, scrollHeight: number, scrollWidth: number, clientHeight: number, clientWidth: number, scrollFactorY: number, scrollFactorX: number);
+    constructor(
+    /** Vertical scroll position of the viewport in px. */
+    scrollTop: number, 
+    /** Horizontal scroll position of the viewport in px. */
+    scrollLeft: number, 
+    /** Height of the whole (virtual) content in px. */
+    scrollHeight: number, 
+    /** Width of the whole content in px. */
+    scrollWidth: number, 
+    /** Visible height in px. */
+    clientHeight: number, 
+    /** Visible width in px. */
+    clientWidth: number, 
+    /** Vertical position as factor 0 (top) … 1 (bottom). */
+    scrollFactorY: number, 
+    /** Horizontal position as factor 0 (left) … 1 (right). */
+    scrollFactorX: number);
 }

package/lib/table/data/common/event/input/table-cell-update-event.d.ts

@@ -1,17 +1,21 @@
-import { TableCellUpdateEventIf } from './table-cell-update-event.if';
-import { AreaIdent } from '../../../tablemodel/area-ident.type';
+import { TableCellUpdateEventIf } from './table-cell-update-event.if.js';
+import { AreaIdent } from '../../../tablemodel/area-ident.type.js';
 
 /**
- * Represents an event that occurs when a table cell is updated.
+ * A new value for one cell – the input of {@link TableApi.updateCells}.
+ * The value is written into the area model; if the cell is visible, only this cell is redrawn.
+ * `cssClasses` are applied to the current drawing of the cell (e.g. a short "flash"); permanent colours
+ * belong into the model ({@link AreaModelIf.getCustomClassesAt}).
  *
- * @class
- * @implements TableCellUpdateEventIf
+ * @example
+ * tableApi.updateCells([
+ *   new TableCellUpdateEvent("body", row, 2, price, { "tick-up": up, "tick-down": !up }),
+ *   new TableCellUpdateEvent("body", row, 4, volume)
+ * ]);
  *
- * @param {AreaIdent} area - The identification of the area where the cell belongs.
- * @param {number} rowIndex - The index of the row where the cell is located.
- * @param {number} columnIndex - The index of the column where the cell is located.
- * @param {any} value - The new value for the cell.
- * @param {Object.<string, boolean>} cssClasses - An object containing CSS classes to be applied to the cell.
+ * @see Training: [Live data without rebuilding the table](https://gui.expert/training/live-data/)
+ *
+ * @category Events
  */
 export declare class TableCellUpdateEvent implements TableCellUpdateEventIf {
     area: AreaIdent;

package/lib/table/data/common/event/input/table-cell-update-event.if.d.ts

@@ -1,8 +1,10 @@
-import { AreaIdent } from '../../../tablemodel/area-ident.type';
+import { AreaIdent } from '../../../tablemodel/area-ident.type.js';
 
 /**
  * One event defines one table cell update operation.
  * You can send an array of these event via TableApi#updateCells(events: TableCellUpdateEventIf[], repaintAll: boolean = false).
+ *
+ * @category Events
  */
 export interface TableCellUpdateEventIf {
     /**

package/lib/table/data/common/filter-function.d.ts

@@ -5,5 +5,7 @@
  * @param {number} index The index of the current element being evaluated.
  * @param {T[]} array The array that the filter function was called upon.
  * @returns {unknown} The result of the filter function evaluation: `true` if the element should be included, `false` otherwise.
+ *
+ * @category Sorting & filtering
  */
 export type FilterFunction<T> = (value: T, index: number, array: T[]) => unknown;

package/lib/table/data/common/get-t.d.ts

@@ -3,5 +3,7 @@
  * Returns the value of type T if it exists, otherwise undefined.
  *
  * @template T - The type of the value to be retrieved.
+ *
+ * @category Utilities
  */
 export type GetT<T> = () => T | undefined;

package/lib/table/data/common/index-and-px.d.ts

@@ -1,5 +1,7 @@
 /**
  * Represents an index and pixel value pair.
+ *
+ * @category Internals
  */
 export declare class IndexAndPx {
     index: number;

package/lib/table/data/common/size-unit.type.d.ts

@@ -5,5 +5,7 @@
  *  'weight': after the width is set for columns with unit 'px' and '%', the remaining width is divided among the weighted columns according to their respective weighting.
  *
  * @typedef {"px" | "%" | "weight"} SizeUnitType
+ *
+ * @category Columns
  */
 export type SizeUnitType = "px" | "%" | "weight";

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

@@ -1,6 +1,17 @@
-import { SizeIf } from './size.if';
-import { SizeUnitType } from './size-unit.type';
+import { SizeIf } from './size.if.js';
+import { SizeUnitType } from './size-unit.type.js';
 
+/**
+ * A width with unit – used for {@link ColumnDefIf.width}, `minWidth` and `maxWidth`.
+ * For pixel widths use the constants {@link px80}, {@link px100}, {@link px120} … (`px0` – `px500`).
+ *
+ * @example
+ * new Size(37, "px");        // fixed
+ * new Size(10, "%");         // 10 % of the table width (clamped by minWidth / maxWidth)
+ * new Size(2, "weight");     // twice as much of the remaining space as a column with weight 1
+ *
+ * @category Columns
+ */
 export declare class Size implements SizeIf {
     value: number;
     unit: SizeUnitType;

package/lib/table/data/common/size.if.d.ts

@@ -1,7 +1,9 @@
-import { SizeUnitType } from './size-unit.type';
+import { SizeUnitType } from './size-unit.type.js';
 
 /**
  * Represents the size of an object or element.
+ *
+ * @category Columns
  */
 export interface SizeIf {
     value: number;

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

@@ -1,35 +1,167 @@
-import { Size } from './size';
+import { Size } from './size.js';
 
+/**
+ * 500 px – a column width, e.g. `new ColumnDef("name", "Name", px500)`.
+ * @category Columns
+ */
 export declare const px500: Size;
+/**
+ * 400 px – a column width, e.g. `new ColumnDef("name", "Name", px400)`.
+ * @category Columns
+ */
 export declare const px400: Size;
+/**
+ * 300 px – a column width, e.g. `new ColumnDef("name", "Name", px300)`.
+ * @category Columns
+ */
 export declare const px300: Size;
+/**
+ * 290 px – a column width, e.g. `new ColumnDef("name", "Name", px290)`.
+ * @category Columns
+ */
 export declare const px290: Size;
+/**
+ * 280 px – a column width, e.g. `new ColumnDef("name", "Name", px280)`.
+ * @category Columns
+ */
 export declare const px280: Size;
+/**
+ * 270 px – a column width, e.g. `new ColumnDef("name", "Name", px270)`.
+ * @category Columns
+ */
 export declare const px270: Size;
+/**
+ * 260 px – a column width, e.g. `new ColumnDef("name", "Name", px260)`.
+ * @category Columns
+ */
 export declare const px260: Size;
+/**
+ * 250 px – a column width, e.g. `new ColumnDef("name", "Name", px250)`.
+ * @category Columns
+ */
 export declare const px250: Size;
+/**
+ * 240 px – a column width, e.g. `new ColumnDef("name", "Name", px240)`.
+ * @category Columns
+ */
 export declare const px240: Size;
+/**
+ * 230 px – a column width, e.g. `new ColumnDef("name", "Name", px230)`.
+ * @category Columns
+ */
 export declare const px230: Size;
+/**
+ * 220 px – a column width, e.g. `new ColumnDef("name", "Name", px220)`.
+ * @category Columns
+ */
 export declare const px220: Size;
+/**
+ * 210 px – a column width, e.g. `new ColumnDef("name", "Name", px210)`.
+ * @category Columns
+ */
 export declare const px210: Size;
+/**
+ * 200 px – a column width, e.g. `new ColumnDef("name", "Name", px200)`.
+ * @category Columns
+ */
 export declare const px200: Size;
+/**
+ * 190 px – a column width, e.g. `new ColumnDef("name", "Name", px190)`.
+ * @category Columns
+ */
 export declare const px190: Size;
+/**
+ * 180 px – a column width, e.g. `new ColumnDef("name", "Name", px180)`.
+ * @category Columns
+ */
 export declare const px180: Size;
+/**
+ * 170 px – a column width, e.g. `new ColumnDef("name", "Name", px170)`.
+ * @category Columns
+ */
 export declare const px170: Size;
+/**
+ * 160 px – a column width, e.g. `new ColumnDef("name", "Name", px160)`.
+ * @category Columns
+ */
 export declare const px160: Size;
+/**
+ * 150 px – a column width, e.g. `new ColumnDef("name", "Name", px150)`.
+ * @category Columns
+ */
 export declare const px150: Size;
+/**
+ * 140 px – a column width, e.g. `new ColumnDef("name", "Name", px140)`.
+ * @category Columns
+ */
 export declare const px140: Size;
+/**
+ * 130 px – a column width, e.g. `new ColumnDef("name", "Name", px130)`.
+ * @category Columns
+ */
 export declare const px130: Size;
+/**
+ * 120 px – a column width, e.g. `new ColumnDef("name", "Name", px120)`.
+ * @category Columns
+ */
 export declare const px120: Size;
+/**
+ * 110 px – a column width, e.g. `new ColumnDef("name", "Name", px110)`.
+ * @category Columns
+ */
 export declare const px110: Size;
+/**
+ * 100 px – a column width, e.g. `new ColumnDef("name", "Name", px100)`.
+ * @category Columns
+ */
 export declare const px100: Size;
+/**
+ * 90 px – a column width, e.g. `new ColumnDef("name", "Name", px90)`.
+ * @category Columns
+ */
 export declare const px90: Size;
+/**
+ * 80 px – a column width, e.g. `new ColumnDef("name", "Name", px80)`.
+ * @category Columns
+ */
 export declare const px80: Size;
+/**
+ * 70 px – a column width, e.g. `new ColumnDef("name", "Name", px70)`.
+ * @category Columns
+ */
 export declare const px70: Size;
+/**
+ * 60 px – a column width, e.g. `new ColumnDef("name", "Name", px60)`.
+ * @category Columns
+ */
 export declare const px60: Size;
+/**
+ * 50 px – a column width, e.g. `new ColumnDef("name", "Name", px50)`.
+ * @category Columns
+ */
 export declare const px50: Size;
+/**
+ * 40 px – a column width, e.g. `new ColumnDef("name", "Name", px40)`.
+ * @category Columns
+ */
 export declare const px40: Size;
+/**
+ * 30 px – a column width, e.g. `new ColumnDef("name", "Name", px30)`.
+ * @category Columns
+ */
 export declare const px30: Size;
+/**
+ * 20 px – a column width, e.g. `new ColumnDef("name", "Name", px20)`.
+ * @category Columns
+ */
 export declare const px20: Size;
+/**
+ * 10 px – a column width, e.g. `new ColumnDef("name", "Name", px10)`.
+ * @category Columns
+ */
 export declare const px10: Size;
+/**
+ * 0 px – a column width, e.g. `new ColumnDef("name", "Name", px0)`.
+ * @category Columns
+ */
 export declare const px0: Size;

package/lib/table/data/common/sort-item.d.ts

@@ -1,10 +1,23 @@
-import { SortState } from './sort-state.type';
+import { SortState } from './sort-state.type.js';
 
 /**
- * Represents a sortable column with its sort order..
+ * One sort instruction: column index + direction. Used by {@link TableModelIf.doSort} and
+ * {@link AreaModelIf.doSort}.
+ *
+ * @example
+ * // sort once by column 10 descending (and match the header icon set with sortState: "desc")
+ * tableModel.doSort([new SortItem(10, "desc")]);
+ *
+ * @category Sorting & filtering
  */
 export declare class SortItem {
+    /** Column index (west + center + east). */
     columnIndex: number;
+    /** `"asc"`, `"desc"` or `""` (unsorted). */
     sortState: SortState;
-    constructor(columnIndex: number, sortState: SortState);
+    constructor(
+    /** Column index (west + center + east). */
+    columnIndex: number, 
+    /** `"asc"`, `"desc"` or `""` (unsorted). */
+    sortState: SortState);
 }

package/lib/table/data/common/sort-state.type.d.ts

@@ -3,5 +3,7 @@
  * It can take one of the following values: "asc", "desc", or "" (empty string).
  *
  * @typedef {("asc" | "desc" | "")} SortState
+ *
+ * @category Sorting & filtering
  */
 export type SortState = "asc" | "desc" | "";

package/lib/table/data/common/tree-arrow.type.d.ts

@@ -4,5 +4,7 @@
  * The arrow type determines the visual representation of the arrow icon associated with a tree node.
  *
  * @typedef {("none" | "hidden" | "collapsed" | "expanded")} TreeArrowType
+ *
+ * @category Tree & checkboxes
  */
 export type TreeArrowType = "none" | "hidden" | "collapsed" | "expanded";

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;