@guiexpert/table 1.1.13 → 1.1.15

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

@@ -47,6 +47,14 @@ export declare class RenderScope extends EleScope {
     private removables;
     constructor(hostElement: HTMLDivElement, tableModel: TableModelIf, dom: ConvenienceDomService, tableOptions: TableOptionsIf);
     isEditing(): boolean;
+    /**
+     * Resets the editor renderer by clearing its values and state.
+     *
+     * @function resetEditorRenderer
+     * @memberof ClassName
+     *
+     * @returns {void}
+     */
     resetEditorRenderer(): void;
     /**
      * Clears the selection in the component.
@@ -56,19 +64,109 @@ export declare class RenderScope extends EleScope {
      * @return {void}
      */
     clearSelection(rerender?: boolean): void;
+    /**
+     * Initializes and renders the editor for a specified row and column index.
+     *
+     * @param {number} rowIdx - The index of the row.
+     * @param {number} colIdx - The index of the column.
+     */
     initRenderEditor(rowIdx: number, colIdx: number): void;
+    /**
+     * Adjusts the content after scrolling and initiates a repaint of the component.
+     *
+     * @return {void}
+     */
     repaint(): void;
+    /**
+     * Repaints the UI by resetting the size of the wrapper div,
+     * adjusting the containers and rows, and performing additional adjustments
+     * after scrolling.
+     *
+     * @return {void} This method does not return any value.
+     */
     repaintHard(): void;
+    /**
+     * Adjusts the table after scrolling. This method performs various adjustments
+     * to the table's appearance and behavior after a scroll event occurs.
+     */
     adjustAfterScrolling(): void;
+    /**
+     * Checks if the scroll position should be saved and saves it.
+     *
+     * @return {void}
+     */
     checkForScrollPosSaving(): void;
+    /**
+     * Updates the cells in the table with the provided values and optionally repaints all cells.
+     *
+     * @param {TableCellUpdateEventIf[]} events - The array of events containing information about the cells to update.
+     * @param {boolean} repaintAll - Optional. If true, repaints all cells after updating. Defaults to false.
+     *
+     * @returns {void}
+     */
     updateCells(events: TableCellUpdateEventIf[], repaintAll?: boolean): void;
+    /**
+     * Rerenders the content of a table cell based on the given parameters.
+     *
+     * @param {TableCellUpdateEventIf} area - The area of the table.
+     * @param {number} rowIndex - The index of the row.
+     * @param {number} columnIndex - The index of the column.
+     * @param {any} value - The new value to be displayed in the cell.
+     * @param {string[]} cssClasses - An array of CSS classes to be applied to the cell.
+     */
     rerenderCellContent({ area, rowIndex, columnIndex, value, cssClasses }: TableCellUpdateEventIf): void;
+    /**
+     * Stores the widths of all columns in the table.
+     *
+     * @protected
+     * @function storeColumnWidths
+     * @returns {void}
+     */
     protected storeColumnWidths(): void;
     protected getAreaAndSideIdentByAttr(srcElement: HTMLElement): [AreaIdent | undefined, SideIdent | undefined];
+    /**
+     * Retrieves the specified area from the grid layout.
+     *
+     * @param {string} areaIdent - The identifier for the area ('header', 'body', or 'footer').
+     * @param {string} sideIdent - The identifier for the side of the area ('west', 'center', or 'east').
+     * @protected
+     * @returns {HTMLElement} - The requested area element.
+     * @throws {Error} - If the area identifier or side identifier is incorrect.
+     */
     protected getArea(areaIdent: AreaIdent, sideIdent: SideIdent): DivScope;
+    /**
+     * Adjusts the body of the table.
+     *
+     * @protected
+     * @return {void}
+     */
     protected adjustBody(): void;
+    /**
+     * Returns a number value extracted from the specified attribute of the source element.
+     *
+     * @param {HTMLElement} srcElement - The source element from which to extract the attribute value.
+     * @param {string} key - The attribute key to extract the value from.
+     * @returns {number} - The extracted number value, or -1 if the attribute was not found or not a valid number.
+     * @protected
+     */
     protected getNumberByAttr(srcElement: HTMLElement, key: string): number;
+    /**
+     * Retrieves the value of the specified attribute from the nearest ancestor element that has the attribute.
+     *
+     * @param {HTMLElement} srcElement - The source element from which to start searching for the nearest ancestor element.
+     * @param {string} key - The name of the attribute to retrieve.
+     * @returns {string} The value of the specified attribute, or an empty string if the attribute is not found.
+     * @protected
+     */
     protected getStringByAttr(srcElement: HTMLElement, key: string): string;
+    /**
+     * Adjusts the layout and positioning of the specified area in the table.
+     * This method is used internally and should not be called directly.
+     *
+     * @param {AreaIdent} areaIdent - The identifier of the area to adjust (e.g. header, body, footer).
+     * @param {number} [yStart=0] - The starting y-position for the layout adjustments.
+     * @protected
+     */
     protected adjustArea(areaIdent: AreaIdent, yStart?: number): void;
     /**
      * Draws big cells (rowspan and or colspan) in body/center
@@ -81,18 +179,97 @@ export declare class RenderScope extends EleScope {
      * @protected
      */
     protected drawBigCell(range: CellRange, xStart: number, yStart: number, areaModel: AreaModelIf, parentDiv: HTMLDivElement, sideIdent: SideIdent): void;
+    /**
+     * Finds the row index of an important rowspan cell in a given area model.
+     *
+     * @param {AreaModelIf} areaModel - The area model to search in.
+     * @param {number} rowIndex - The current row index.
+     * @param {number} colIndex - The current column index.
+     * @returns {number} - The row index of the important rowspan cell, or -1 if not found.
+     * @protected
+     */
     protected findRowOfImportantRowspanCell(areaModel: AreaModelIf, rowIndex: number, colIndex: number): number;
+    /**
+     * Adjusts the columns to fit the width of the row's parent element.
+     *
+     * @param {ArgsAdjustColumnsToRowParentParams} params - The parameters for adjusting the columns.
+     * @protected
+     * @return {void}
+     */
     protected adjustColumnsToRowParent({ areaIdent, sideIdent, areaModel, geo, parent, rowIndex, columnIndexStart, columnIndexEnd, verticalFixed, lastRowOfModel }: ArgsAdjustColumnsToRowParentParams): void;
+    /**
+     * Retrieves the column index of the tree arrow column in the table.
+     *
+     * @protected
+     *
+     * @returns {0 | 1} The column index of the tree arrow column.
+     *                Returns 0 if the checkbox is not visible,
+     *                otherwise returns 1.
+     */
     protected getTreeArrowColumnIndex(): 0 | 1;
     protected addAndRenderCellDiv({ areaModel, areaIdent, sideIdent, rowIndex, index, left, width, height, top, parent, lastRowOfModel }: ArgsRenderCellDiv): [HTMLDivElement, RendererCleanupFnType | undefined];
+    /**
+     * Applies CSS classes to an HTML element.
+     *
+     * @param {HTMLDivElement} ele - The HTML element to which CSS classes will be applied.
+     * @param {Object.<string, boolean>} cssClasses - An object containing CSS class names as keys and boolean values indicating whether to apply or remove the class.
+     * @protected
+     */
     protected applyCssClasses(ele: HTMLDivElement, cssClasses?: {
         [key: string]: boolean;
     }): void;
+    /**
+     * Retrieves the column widths of a table within a specified range.
+     *
+     * @param {number} startIndex - The index of the first column to retrieve the width of.
+     * @param {number} endIndex - The index of the last column to retrieve the width of.
+     *
+     * @return {number[]} An array containing the widths of the columns within the specified range.
+     */
     protected getColumnWidths(startIndex: number, endIndex: number): number[];
+    /**
+     * Retrieves the heights of rows within a specified range.
+     *
+     * @param {number} startIndex - The index of the first row in the range.
+     * @param {number} endIndex - The index of the last row in the range.
+     * @param {AreaModelIf} areaModel - The area model.
+     * @return {number[]} - An array containing the heights of the rows within the specified range.
+     */
     protected getRowHeights(startIndex: number, endIndex: number, areaModel: AreaModelIf): number[];
+    /**
+     * Adjusts the position and size of the hover row based on the mouse move event.
+     *
+     * @param {GeMouseEvent} mouseMoveEvent - The mouse move event.
+     *
+     * @return {void}
+     */
     protected adjustHoverRows(mouseMoveEvent: GeMouseEvent): void;
+    /**
+     * Hides the hover row by applying 'display: none' style to it.
+     *
+     * @protected
+     * @function
+     * @name hideHoverRow
+     * @memberof ClassName
+     *
+     * @returns {void}
+     */
     protected hideHoverRow(): void;
+    /**
+     * Adjusts the position and size of the hover column based on the mouse move event.
+     *
+     * @param {GeMouseEvent} mouseMoveEvent - The mouse move event object.
+     */
     protected adjustHoverColumns(mouseMoveEvent: GeMouseEvent): void;
+    /**
+     * Hide hover column.
+     *
+     * This method hides the hover column by applying a style of 'display: none'
+     * to the element representing the hover column.
+     *
+     * @protected
+     * @memberof ClassName
+     */
     protected hideHoverColumn(): void;
     /**
      * Executes a function after a specified delay, ensuring that the function is called only once within that delay period.
@@ -103,12 +280,100 @@ export declare class RenderScope extends EleScope {
      * @return {undefined}
      */
     protected debounce(fn: () => void, delay?: number): void;
+    /**
+     * Adjusts the dragging column during a mouse move event.
+     *
+     * @param {GeMouseEvent} mouseMoveEvent - The mouse move event.
+     * @param {number} sourceColumnIndex - The index of the source column.
+     * @param {boolean} firstDraggingRendering - Indicates if it's the first rendering of the dragging column.
+     */
     protected adjustDraggingColumn(mouseMoveEvent: GeMouseEvent, sourceColumnIndex: number, firstDraggingRendering: boolean): void;
+    /**
+     * Renders the content of a dragging column.
+     *
+     * @param {GeoData} columnGeo - The geographic data of the column.
+     *
+     * @returns {number} The y-coordinate of the rendered content.
+     */
     protected renderContentOfDraggingColumn(columnGeo: GeoData): void;
+    /**
+     * Renders the content of the dragging column for a specific area.
+     *
+     * @param {GeoData} columnGeo - The geometry data of the dragging column.
+     * @param {AreaIdent} areaIdent - The identifier of the area.
+     * @param {number} [y=0] - The starting y-position.
+     * @return {number} The final y-position after rendering all the content.
+     */
     protected renderContentOfDraggingColumnForArea(columnGeo: GeoData, areaIdent: AreaIdent, y?: number): number;
+    /**
+     * Hides the dragging column by applying a 'display: none' style to it.
+     * This method is protected and can only be accessed within the class.
+     *
+     * @return {void}
+     */
     protected hideDraggingColumn(): void;
+    /**
+     * Renders a draggable target div element.
+     *
+     * @param {HTMLDivElement} parent - The parent element where the target div will be appended to.
+     * @param {number} left - The left position of the target div in pixels.
+     * @param {number} top - The top position of the target div in pixels.
+     * @param {number} width - The width of the target div in pixels.
+     * @param {number} height - The height of the target div in pixels.
+     * @return {HTMLDivElement} - The rendered draggable target div element.
+     */
     private renderDragTargetDiv;
+    /**
+     * Render selected background div.
+     *
+     * @private
+     * @param {boolean} skip - Whether to skip rendering.
+     * @param {boolean} renderSelection - Whether to render the selection.
+     * @param {SideIdent} sideIdent - The side identifier.
+     * @param {AreaModelIf} areaModel - The area model.
+     * @param {number} rowIndex - The row index.
+     * @param {number} index - The index.
+     * @param {HTMLDivElement} parent - The parent div element.
+     * @param {number} left - The left position.
+     * @param {number} top - The top position.
+     * @param {number} width - The width of the div.
+     * @param {number} height - The height of the div.
+     * @returns {boolean} - Whether the cell is selected.
+     */
     private renderSelectedBackgroundDiv;
+    /**
+     * Renders a cell in the grid.
+     *
+     * @param {ArgsRenderCell} args - The arguments for rendering the cell.
+     * @param {AreaModel} args.areaModel - The area model of the grid.
+     * @param {string} args.areaIdent - The identifier of the area.
+     * @param {string} args.sideIdent - The identifier of the side.
+     * @param {number} args.rowIndex - The index of the row.
+     * @param {number} args.columnIndex - The index of the column.
+     * @param {number} args.left - The left position of the cell.
+     * @param {number} args.top - The top position of the cell.
+     * @param {number} args.width - The width of the cell.
+     * @param {number} args.height - The height of the cell.
+     * @param {HTMLElement} args.parent - The parent element of the cell.
+     * @param {boolean} args.cellSelected - Indicates if the cell is selected.
+     * @param {boolean} args.lastRowOfModel - Indicates if the cell is in the last row of the model.
+     *
+     * @returns {void}
+     */
     private renderCell;
+    /**
+     * Render the header cell resize handle.
+     *
+     * @param {ArgsRenderHeaderCellResizeHandle} args - The arguments for rendering the handle.
+     * @param {number} args.rowIndex - The index of the row.
+     * @param {number} args.columnIndex - The index of the column.
+     * @param {number} args.cellLeft - The left position of the cell.
+     * @param {number} args.cellTop - The top position of the cell.
+     * @param {number} args.cellWidth - The width of the cell.
+     * @param {number} args.cellHeight - The height of the cell.
+     * @param {HTMLElement} args.parent - The parent element to append the handle to.
+     *
+     * @return {void}
+     */
     private renderHeaderCellResizeHandle;
 }

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

