@guiexpert/table 1.1.72 → 1.1.75

package/lib/table/data/tablemodel/areamodel/abstract-area-model.d.ts

@@ -38,6 +38,7 @@ export declare abstract class AbstractAreaModel<T> implements AreaModelIf, HasDe
     abstract externalFilterChanged<T>(predictFn: FilterFunction<T>): void;
     isFilterable(): boolean;
     doSort(_sortItems: SortItem[]): boolean;
+    sort(_compareFn?: (a: any, b: any) => number): void;
     isEditable(_rowIndex: number, columnIndex: number): boolean;
     setValue(rowIndex: number, columnIndex: number, value: any): boolean;
     isSelectable(_rowIndex: number, _columnIndex: number): boolean;

package/lib/table/data/tablemodel/areamodel/area-model-cell-groups.d.ts

@@ -22,6 +22,7 @@ export declare class AreaModelCellGroups implements AreaModelIf {
     private groupExts;
     private cellGroupExtCellRenderer;
     constructor(areaIdent: AreaIdent, groups: CellGroupIf[], columnDefs: ColumnDefIf[], defaultRowHeight: number, headerGroupOptions?: HeaderGroupOptionsIf);
+    sort<T>(_compareFn?: (a: T, b: T) => number): void;
     init(): void;
     getAllLeafs(): CellGroupExt[];
     getMaxRowCount(): number;

package/lib/table/data/tablemodel/areamodel/area-model-hidden.d.ts

@@ -12,6 +12,7 @@ export declare class AreaModelHidden implements AreaModelIf {
     areaIdent: AreaIdent;
     rowSelectionModel: CheckboxModelIf<any> | undefined;
     constructor(areaIdent?: AreaIdent);
+    sort<T>(_compareFn?: (a: T, b: T) => number): void;
     getRowCount(): number;
     getValueAt(_rowIndex: number, _columnIndex: number): any;
     getTextValueAt(_rowIndex: number, _columnIndex: number): string;

package/lib/table/data/tablemodel/areamodel/area-model-object-array.d.ts

@@ -16,11 +16,13 @@ export declare class AreaModelObjectArray<T> extends AbstractAreaModel<T> implem
     protected columnDefs: ColumnDefIf[];
     selectedRowClass: string;
     focusedRowClass: string;
-    focusedRowIndex: number;
     protected readonly properties: string[];
     protected filteredRows: T[];
     protected sorterService: SorterService;
     constructor(areaIdent: AreaIdent, rows: T[], defaultRowHeight: number, columnDefs?: ColumnDefIf[], selectedRowClass?: string, focusedRowClass?: string);
+    private _focusedRowIndex;
+    get focusedRowIndex(): number;
+    set focusedRowIndex(value: number);
     setRows(rows: T[]): void;
     filterRowsByPredict(predict: (row: T) => boolean): void;
     /**
@@ -36,10 +38,29 @@ export declare class AreaModelObjectArray<T> extends AbstractAreaModel<T> implem
      */
     getFilteredRows(): T[];
     getAllRows(): T[];
+    /**
+     * Returns the first row from the filtered rows that matches the given criteria based on the provided predicate function.
+     *
+     * @param {Partial<T>} criteria - A partial object containing the search criteria
+     * @param {(criteria: Partial<T>, row: T) => boolean} predicate - A function that takes the search criteria and a row,
+     *        and returns true if the row matches the criteria
+     * @returns {T | undefined} The first matching row, or undefined if no match is found
+     */
+    findRowFromFilteredRowsByAllCriteria(criteria: Partial<T>, predicate: (criteria: Partial<T>, row: T) => boolean): T | undefined;
+    /**
+     * Searches through all rows to find a row that matches the given criteria based on the predicate function.
+     *
+     * @param {Partial<T>} criteria - A partial object containing the search criteria
+     * @param {(criteria: Partial<T>, row: T) => boolean} predicate - A function that takes the search criteria and a row,
+     *        and returns true if the row matches the criteria
+     * @returns {T | undefined} The first matching row from all rows, or undefined if no match is found
+     */
+    findRowFromAllRowsByAllCriteria(criteria: Partial<T>, predicate: (criteria: Partial<T>, row: T) => boolean): T | undefined;
     getRowHeight(_rowIndex: number): number;
     getRowByIndex(rowIndex: number): any;
     externalFilterChanged(predictFn: FilterFunction<any>): void;
     doSort(sortItems: SortItem[]): boolean;
+    sort(compareFn: (a: T, b: T) => number): void;
     getValueByT(t: T, property: string): any;
     changeColumnOrder(sourceColumnIndex: number, targetColumnIndex: number): void;
     getCustomClassesAt(rowIndex: number, _columnIndex: number): string[];

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

@@ -13,6 +13,7 @@ export declare class AreaModel implements AreaModelIf {
     rowSelectionModel: CheckboxModelIf<any> | undefined;
     changeColumnOrder(_sourceColumnIndex: number, _targetColumnIndex: number): void;
     doSort(_sortItems: SortItem[]): boolean;
+    sort(_compareFn?: (a: any, b: any) => number): void;
     externalFilterChanged<T>(_predictFn: FilterFunction<T>): void;
     getCellRenderer(_rowIndex: number, _columnIndex: number): CellRendererIf | undefined;
     getColspanAt(_rowIndex: number, _columnIndex: number): number;

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

@@ -160,4 +160,5 @@ export interface AreaModelIf {
      * @param sortItems
      */
     doSort(sortItems: SortItem[]): boolean;
+    sort(compareFn?: (a: any, b: any) => number): void;
 }

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

@@ -230,6 +230,7 @@ export declare class TableModel implements TableModelIf {
      * @return {boolean} - Returns true if the sorting is successful, otherwise false.
      */
     doSort(sortItems: SortItem[]): boolean;
+    sort(compareFn: (a: any, b: any) => number): void;
     /**
      * Returns an array of ColumnDefIf objects or undefined.
      *

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

@@ -221,6 +221,7 @@ export interface TableModelIf {
      * @return {boolean} - Returns true if the sorting was successful, false otherwise.
      */
     doSort(sortItems: SortItem[]): boolean;
+    sort(compareFn: (a: any, b: any) => number): void;
     /**
      * Retrieves the selection model associated with the component.
      *

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

@@ -172,17 +172,410 @@ export declare class TableApi {
      * or undefined if no selection model is available.
      */
     getSelectionModel(): SelectionModelIf | undefined;
+    /**
+     * Automatically resizes all columns to fit their content.
+     *
+     * @param {boolean} recalcWrappers - Determines whether to recalculate wrapper dimensions after resizing columns.
+     *                                   Default value is true.
+     *
+     * @return {void} - This method doesn't return anything.
+     */
     autoResizeColumns(recalcWrappers?: boolean): void;
+    /**
+     * Recalculates the dimensions of all wrapper elements in the table.
+     *
+     * This method is typically called after changes to the table structure or content
+     * that might affect the layout, such as resizing columns or changing row heights.
+     * It ensures that all wrapper elements are properly sized to match their content.
+     *
+     * @return {void} - This method doesn't return anything.
+     */
     recalcWrappers(): void;
+    /**
+     * Sets the width of a specific column in the table.
+     *
+     * @param {number} columnIndex - The index of the column to resize.
+     * @param {number} width - The new width to set for the column, in pixels.
+     *
+     * @return {void} - This method doesn't return anything.
+     */
     setColumnWidth(columnIndex: number, width: number): void;
+    /**
+     * Retrieves the table model that contains all data and structure information for the table.
+     *
+     * @return {TableModelIf} The table model interface that provides access to the table's data structure,
+     *                        including header, body, and footer area models.
+     */
     getTableModel(): TableModelIf;
+    /**
+     * Retrieves the area model for the body section of the table.
+     *
+     * @return {AreaModelIf} The area model interface that provides access to the table's body data,
+     *                       including rows, cells, and their values.
+     */
     getBodyModel(): AreaModelIf;
+    /**
+     * Sets the rows data for the table body, replacing any existing rows.
+     *
+     * @template T - The type of elements in the rows array
+     * @param {T[]} rows - An array of data objects to set as the table's rows
+     *
+     * @description
+     * This method replaces all existing rows in the table body with the provided array of data objects.
+     * It only works with tables that use AreaModelObjectArray as their body model.
+     *
+     * @return {void} - This method doesn't return anything.
+     *
+     * @throws {Warning} Logs a console warning if the table's body model is not an AreaModelObjectArray
+     */
     setRows<T>(rows: T[]): void;
+    /**
+     * Adds new rows to the end of the table body.
+     *
+     * @template T - The type of elements in the rows array
+     * @param {T[]} rows - An array of data objects to append to the table's existing rows
+     *
+     * @description
+     * This method appends the provided array of data objects to the end of the existing rows in the table body.
+     * It only works with tables that use AreaModelObjectArray as their body model.
+     *
+     * @return {void} - This method doesn't return anything.
+     *
+     * @throws {Warning} Logs a console warning if the table's body model is not an AreaModelObjectArray
+     */
     addRows<T>(rows: T[]): void;
+    /**
+     * Inserts new rows at a specific position in the table body.
+     *
+     * @template T - The type of elements in the rows array
+     * @param {T[]} rows - An array of data objects to insert into the table
+     * @param {number} rowIndex - The index position where the new rows should be inserted
+     *
+     * @description
+     * This method inserts the provided array of data objects at the specified index position in the table body.
+     * Existing rows at or after the specified index will be shifted down.
+     * It only works with tables that use AreaModelObjectArray as their body model.
+     *
+     * @return {void} - This method doesn't return anything.
+     *
+     * @throws {Warning} Logs a console warning if the table's body model is not an AreaModelObjectArray
+     */
     addRowsAt<T>(rows: T[], rowIndex: number): void;
+    /**
+     * Removes specified rows from the table body.
+     *
+     * @template T - The type of elements in the rows array
+     * @param {T[]} rows - An array of data objects to remove from the table
+     * @param {(a: T, b: T) => boolean} predicate - A comparison function that determines if two rows match
+     *   - Default predicate uses strict equality (===)
+     *   - The function should return true if the rows are considered a match
+     *
+     * @description
+     * This method removes rows from the table body that match any of the provided rows based on the predicate function.
+     * It only works with tables that use AreaModelObjectArray as their body model.
+     *
+     * @return {void} - This method doesn't return anything.
+     *
+     * @throws {Warning} Logs a console warning if the table's body model is not an AreaModelObjectArray
+     */
     removeRows<T>(rows: T[], predicate?: (a: T, b: T) => boolean): void;
+    /**
+     * Searches for and returns rows from the table body that match the given criteria.
+     *
+     * @template T - The type of elements in the rows array
+     *
+     * @description
+     * This method searches through the table body model for rows that match the provided criteria.
+     * It only works with tables that use AreaModelObjectArray as their body model.
+     * The method uses a predicate function to determine matches between rows.
+     *
+     * @param {T[]} rows - An array of rows to search for in the table body
+     * @param {(a: T, b: T) => boolean} predicate - A comparison function that determines if two rows match
+     *   - Default predicate uses strict equality (===)
+     *   - The function should return true if the rows are considered a match
+     *   - Parameters:
+     *     - a: The row from the table body being checked
+     *     - b: The row from the input array being searched for
+     *
+     * @returns {T[]} An array containing all matching rows found in the table body
+     *   - Returns an empty array if:
+     *     - The body model is not an instance of AreaModelObjectArray
+     *     - No matches are found
+     *
+     * @example
+     * // Find rows with simple equality comparison
+     * const matchingRows = table.findRows([row1, row2]);
+     *
+     * @example
+     * // Find rows with custom comparison logic
+     * const matchingRows = table.findRows([row1, row2], (a, b) => a.id === b.id);
+     *
+     * @throws {Warning} Logs a console warning if the table's body model is not an AreaModelObjectArray
+     */
     findRows<T>(rows: T[], predicate?: (a: T, b: T) => boolean): T[];
+    /**
+     * Searches through the filtered rows of the table to find a row that matches specific criteria.
+     * This method only works with tables that use AreaModelObjectArray as their body model.
+     *
+     * @template T - The type of the row objects in the table
+     *
+     * @param {Partial<T>} criteria - A partial object containing the search criteria.
+     *                               Only needs to include the properties you want to match against.
+     *
+     * @param {(criteria: Partial<T>, row: T) => boolean} predicate - A function that defines how to match rows against the criteria.
+     *                                                               Returns true if the row matches the criteria, false otherwise.
+     *
+     * @returns {T | undefined} The first matching row from the filtered rows, or undefined if no match is found
+     *                         or if the body model is not an instance of AreaModelObjectArray.
+     *
+     * @example
+     * ```typescript
+     * interface Person {
+     *   id: number;
+     *   name: string;
+     *   age: number;
+     * }
+     *
+     * // Find a person by exact match
+     * const criteria = { name: "John", age: 30 };
+     * const person = tableApi.findRowFromFilteredRowsByAllCriteria<Person>(
+     *   criteria,
+     *   (criteria, row) => row.name === criteria.name && row.age === criteria.age
+     * );
+     *
+     * // Find a person by partial name match
+     * const searchCriteria = { name: "Jo" };
+     * const person2 = tableApi.findRowFromFilteredRowsByAllCriteria<Person>(
+     *   searchCriteria,
+     *   (criteria, row) => row.name.toLowerCase().includes(criteria.name!.toLowerCase())
+     * );
+     *
+     * // Find a person within age range
+     * const ageCriteria = { minAge: 25, maxAge: 35 };
+     * const person3 = tableApi.findRowFromFilteredRowsByAllCriteria<Person>(
+     *   ageCriteria,
+     *   (criteria, row) => row.age >= criteria.minAge! && row.age <= criteria.maxAge!
+     * );
+     * ```
+     *
+     * @throws {Warning} Logs a warning to console if the body model is not an instance of AreaModelObjectArray
+     *
+     * @remarks
+     * - This method only searches through filtered rows (rows that are currently visible in the table)
+     * - If you need to search through all rows (including filtered out ones), use findRowFromAllRowsByAllCriteria instead
+     * - The predicate function gives you full control over how to match rows against your criteria
+     * - Returns undefined if either no match is found or if the table's body model is not compatible
+     */
+    findRowFromFilteredRowsByAllCriteria<T>(criteria: Partial<T>, predicate: (criteria: Partial<T>, row: T) => boolean): T | undefined;
+    /**
+     * Searches through all rows in the table's body model to find a row that matches specified criteria.
+     * This method works only with AreaModelObjectArray<T> body models.
+     *
+     * @template T - The type of objects/rows in the table
+     *
+     * @param {Partial<T>} criteria - A partial object containing the search criteria.
+     *                               Only needs to include the properties you want to match against.
+     *
+     * @param {(criteria: Partial<T>, row: T) => boolean} predicate - A function that defines how to match rows against the criteria.
+     *                                                               Returns true if the row matches the criteria, false otherwise.
+     *
+     * @returns {T | undefined} The first matching row, or undefined if no match is found or if the body model is not AreaModelObjectArray.
+     *
+     * @example
+     * // Find a user row by id and name
+     * const criteria = { id: 1, name: "John" };
+     * const user = tableApi.findRowFromAllRowsByAllCriteria(criteria,
+     *   (criteria, row) => row.id === criteria.id && row.name === criteria.name
+     * );
+     *
+     * @example
+     * // Find a product row with partial match on name
+     * const criteria = { name: "Phone" };
+     * const product = tableApi.findRowFromAllRowsByAllCriteria(criteria,
+     *   (criteria, row) => row.name.includes(criteria.name)
+     * );
+     *
+     * @example
+     * // Find an order with complex matching logic
+     * const criteria = { total: 100, status: "pending" };
+     * const order = tableApi.findRowFromAllRowsByAllCriteria(criteria,
+     *   (criteria, row) => {
+     *     return row.total > criteria.total &&
+     *            row.status === criteria.status &&
+     *            row.items.length > 0;
+     *   }
+     * );
+     *
+     * @throws {Warning} Logs a warning to console if the body model is not an instance of AreaModelObjectArray
+     */
+    findRowFromAllRowsByAllCriteria<T>(criteria: Partial<T>, predicate: (criteria: Partial<T>, row: T) => boolean): T | undefined;
+    /**
+     * Updates existing rows in the table body with new data.
+     *
+     * @template T - The type of elements in the rows array
+     * @param {T[]} rows - An array of data objects containing the updated values
+     * @param {(a: T, b: T) => boolean} predicate - A comparison function that determines which rows to update
+     *   - Default predicate uses strict equality (===)
+     *   - The function should return true if the row should be updated
+     *
+     * @description
+     * This method updates existing rows in the table body with new values from the provided rows array.
+     * For each row in the table, if the predicate returns true when compared with any row in the provided array,
+     * all properties from the provided row will be copied to the existing row.
+     * It only works with tables that use AreaModelObjectArray as their body model.
+     *
+     * @return {void} - This method doesn't return anything.
+     *
+     * @throws {Warning} Logs a console warning if the table's body model is not an AreaModelObjectArray
+     */
     updateRows<T>(rows: T[], predicate?: (a: T, b: T) => boolean): void;
+    /**
+     * Re-applies the current sorting configuration to the table data.
+     *
+     * @description
+     * This method triggers a re-sort of the table data using the current sorting configuration.
+     * It's useful when the underlying data has changed and needs to be re-sorted without changing
+     * the sort columns or direction.
+     *
+     * @return {void} - This method doesn't return anything.
+     */
     reSort(): void;
+    /**
+     * Sorts the table data using a custom comparison function.
+     *
+     * This method allows sorting of table rows by providing a custom comparison function. The comparison function
+     * should follow the standard JavaScript array sort comparator pattern, returning:
+     * - A negative number if the first element should be sorted before the second
+     * - A positive number if the first element should be sorted after the second
+     * - Zero if the elements are equal
+     *
+     * @param compareFn - A function that defines the sort order. The function should accept two arguments
+     *                   and return a number indicating their relative order:
+     *                   - Negative number: first argument should come before second
+     *                   - Positive number: second argument should come before first
+     *                   - Zero: elements are equal
+     *
+     * @example
+     * // Sort table rows by a specific property in ascending order
+     * table.api.sort((a, b) => {
+     *   if (a.name < b.name) return -1;
+     *   if (a.name > b.name) return 1;
+     *   return 0;
+     * });
+     *
+     * @example
+     * // Sort numbers in descending order
+     * table.api.sort((a, b) => b.value - a.value);
+     *
+     * @example
+     * // Sort with multiple criteria
+     * table.api.sort((a, b) => {
+     *   // First sort by status
+     *   const statusCompare = a.status.localeCompare(b.status);
+     *   if (statusCompare !== 0) return statusCompare;
+     *
+     *   // Then sort by name if status is equal
+     *   return a.name.localeCompare(b.name);
+     * });
+     *
+     * @example
+     * // Case-insensitive string sorting
+     * table.api.sort((a, b) =>
+     *   a.name.toLowerCase().localeCompare(b.name.toLowerCase())
+     * );
+     */
+    sort(compareFn: (a: any, b: any) => number): void;
+    /**
+     * Ensures that a specific row is visible in the viewport by scrolling if necessary.
+     * This method checks if the target row is within the currently visible range and
+     * adjusts the scroll position if it's not visible.
+     *
+     * The method performs the following:
+     * 1. Checks if the row is above the current viewport (before first visible row)
+     * 2. Checks if the row is below the current viewport (after last visible row)
+     * 3. Scrolls to make the row visible if needed
+     *
+     * @param {number} rowIndex - The index of the row to make visible
+     * @returns {boolean} Returns true if scrolling was needed and performed, false if the row was already visible
+     *
+     * @example
+     * // Ensure row 5 is visible in the viewport
+     * tableApi.ensureRowIsVisible(5);
+     *
+     * @example
+     * // Example usage in a component
+     * class MyTableComponent {
+     *   private tableApi: TableApi;
+     *
+     *   scrollToSpecificRow(rowIndex: number) {
+     *     // This will scroll the row into view if it's not visible
+     *     const didScroll = this.tableApi.ensureRowIsVisible(rowIndex);
+     *
+     *     if (didScroll) {
+     *       console.log(`Table scrolled to show row ${rowIndex}`);
+     *     } else {
+     *       console.log(`Row ${rowIndex} was already visible`);
+     *     }
+     *   }
+     * }
+     *
+     * @example
+     * // Example with row selection
+     * class TableHandler {
+     *   selectAndShowRow(rowIndex: number) {
+     *     // First ensure the row is visible
+     *     this.tableApi.ensureRowIsVisible(rowIndex);
+     *
+     *     // Then perform selection
+     *     this.selectionModel.selectRow(rowIndex);
+     *   }
+     * }
+     *
+     * @throws {Error} Implicitly may throw if rowIndex is not a number or if required properties are undefined
+     *
+     * @see {@link scrollToIndex} - The underlying method used for scrolling
+     * @see {@link getDisplayedRowCount} - Related method for getting visible row count
+     */
+    ensureRowIsVisible(rowIndex: number): boolean;
+    /**
+     * Retrieves the number of rows currently displayed in the table.
+     *
+     * @description
+     * This method returns the count of rows that are currently visible in the table after
+     * applying any filtering, pagination, or other visibility constraints.
+     *
+     * @return {number} The number of rows currently displayed in the table.
+     */
     getDisplayedRowCount(): number;
+    /**
+     * Returns the index of the first visible row in the table's viewport.
+     *
+     * This method retrieves the first visible row index from the table's scope, which is useful
+     * for virtual scrolling and viewport-related calculations. The index represents the topmost
+     * visible row in the current scroll position of the table.
+     *
+     * This value is maintained internally by the table and updated during scrolling operations.
+     * It's particularly important for:
+     * - Virtual scrolling optimization
+     * - Calculating visible range of rows
+     * - Viewport-related operations
+     * - Scroll position restoration
+     *
+     * @returns {number} The index of the first visible row in the table's viewport.
+     *                   Returns -1 if no rows are visible or if the table is not yet rendered.
+     *
+     * @example
+     * ```typescript
+     * // Get the first visible row index
+     * const tableApi = new TableApi(tableScope);
+     * const firstVisibleIndex = tableApi.getFirstVisibleRowIndex();
+     *
+     * // Use the index for scroll position calculations
+     * if (firstVisibleIndex >= 0) {
+     *   // Perform operations with the first visible row
+     *   console.log(`First visible row index: ${firstVisibleIndex}`);
+     * }
+     * ```
+     */
+    getFirstVisibleRowIndex(): number;
 }

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

@@ -297,5 +297,59 @@ export declare class TableScope extends RenderScope implements OnActionTriggered
     autoResizeColumns(recalcWrappers?: boolean): void;
     recalcWrappers(): void;
     reSort(): void;
+    sort(compareFn: (a: any, b: any) => number): void;
     getDisplayedRowCount(): number;
+    /**
+     * Ensures that a specific row is visible in the viewport by scrolling if necessary.
+     * This method checks if the target row is within the currently visible range and
+     * adjusts the scroll position if it's not visible.
+     *
+     * The method performs the following:
+     * 1. Checks if the row is above the current viewport (before first visible row)
+     * 2. Checks if the row is below the current viewport (after last visible row)
+     * 3. Scrolls to make the row visible if needed
+     *
+     * @param {number} rowIndex - The index of the row to make visible
+     * @returns {boolean} Returns true if scrolling was needed and performed, false if the row was already visible
+     *
+     * @example
+     * // Ensure row 5 is visible in the viewport
+     * tableScope.ensureRowIsVisible(5);
+     *
+     * @example
+     * // Example usage in a component
+     * class MyTableComponent {
+     *   private tableScope: TableScope;
+     *
+     *   scrollToSpecificRow(rowIndex: number) {
+     *     // This will scroll the row into view if it's not visible
+     *     const didScroll = this.tableScope.ensureRowIsVisible(rowIndex);
+     *
+     *     if (didScroll) {
+     *       console.log(`Table scrolled to show row ${rowIndex}`);
+     *     } else {
+     *       console.log(`Row ${rowIndex} was already visible`);
+     *     }
+     *   }
+     * }
+     *
+     * @example
+     * // Example with row selection
+     * class TableHandler {
+     *   selectAndShowRow(rowIndex: number) {
+     *     // First ensure the row is visible
+     *     this.tableScope.ensureRowIsVisible(rowIndex);
+     *
+     *     // Then perform selection
+     *     this.selectionModel.selectRow(rowIndex);
+     *   }
+     * }
+     *
+     * @throws {Error} Implicitly may throw if rowIndex is not a number or if required properties are undefined
+     *
+     * @see {@link scrollToIndex} - The underlying method used for scrolling
+     * @see {@link getDisplayedRowCount} - Related method for getting visible row count
+     */
+    ensureRowIsVisible(rowIndex: number): boolean;
+    getFirstVisibleRowIndex(): number;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guiexpert/table",
-  "version": "1.1.72",
+  "version": "1.1.75",
   "private": false,
   "type": "module",
   "main": "./index.js",