@guiexpert/table 1.1.29 → 1.1.32

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

@@ -2,7 +2,28 @@ import { AreaIdent } from "../tablemodel/area-ident.type";
 import { AreaModelIf } from "../tablemodel/areamodel/area-model.if";
 import { TableScope } from "../../table-scope";
 /**
- * Represents data about a mouse target. It's a helper class to extract all information from the target HTMLElement.
+ * 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.
+ *
+ * The class encapsulates different types of data related to the element on which an event was targeted.
+ * Data such as the targeted row and column indices, the area on the table identified (header, body, or footer),
+ * the model of the table area the user interacted with, attributes of the HTML Input Element
+ * (value and type), associated action, content row, and CSS class applied to the element.
+ *
+ * The constructor expects an `EventTarget` and `TableScope` objects as parameters -
+ * data encapsulated in the `EventTarget` object will be used to populate the properties of the `MouseTargetData` object.
+ *
+ * @property {number} rowIdx - The index of the targeted row on an interaction event. Default value is -1.
+ * @property {number} colIdx - The index of the targeted column on an interaction event. Default value is -1.
+ * @property {AreaIdent} [areaIdent] - The identification of the targeted area on an interaction event. Possible value can be 'header', 'body', 'footer'.
+ * @property {AreaModelIf} [areaModel] - The model of the table area the user interacted with.
+ * @property {any} [row] - The specific row the user interacted with.
+ * @property {any} [value] - The value(s) associated with the HTML Input Element the user interacted with.
+ * @property {string | null} action - The associated action with the HTML Element (retrieved through "data-ge-action" data attribute). Default is `null`.
+ * @property {string | null} inputType - The type of the HTML Input Element (retrieved through "data-input-type" data attribute). Default is `null`.
+ * @property {string} className - The CSS class name applied to the target element. Default is an empty string.
+ *
+ * @example
+ * const mouseTarget = new MouseTargetData(eventTarget, tableScope);
  */
 export declare class MouseTargetData {
     rowIdx: number;

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

@@ -1,8 +1,65 @@
+/**
+ * `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>`.
+ *
+ * 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.
+ *
+ * @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.
+ */
 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.
+ */
 export type GetRowIdFn<T> = ((row: T) => 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
+ */
 export type GetStorageKeyFn = (() => string);
 /**
- * See TableOptionsIf#autoRestoreOptions()
+ * 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.
+ *
+ * @property {boolean=} autoRestoreScrollPosition - Optional. If true, the scroll position
+ * in the list of T elements will be preserved after changes in the application state.
+ *
+ * @property {boolean=} autoRestoreCheckedState - Optional. If true, the checked state of
+ * T elements will be preserved after changes in the application state.
+ *
+ * @property {boolean=} autoRestoreSelectedState - Optional. If true, the selected state of
+ * T elements will be preserved after changes in the application state.
+ *
+ * @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.
+ *
+ * @property {() => string} getStorageKeyFn - Function for generating a unique key used for storage.
+ * If not provided, a constant key 'autorestoreoptionsif' will be used.
+ *
+ * @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.
  */
 export interface AutoRestoreOptionsIf<T> {
     autoRestoreSortingState: boolean;

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

@@ -1,3 +1,22 @@
+/**
+ * The `DefaultRowHeightsIf` interface provides a specification for the default row heights in the table layout.
+ * It includes properties for defining heights of the header, body, and footer sections of the rows.
+ * Each property is of type `number`, which states the height in pixels.
+ *
+ * @property `header`: It denotes the height of the table header row. Developers can set their preferred height as per the design requirements.
+ * @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.
+ *
+ * @example
+ * // declaring a variable with default row heights
+ * let rowHeights: DefaultRowHeightsIf = {
+ *     header: 50,
+ *     body: 100,
+ *     footer: 60
+ * };
+ *
+ * For implementation details, refer to the `DefaultRowHeights` class.
+ */
 export interface DefaultRowHeightsIf {
     header: number;
     body: number;

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

@@ -1,4 +1,41 @@
 import { IconIf } from "./icon.if";
+/**
+ * The `HeaderGroupOptionsIf` interface is part of the TypeScript project,
+ * and it's used as a type definition for the options of a header group component.
+ * It includes the specifications for both the expanded and collapsed states of the said header group component.
+ *
+ * This interface contains two properties:
+ * - `iconExpanded`: An `IconIf` interface definition for the icon shown when the header group is expanded.
+ * - `iconCollapsed`: An `IconIf` interface definition for the icon shown when the header group is collapsed.
+ *
+ * Each of these properties, `iconExpanded` and `iconCollapsed`, is an object that adheres to the `IconIf` interface.
+ * Therefore, they should include:
+ * - `content`: (type `string`) which represents the HTML content of the icon.
+ * - `style`: (type `string`) a string containing the CSS style to be applied to the icon.
+ * - `classes`: (type `string[]`) which is an array of CSS classes to be applied to the icon.
+ *
+ * @interface
+ * @see {@link IconIf}
+ *
+ * @example
+ *
+ * const HeaderGroupOptions: HeaderGroupOptionsIf = {
+ *   iconExpanded: {
+ *     content: "<i class='my-expanded-icon'></i>",
+ *     style: "color: green;",
+ *     classes: ["my-expanded-icon-class"]
+ *   },
+ *   iconCollapsed: {
+ *     content: "<i class='my-collapsed-icon'></i>",
+ *     style: "color: red;",
+ *     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.
+ */
 export interface HeaderGroupOptionsIf {
     iconExpanded: IconIf;
     iconCollapsed: IconIf;

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

@@ -1,6 +1,24 @@
 import { IconIf } from "./icon.if";
 /**
- * Represents a class that defines sorted icons, which will displayed in the header (if column is sortable).
+ * This TypeScript interface, `SortedOptionsIf`, represents the configuration options for sorting.
+ *
+ * It contains three properties, each of type `IconIf`. This allows the consumer of this interface to specify their
+ * own icon for ascending sort order (`iconAsc`), descending sort order (`iconDesc`), and a placeholder icon (`iconPlaceholder`).
+ *
+ * The IconIf interface represents an icon with content, css style, and css classes.
+ *
+ * For example:
+ *
+ * ```typescript
+ * {
+ *    iconAsc: {content: '>', style: 'color:green;', classes: ['sortable-icon', 'sortable-asc']},
+ *    iconDesc: {content: '<', style: 'color:red;', classes: ['sortable-icon', 'sortable-desc']},
+ *    iconPlaceholder: {content: '', style: '', classes: ['sortable-icon']}
+ * }
+ * ```
+ *
+ * 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
  */
 export interface SortedOptionsIf {

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

@@ -10,6 +10,9 @@ 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';
+/**
+ * TableOptions class provides configuration options for the table.
+ */
 export declare class TableOptions implements TableOptionsIf {
     overflowX: "auto" | "scroll";
     overflowY: "auto" | "scroll";
@@ -37,6 +40,7 @@ export declare class TableOptions implements TableOptionsIf {
     sortedOptions: SortedOptions;
     sortOrder: SortState[];
     shortcutActionIdMapping?: ShortcutActionIdMapping;
+    resizeEventDebounceDelay: number;
     getEditRenderer?: GetEditRenderer;
     getSelectionModel?: GetT<SelectionModelIf>;
     getFocusModel?: GetT<FocusModelIf>;

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

@@ -47,6 +47,12 @@ import { HeaderGroupOptionsIf } from './header-group-options.if';
  * | shortcutActionIdMapping          | Represents a mapping of shortcut action IDs.                                                     |
  */
 export interface TableOptionsIf {
+    /**
+     * The delay in milliseconds used for debouncing the resize event.
+     *
+     * @type {number}
+     */
+    resizeEventDebounceDelay: number;
     /**
      * Indicates whether the header separator border is visible.
      *

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

@@ -1,4 +1,45 @@
 import { IconIf } from "./icon.if";
+/**
+ * This interface `TreeOptionsIf` represents the specific configuration and properties of a tree component, usually displayed in a User Interface (UI).
+ * The interface includes several properties that illustrate the statuses of tree's collapsible nodes. All properties represent the Icon characteristics in their different states in the tree.
+ *
+ * Property `arrowExpandCollapseAll` is an Icon configuration when an action to expand or collapse all nodes in the tree is performed.
+ *
+ * Property `arrowExpanded` describes Icon configuration when a single tree node is expanded.
+ *
+ * Property `arrowCollapsed` holds Icon configuration when a single tree node is collapsed.
+ *
+ * Property `arrowPlaceholder` entails Icon configuration signifying an placeholder arrow, generally used when tree nodes have no children.
+ *
+ * All properties of this interface are themselves objects based on another interface `IconIf`, symbolizing an icon configuration. Each icon has `content` - a string that represents icon, `style` - a string which determines the CSS styles applied to the icon, and `classes` - an array of strings for CSS class name(s) to be added to the icon.
+ *
+ * @interface
+ * @see {@link IconIf}
+ * @example
+ *
+ * const treeOptions: TreeOptionsIf = {
+ *   arrowExpandCollapseAll: {
+ *     content: '>>',
+ *     style: 'color: blue;',
+ *     classes: ['expand-collapse-all-icon-class'],
+ *   },
+ *   arrowExpanded: {
+ *     content: '>',
+ *     style: 'color: green;',
+ *     classes: ['expand-icon-class'],
+ *   },
+ *   arrowCollapsed: {
+ *     content: '<',
+ *     style: 'color: red;',
+ *     classes: ['collapse-icon-class'],
+ *   },
+ *   arrowPlaceholder: {
+ *     content: '-',
+ *     style: 'color: gray;',
+ *     classes: ['placeholder-icon-class'],
+ *   },
+ * };
+ */
 export interface TreeOptionsIf {
     arrowExpandCollapseAll: IconIf;
     arrowExpanded: IconIf;

package/lib/table/data/side-ident.type.d.ts

@@ -1,4 +1,28 @@
 /**
- * Represents a class that identifies a (vertical) side of the table.
+ * The `SideIdent` type is utilized in various parts of the application to identify the position
+ * of a component or an element on the horizontal axis within a layout. This can be seen in usage
+ * within the `TableModel` and `AreaModelIf` classes to manage layout aspects such as column positioning
+ * and adjustments.
+ *
+ * The `SideIdent` is a string literal type that can have the following values:
+ * - "west"  : Represents the left side on the horizontal axis of a layout.
+ * - "center": Represents the center on the horizontal axis of a layout.
+ * - "east"  : Represents the right side on the horizontal axis of a layout.
+ *
+ * It is used as an argument in numerous functions and interfaces to specify which 'side' the operation pertains to.
+ *
+ * Example:
+ * - In the `TableModel` class, it's used in `getSideAreaWidth` and `getSideStartAndEndColumnIndex` methods to determine
+ *   the position and the width of different sections.
+ * - In the `ArgsAdjustColumnsToRowParentParams` and `ArgsRenderCellDiv` interfaces, it's used to provide classification
+ *   of the area requested for operation.
+ *
+ * These examples show how crucial this value is for the computation and organization of layout within the application.
+ *
+ * @see ArgsAdjustColumnsToRowParentParams
+ * @see ArgsRenderCellDiv
+ * @see TableModel
+ * @see AreaModelIf
+ * @type {("west"|"center"|"east")}
  */
 export type SideIdent = "west" | "center" | "east";

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

@@ -7,6 +7,42 @@ import { TableModelIf } from "../data/tablemodel/table-model.if";
 import { TableModel } from "../data/tablemodel/table-model";
 import { SelectionModelIf } from "../selection/selection-model.if";
 export declare class TableFactory {
+    /**
+     * TableFactory
+     *
+     * This class is responsible for creating table models based on various
+     * parameters and configurations. TableFactory provides different methods
+     * to create these models that must comply with TableModelIf interface.
+     *
+     * Methods:
+     *
+     * createTableModel(p: Partial<{...}>): TableModelIf
+     * Receives a set of parameters as a Partial object with a number of properties
+     * and returns an instance of an object that complies to TableModelIf interface.
+     * Refer to the method's documentation for details.
+     *
+     * buildByTypedRowsParam(param: {rows: T[]; columnDefs: ColumnDefIf[]; tableOptions?: TableOptionsIf; fixedLeftColumnCount?: number; fixedRightColumnCount?: number}): TableModelIf
+     * Receives a parameter object with essential properties needed to build the table model,
+     * including rows (type T array), column definitions (ColumnDefIf array),
+     * optional table options (TableOptionsIf object), and optional fixed column counts,
+     * and returns an instance of TableModelIf.
+     *
+     * buildByTypedRows(rows: T[], columnDefs: ColumnDefIf[], tableOptions?: TableOptionsIf, fixedLeftColumnCount?: number, fixedRightColumnCount?: number): TableModelIf
+     * Similar to `buildByTypedRowsParam` but accepts separate parameters instead of a single parameter object.
+     *
+     * createByObjectArrayParam(param: {rows: T[]; header?: string[][]; footer?: string[][]; fixedLeftColumnCount?: number; fixedRightColumnCount?: number; rowCheckboxVisible?: boolean; defaultRowHeights?: DefaultRowHeightsIf; columnDefs?: ColumnDefIf[]; columnSizes?: number[]}): TableModelIf
+     * Similar to `createTableModel` but accepts an object parameter with properties required to create a table, including row data, header and footer multi-line data, fixed column counts, visibility of row checkbox, default row heights, column definitions, and column sizes, and returns a TableModelIf instance.
+     *
+     * createByAreaModels(headerAreaModel: AreaModelIf, bodyAreaModel: AreaModelIf, footerAreaModel: AreaModelIf, fixedLeftColumnCount: number, fixedRightColumnCount: number, rowCheckboxVisible: boolean, defaultRowHeights: DefaultRowHeightsIf): TableModelIf
+     * Accepts area models for header, body, and footer, along with fixed column counts, visibility of row checkbox, and default row heights, to create a table model.
+     *
+     * createByAreaModelsParam(param: {headerAreaModel?: AreaModelIf; bodyAreaModel: AreaModelIf; footerAreaModel?: AreaModelIf; fixedLeftColumnCount?: number; fixedRightColumnCount?: number; rowCheckboxVisible?: boolean; defaultRowHeights?: DefaultRowHeightsIf; columnDefs?: ColumnDefIf[]; columnSizes?: number[]; overridingColumnWidth?: number; columnCount?: number}): TableModelIf
+     * Similar to `createByAreaModels` but accepts an object parameter with the required and optional properties to create the table model.
+     *
+     * createByObjectArray(rows: T[], header: string[][], footer: string[][], fixedLeftColumnCount: number, fixedRightColumnCount: number, rowCheckboxVisible: boolean, defaultRowHeights: DefaultRowHeightsIf): TableModelIf
+     * Allows to create a table model utilizing object array data for rows, header, and footer along with the specified configurations.
+     * Please consult each method's documentation for detailed explanation of their functionality.
+     */
     static createTableModel(p: Partial<{
         headerAreaModel: AreaModelIf;
         bodyAreaModel: AreaModelIf;
@@ -28,6 +64,23 @@ export declare class TableFactory {
         footerData: string[][];
         tableOptions: TableOptionsIf;
     }>): TableModelIf;
+    /**
+     * Constructs a table model (an instance of `TableModelIf`) by using provided parameters.
+     *
+     * @template T The generic parameter that represents the datatype of rows.
+     *
+     * @param {Object} param The parameter object.
+     * @param {T[]} param.rows The rows data to be used in the table model.
+     * @param {ColumnDefIf[]} param.columnDefs The definition of columns that are to be used in the table model.
+     * @param {TableOptionsIf} [param.tableOptions=new TableOptions()] Optional table options that may override default table settings. Defaults to `new TableOptions()`.
+     * @param {number} [param.fixedLeftColumnCount=0] Optional parameter that specifies the count of fixed (non-scrollable) columns from the left. Defaults to `0`.
+     * @param {number} [param.fixedRightColumnCount=0] Optional parameter that specifies the count of fixed (non-scrollable) columns from the right. Defaults to `0`.
+     *
+     * @returns {TableModelIf} The newly constructed table model.
+     *
+     * @static
+     * @method
+     */
     static buildByTypedRowsParam<T>(param: {
         rows: T[];
         columnDefs: ColumnDefIf[];
@@ -35,7 +88,87 @@ export declare class TableFactory {
         fixedLeftColumnCount?: number;
         fixedRightColumnCount?: number;
     }): TableModelIf;
+    /**
+     * Static method that helps to build a table model object. It takes in tabular data and options and constructs a suitable
+     * model for rendering as a table. This method is capable of handling both 'Flat' and 'Tree' data structures.
+     *
+     * @typeparam T - The type of the data in the rows.
+     *
+     * @param rows - An array of the data rows. The type of these rows could be anything which is defined by the generic type parameter T.
+     *
+     * @param columnDefs - An array of objects that define the columns of the table. Each object represents one column.
+     *
+     * @param tableOptions - A configuration object that allows you to customize how the table is displayed and behaves.
+     * This is optional, and if not provided it defaults to a new instance of TableOptions.
+     *
+     * @param fixedLeftColumnCount - Optional parameter that specifies the number of columns that should remain fixed from the left
+     * side of the table while scrolling horizontally. It defaults to 0 if not provided.
+     *
+     * @param fixedRightColumnCount - Optional parameter that specifies the number of columns that should remain fixed from the right
+     * side of the table while scrolling horizontally. It defaults to 0 if not provided.
+     *
+     * @returns A TableModelIf object which can be used to render the table. The TableModelIf defines the structure of the table and
+     * contains all its data and state.
+     *
+     * @usageNotes
+     *
+     * Here is an example of using this static method to build a table model:
+     *
+     * ```typescript
+     * const tableModel = TableFactory.buildByTypedRows<User>(users, [{ property: 'name', headerLabel: 'Name' }, { property: 'email', headerLabel: 'Email' }]);
+     * ```
+     *
+     * This will build a table with two columns 'Name' and 'Email', each row representing a 'User' object from the 'users' array.
+     *
+     * **Warning:** This function assumes that the first columnDef provided represents a checkbox column if the property of the first
+     * columnDef is "CheckboxColumn". If the first column is not a checkbox column, ensure that the first columnDef does not have "CheckboxColumn"
+     * as its property.
+     */
     static buildByTypedRows<T>(rows: T[], columnDefs: ColumnDefIf[], tableOptions?: TableOptionsIf, fixedLeftColumnCount?: number, fixedRightColumnCount?: number): TableModelIf;
+    /**
+     * The `createByObjectArrayParam` static method is used to create a `TableFactory` object with the data contained in the `param` object.
+     * This method would call the `createByObjectArray` static method, which actually constructs the `TableModel` object with the provided data.
+     *
+     * @template T - Defines the type of the items contained in the rows.
+     *
+     * @param {Object} param - Method parameter as an object that carries several properties described below:
+     * @param {T[]} param.rows - Array of table row data that can be of any type.
+     * @param {string[][]} [param.header] - Optional array of arrays with the table header data.
+     * @param {string[][]} [param.footer] - Optional array of arrays with the table footer data.
+     * @param {number} [param.fixedLeftColumnCount] - Optional number detailing how many of the beginning columns are sticky to the left.
+     * @param {number} [param.fixedRightColumnCount] - Optional number detailing how many of the ending columns are sticky to the right.
+     * @param {boolean} [param.rowCheckboxVisible] - Optional flag that indicates whether checkboxes are visible in the rows.
+     * @param {DefaultRowHeightsIf} [param.defaultRowHeights] - Optional object defining default heights of rows in different sections of the table. Defaults to new `DefaultRowHeights()`.
+     * @param {ColumnDefIf[]} [param.columnDefs] - Optional array of column definitions, each is an object conforming to `ColumnDefIf` interface.
+     * @param {number[]} [param.columnSizes] - Optional array of numbers providing the specific sizes for columns.
+     *
+     * @returns A `TableFactory` object created by the `createByObjectArray` method.
+     *
+     * @example
+     * let param = {
+     *   rows: [{name: 'John', age: 30}, {name: 'Doe', age: 40}],
+     *   header: [['Name', 'Age']],
+     *   footer: [['Avg', '35']],
+     *   fixedLeftColumnCount: 1,
+     *   fixedRightColumnCount: 0,
+     *   rowCheckboxVisible: true,
+     *   defaultRowHeights: new DefaultRowHeights(40, 50, 40),
+     *   columnDefs: [
+     *     {
+     *       property: 'name',
+     *       headerLabel: 'Name',
+     *       width: 100
+     *     },
+     *     {
+     *       property: 'age',
+     *       headerLabel: 'Age',
+     *       width: 50
+     *     }
+     *   ],
+     *   columnSizes: [100, 50]
+     * };
+     * const tableModel = TableFactory.createByObjectArrayParam(param);
+     */
     static createByObjectArrayParam<T>(param: {
         rows: T[];
         header?: string[][];
@@ -47,7 +180,84 @@ export declare class TableFactory {
         columnDefs?: ColumnDefIf[];
         columnSizes?: number[];
     }): TableModel;
+    /**
+     * This public static factory method creates a `TableModel` instance using the provided parameters.
+     * Each parameter has a default value allowing for great flexibility in creating table models.
+     * The main parameters are the AreaModel instances for different table sections:
+     *
+     * @param headerAreaModel - This parameter of type `AreaModelIf` represents the header area of the table.
+     * The default value is a new instance of `AreaModelHidden`, indicating an invisible header.
+     *
+     * @param bodyAreaModel - This parameter of type `AreaModelIf` represents the body area of the table and is required.
+     * It needs to be passed as it contains all the row data that will be displayed in the table.
+     *
+     * @param footerAreaModel - This `AreaModelIf` type parameter represents the footer area of the table.
+     * Similar to `headerAreaModel`, the default value is a new instance of `AreaModelHidden`, indicating an invisible footer.
+     *
+     * Also, the method receives parameters for fixed columns, row checkbox visibility, default row heights, column definitions, column sizes, overriding column width, and column count:
+     *
+     * @param fixedLeftColumnCount - This value indicates the number of fixed columns on the left side of the table.
+     * The default value is `0`, no fixed column by default.
+     *
+     * @param fixedRightColumnCount - This value indicates the number of fixed columns on the right side of the table.
+     * Similarly to `fixedLeftColumnCount`, its default value is `0`.
+     *
+     * @param rowCheckboxVisible - This is a boolean that determines whether a checkbox will be visible for each row.
+     * The default value is `false`, indicating that checkboxes will not be displayed unless otherwise specified.
+     *
+     * @param defaultRowHeights - This object of type `DefaultRowHeightsIf` allows setting of the default row heights for the table sections.
+     * By default, it creates a new `DefaultRowHeights` instance with values of `34` for header, body and footer.
+     *
+     * @param columnDefs - Here, an array of `ColumnDefIf[]` needs to be passed to specify the column definitions.
+     *
+     * @param columnSizes - This is an array of `number[]` providing custom column sizes.
+     * If not defined, an empty array `[]` is used.
+     *
+     * @param overridingColumnWidth - This number sets a uniform width for all columns, overriding individual column sizes.
+     * Default value is `-1`, indicating that this feature is disabled by default.
+     *
+     * @param columnCount - This is the total column count.
+     *
+     * @return A new instance of `TableModel` is created using the provided parameters.
+     * If a parameter isn't provided, the default value is used.
+     */
     static createByAreaModels(headerAreaModel: AreaModelIf | undefined, bodyAreaModel: AreaModelIf, footerAreaModel: AreaModelIf | undefined, fixedLeftColumnCount: number | undefined, fixedRightColumnCount: number | undefined, rowCheckboxVisible: boolean | undefined, defaultRowHeights: DefaultRowHeightsIf | undefined, columnDefs: ColumnDefIf[], columnSizes: number[] | undefined, overridingColumnWidth: number | undefined, columnCount: number): TableModel;
+    /**
+     * `TableFactory.createByAreaModelsParam` is a static method in the `TableFactory` class that creates a table model by area models and other optional parameters.
+     * This method allows more flexibility and control over table building by providing the option to decide the visibility and nature of the header, body, footer, columns, and rows in the table.
+     *
+     * @param `param` is an object that holds the configuration settings for creating the table model. Below are the properties that this object can have:
+     *   - `headerAreaModel`: Optional. An instance of `AreaModelIf` class to be used for creating the header of the table. If not provided, a new `AreaModelHidden` is created by default.
+     *   - `bodyAreaModel`: Mandatory. An instance of `AreaModelIf` class for body of the table.
+     *   - `footerAreaModel`: Optional. An instance of `AreaModelIf` class for table footer. If not provided, a new `AreaModelHidden` is created by default.
+     *   - `fixedLeftColumnCount`: Optional. Number of fixed columns on the left side of the table. Default is 0.
+     *   - `fixedRightColumnCount`: Optional. Number of fixed columns on the right side of the table. Default is 0.
+     *   - `rowCheckboxVisible`: Optional. Boolean that decides if the row checkboxes are visible or not. Defaults to `false`.
+     *   - `defaultRowHeights`: Optional. An instance of `DefaultRowHeightsIf` interface that specifies default row heights. No default value.
+     *   - `columnDefs`: Optional. Array of instance(s) of `ColumnDefIf` interface to define column properties. Defaults to an empty array.
+     *   - `columnSizes`: Optional. Array of numbers setting the sizes of the columns. Defaults to an empty array.
+     *   - `overridingColumnWidth`: Optional. Overrides the width of all columns with this value. Defaults to `-1` which means no width override.
+     *   - `columnCount`: Optional. Number setting the total count of columns. Defaults to 0.
+     *
+     * @returns a new instance of `TableModelIf` created by the `createByAreaModels` method of `TableFactory` using the provided parameters.
+     *
+     * Note: The area models (`headerAreaModel`, `bodyAreaModel`, `footerAreaModel`) should be initialized before being passed to this method. If not initialized, they might need to call their `init` method to ensure proper functioning.
+     *
+     * @example
+     * const tableModel = TableFactory.createByAreaModelsParam({
+     *    headerAreaModel: myHeaderModel,
+     *    bodyAreaModel: myBodyModel,
+     *    footerAreaModel: myFooterModel,
+     *    fixedLeftColumnCount: 2,
+     *    fixedRightColumnCount: 1,
+     *    rowCheckboxVisible: true,
+     *    defaultRowHeights: myDefaultHeights,
+     *    columnDefs: myColumnDefs,
+     *    columnSizes: [100, 100, 200],
+     *    overridingColumnWidth: 150,
+     *    columnCount: 3
+     * });
+     */
     static createByAreaModelsParam(param: {
         headerAreaModel?: AreaModelIf;
         bodyAreaModel: AreaModelIf;
@@ -61,5 +271,53 @@ export declare class TableFactory {
         overridingColumnWidth?: number;
         columnCount?: number;
     }): TableModel;
+    /**
+     * Class method `createByObjectArray` of the `TableFactory` class.
+     *
+     * This public, static method is intended to create a table model by an array of objects.
+     * This method is particularly useful when you are aiming to build a table from a set of data rows, header and footer information.
+     * The table can include both fixed and flexible columns and optional checkboxes for each row.
+     * The table layout can further be customized using the default row heights, column definitions, and column sizes parameters.
+     *
+     * @generic `T` - The generic type parameter for data rows.
+     *
+     * @param `rows` - This parameter is an array of typed data rows (type `T`) for the table body.
+     *
+     * @param `header` - This optional parameter is a two-dimensional string array. It defines the table header data. The default value is an empty array.
+     *
+     * @param `footer` - This optional parameter is a two-dimensional string array. It defines the table footer data. The default value is an empty array.
+     *
+     * @param `fixedLeftColumnCount` - This optional parameter specifies the count of fixed (non-scrollable) columns on the left side of the table. The default value is 0.
+     *
+     * @param `fixedRightColumnCount` - This optional parameter specifies the count of fixed (non-scrollable) columns on the right side of the table. The default value is 0.
+     *
+     * @param `rowCheckboxVisible` - This optional boolean parameter tells whether to display checkboxes for each row in the table. The default value is false.
+     *
+     * @param `defaultRowHeights` - This optional parameter is an instance of `DefaultRowHeightsIf` interface. It sets the default row heights for the header, body, and footer areas of the table.
+     *
+     * @param `columnDefs` - This optional parameter is an array of column definitions (`ColumnDefIf[]`). It helps to define the settings and properties of individual columns.
+     *
+     * @param `columnSizes` - This optional parameter is a number array. It helps to define the column widths. The default value is an empty array.
+     *
+     * The method further processes the header, footer, and body data to create respective models (`AreaModelIf`), and ultimately it creates and returns a new instance of `TableModel` containing all those prepared models, options, and properties.
+     *
+     * @returns It returns an instance of `TableModel` with all the provided/processed parameters.
+     *
+     * Note: You need to import the `AreaModelArrayOfArrays` and `AreaModelHidden` classes from the respective package/module before using this method.
+     *
+     * @example
+     * ```typescript
+     * // Given the following array of objects:
+     * const rows = [{field1: 'data11', field2: 'data12'}, {field1: 'data21', field2: 'data22'}];
+     *
+     * // And a set of column definitions:
+     * const columnDefs: ColumnDefIf[] = [{headerLabel: 'Field 1', property: 'field1'}, {headerLabel: 'Field 2', property: 'field2'}];
+     *
+     * // You can create a TableModel like following:
+     * let tableModel = TableFactory.createByObjectArray(rows, undefined, undefined, 0, 0, false, new DefaultRowHeights(), columnDefs);
+     * ```
+     *
+     * Reference: For more details regarding the `DefaultRowHeightsIf`, `ColumnDefIf`, `AreaModelIf`, and `AreaModelArrayOfArrays` classes/interfaces, please refer to the respective API documents.
+     */
     static createByObjectArray<T>(rows: T[], header: string[][] | undefined, footer: string[][] | undefined, fixedLeftColumnCount: number | undefined, fixedRightColumnCount: number | undefined, rowCheckboxVisible: boolean | undefined, defaultRowHeights: DefaultRowHeightsIf | undefined, columnDefs: ColumnDefIf[], columnSizes?: number[]): TableModel;
 }

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

@@ -1,4 +1,39 @@
 import { FocusModelIf } from './focus-model.if';
+/**
+ * `EventFocusChangedListenerIf` is an interface that defines a contract for classes that wish to listen for changes in focus in a
+ * tabular data structure, such as a data grid or spreadsheet.
+ * Listener classes should implement the `onFocusChanged` method which would be triggered whenever focus changes in the data grid.
+ *
+ * ## Overview
+ * This interface ensures a consistent API for classes that need to react to changes in focus in the data grid.
+ * The table grid or data grid components will typically iterate over an array of `EventFocusChangedListenerIf` listeners and
+ * call the `onFocusChanged` method on each one when the focus within the grid changes.
+ * This could be due to user interactions such as clicking on a different cell or programmatically changing the cell focus.
+ *
+ * ## Usage
+ * Implement `EventFocusChangedListenerIf` if you want to create a class that reacts to changes in focus.
+ *
+ * ```typescript
+ * class MyFocusChangeListener implements EventFocusChangedListenerIf {
+ *   onFocusChanged(model: FocusModelIf): void {
+ *     console.log('Focus changed: ', model.getFocus());
+ *   }
+ * }
+ * ```
+ *
+ * Use the `addEventFocusChangedListener` method from `FocusModelIf` to add your listener to the queue.
+ *
+ * ```typescript
+ * focusModel.addEventFocusChangedListener(new MyFocusChangeListener());
+ * ```
+ *
+ * ## See Also
+ * - [FocusModelIf](./FocusModel.md) for focus management.
+ * - [EventAdapter](./EventAdapter.md) for a class that implements this and other listener interfaces.
+ *
+ * @interface
+ * @method onFocusChanged - method to be called with an instance of the `FocusModelIf` interface whenever a focus event occurs
+ */
 export interface EventFocusChangedListenerIf {
     onFocusChanged(model: FocusModelIf): void;
 }