@@ -15,9 +15,16 @@ export declare class SelectionModel implements SelectionModelIf {
     clear(): void;
     hasSelection(): boolean;
     selectAll(): void;
+    isAllSelected(): boolean;
     addSelection(range: CellRange): void;
     removeSelection(range: CellRange): void;
     togglePoint(row: number, col: number): void;
     isSelected(row: number, col: number): boolean;
+    /**
+     * Retrieves the merged row indices from the given range selection.
+     *
+     * @returns {number[]} Array of merged row indices
+     */
+    getMergedRowIndices(): number[];
     private addRange;
 }

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

@@ -1,13 +1,34 @@
 import { CellRange } from "../data/common/cell-range";
 export interface SelectionModelIf {
+    /**
+     * Toggles the selection state of a point at the specified row and column in a grid.
+     *
+     * @param {number} row - The row index of the point to toggle.
+     * @param {number} col - The column index of the point to toggle.
+     * @return {void}
+     */
     togglePoint(row: number, col: number): void;
+    /**
+     * Checks if a specific cell in a grid is selected.
+     *
+     * @param {number} row - The row index of the cell to check.
+     * @param {number} col - The column index of the cell to check.
+     * @returns {boolean} - Returns true if the cell is selected, otherwise false.
+     */
     isSelected(row: number, col: number): boolean;
+    /**
+     * Returns an array of CellRange objects representing the selections.
+     *
+     * @return {CellRange[]} Array of CellRange objects representing the ranges.
+     */
     getRanges(): CellRange[];
+    getMergedRowIndices(): number[];
     clear(): void;
     hasSelection(): boolean;
     addSelection(range: CellRange): void;
     removeSelection(range: CellRange): void;
     getSelectionCount(rowIndex: number, columnIndex: number): number;
     selectAll(): void;
+    isAllSelected(): boolean;
     firstClick(rowIndex: number, columnIndex: number): void;
 }

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

@@ -4,8 +4,9 @@ import { TableCellUpdateEventIf } from "./data/common/event/input/table-cell-upd
 import { SelectionModel } from './selection/selection-model';
 import { ActionId } from './action/action-id.type';
 import { ShortcutActionIdMapping } from './action/shortcut-actionid-mapping.type';
+import { SelectionModelIf } from './selection/selection-model.if';
 export declare class TableApi {
-    private readonly tableScope;
+    readonly tableScope: TableScope;
     constructor(tableScope: TableScope);
     /**
      * Updates the cells in the table based on the provided events.
@@ -90,6 +91,14 @@ export declare class TableApi {
      * to update and redraw the table based on the latest data.
      */
     repaint(): void;
+    /**
+     * Repaints the table scope with hard repaint.
+     * Repaints the UI by resetting the size of the wrapper div,
+     * adjusting the containers and rows, and performing additional adjustments
+     * after scrolling.
+     *
+     * @return {void}
+     */
     repaintHard(): void;
     /**
      * Clears the current selection of the table.
@@ -127,4 +136,17 @@ export declare class TableApi {
      * @return {Promise<string>} - A promise that resolves with the copied data as a string.
      */
     copyToClipboard(): Promise<string>;
+    /**
+     * Retrieves the current scope of the table.
+     *
+     * @returns {TableScope} The current scope of the table.
+     */
+    getTableScope(): TableScope;
+    /**
+     * Retrieves the selection model of the table.
+     *
+     * @return {SelectionModelIf | undefined} The selection model of the table,
+     * or undefined if no selection model is available.
+     */
+    getSelectionModel(): SelectionModelIf | undefined;
 }

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

@@ -22,12 +22,30 @@ import { MouseTargetData } from './data/event/mouse-target-data';
 import { SelectionModelIf } from './selection/selection-model.if';
 import { FocusModelIf } from './focus/focus-model.if';
 /**
- * Creates a TableScope instance.
- * @param {HTMLDivElement} hostElement - The host element.
- * @param {TableModelIf} tableModel - The table model object.
- * @param {TableOptionsIf} [tableOptions=new TableOptions()] - Optional table options object.
- * @param {EventListenerIf} [eventListener=new EventAdapter()] - Optional event listener object.
- * @param {DomServiceIf} [domService=new SimpleDomService()] - Optional DOM service object.
+ * The TableScope class extends the RenderScope class and provides functionality for rendering and interacting with a table.
+ *
+ * @property {LicenseManager} licenseManager - An instance of LicenseManager.
+ * @property {MouseHandler} mouseHandler - An instance of MouseHandler to handle mouse events.
+ * @property {InputHandler} inputHandler - An instance of InputHandler to handle keyboard inputs.
+ * @property {ShortcutService} shortcutService - An instance of ShortcutService to register and handle shortcuts.
+ * @property {StoreStateCollapsedExpandService | undefined} storeStateCollapsedExpandService - A service to manage and restore the collapsed or expanded state of the table's rows.
+ * @property {StoreStateSortingService | undefined} storeSortingService - A service to manage and restore the sort state of the table's columns.
+ * @property {SelectionService} selectionService - An instance of SelectionService to manage cell selection in the table.
+ * @property {GeKeyEvent | undefined} keyEvent - An object representing the last processed keyboard event.
+ * @property {TableApi} api - An instance of TableApi, providing an API for table interactions.
+ *
+ * Additional properties related to the dragging state of the table:
+ * - mouseStartAction: The action performed at the start of a mouse drag operation.
+ * - mouseStartWidth: The initial width of an element at the start of a resizing drag operation.
+ * - mouseStartColumnIndex: The index of the column at the start of a resizing drag operation.
+ * - dragFrom: The initial cell index of a drag operation.
+ * - dragTo: The current cell index of a drag operation.
+ * - lastDragFrom: The previous initial cell index of a drag operation.
+ * - lastDragTo: The previous current cell index of a drag operation.
+ * - firstDraggingRendering: A boolean indicating if this is the first render during the current drag operation.
+ *
+ * Methods: Please refer to the documentation of the superclass RenderScope for the inherited methods.
+ * The TableScope class introduces additional methods not listed here. Please refer to the source code for further details.
  */
 export declare class TableScope extends RenderScope implements OnActionTriggeredIf {
     protected readonly eventListener: EventListenerIf;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guiexpert/table",
-  "version": "1.1.13",
+  "version": "1.1.15",
   "dependencies": {
     "tslib": "^2.3.0"
   },