handsontable 18.0.0 → 18.1.0-rc7

package/3rdparty/walkontable/src/table.d.ts

@@ -1,741 +0,0 @@
-import type { DataAccessObject, WalkontableInstance, DomBindings } from './types';
-import type Settings from './settings';
-import ColumnFilter from './filter/column';
-import RowFilter from './filter/row';
-import { Renderer } from './renderer';
-import ColumnUtils from './utils/column';
-import RowUtils from './utils/row';
-/**
- * @todo These mixes are never added to the class Table, however their members are used here.
- * @todo Continue: Potentially it works only, because some of these mixes are added to every inherited class.
- * @todo Refactoring, move code from `if(this.isMaster)` into MasterTable, and others like that.
- * @mixes stickyColumnsStart
- * @mixes stickyRowsBottom
- * @mixes stickyRowsTop
- * @mixes calculatedRows
- * @mixes calculatedColumns
- * @abstract
- */
-declare class Table {
-    /**
-     * The walkontable settings.
-     *
-     * @protected
-     * @type {Settings}
-     */
-    wtSettings: Settings;
-    /**
-     * The DOM bindings for the table.
-     *
-     * @type {DomBindings}
-     */
-    domBindings: DomBindings;
-    /**
-     * The table body element (TBODY).
-     *
-     * @type {HTMLTableSectionElement | null}
-     */
-    TBODY: HTMLTableSectionElement | null;
-    /**
-     * The table head element (THEAD).
-     *
-     * @type {HTMLTableSectionElement | null}
-     */
-    THEAD: HTMLTableSectionElement | null;
-    /**
-     * The column group element (COLGROUP).
-     *
-     * @type {HTMLTableColElement | null}
-     */
-    COLGROUP: HTMLTableColElement | null;
-    /**
-     * Indicates if the table has height bigger than 0px.
-     *
-     * @type {boolean}
-     */
-    hasTableHeight: boolean;
-    /**
-     * Indicates if the table has width bigger than 0px.
-     *
-     * @type {boolean}
-     */
-    hasTableWidth: boolean;
-    /**
-     * Indicates if the table is visible. By visible, it means that the holder
-     * element has CSS 'display' property different than 'none'.
-     *
-     * @type {boolean}
-     */
-    isTableVisible: boolean;
-    /**
-     * The offset of the table element.
-     *
-     * @type {number | { top: number; left: number }}
-     */
-    tableOffset: number | {
-        top: number;
-        left: number;
-    };
-    /**
-     * The offset of the holder element.
-     *
-     * @type {number | { top: number; left: number }}
-     */
-    holderOffset: number | {
-        top: number;
-        left: number;
-    };
-    /**
-     * The borders holder element.
-     *
-     * @type {HTMLElement}
-     */
-    bordersHolder?: HTMLElement;
-    /**
-     * Indicates if this instance is of type MasterTable (i.e. it is NOT an overlay).
-     *
-     * @type {boolean}
-     */
-    isMaster: boolean;
-    /**
-     * The name of the table (overlay name or 'master').
-     *
-     * @type {string}
-     */
-    name: string;
-    /**
-     * The data access object.
-     *
-     * @type {DataAccessObject}
-     */
-    dataAccessObject: DataAccessObject;
-    /**
-     * Function which returns the proper facade.
-     *
-     * @type {Function}
-     */
-    facadeGetter: Function;
-    /**
-     * The Walkontable instance.
-     *
-     * @type {WalkontableInstance}
-     */
-    instance: WalkontableInstance;
-    /**
-     * The Walkontable instance (legacy alias for instance).
-     *
-     * @type {WalkontableInstance}
-     */
-    wot: WalkontableInstance;
-    /**
-     * The table element.
-     *
-     * @type {HTMLTableElement}
-     */
-    TABLE: HTMLTableElement;
-    /**
-     * The spreader element.
-     *
-     * @type {HTMLElement}
-     */
-    spreader: HTMLElement;
-    /**
-     * The hider element.
-     *
-     * @type {HTMLElement}
-     */
-    hider: HTMLElement;
-    /**
-     * The holder element.
-     *
-     * @type {HTMLElement}
-     */
-    holder: HTMLElement;
-    /**
-     * The root element.
-     *
-     * @type {HTMLElement}
-     */
-    wtRootElement: HTMLElement;
-    /**
-     * The row filter.
-     *
-     * @type {RowFilter | null}
-     */
-    rowFilter: RowFilter | null;
-    /**
-     * The column filter.
-     *
-     * @type {ColumnFilter | null}
-     */
-    columnFilter: ColumnFilter | null;
-    /**
-     * Indicates if the header width should be corrected.
-     *
-     * @type {boolean}
-     */
-    correctHeaderWidth: boolean;
-    /**
-     * The row utilities.
-     *
-     * @type {RowUtils}
-     */
-    rowUtils: RowUtils;
-    /**
-     * The column utilities.
-     *
-     * @type {ColumnUtils}
-     */
-    columnUtils: ColumnUtils;
-    /**
-     * The table renderer.
-     *
-     * @type {Renderer}
-     */
-    tableRenderer: Renderer;
-    /**
-     * Gets the index of the first rendered row.
-     *
-     * @type {() => number}
-     */
-    getFirstRenderedRow: () => number;
-    /**
-     * Gets the index of the first visible row.
-     *
-     * @type {() => number}
-     */
-    getFirstVisibleRow: () => number;
-    /**
-     * Gets the index of the first partially visible row.
-     *
-     * @type {() => number}
-     */
-    getFirstPartiallyVisibleRow: () => number;
-    /**
-     * Gets the index of the last rendered row.
-     *
-     * @type {() => number}
-     */
-    getLastRenderedRow: () => number;
-    /**
-     * Gets the index of the last visible row.
-     *
-     * @type {() => number}
-     */
-    getLastVisibleRow: () => number;
-    /**
-     * Gets the index of the last partially visible row.
-     *
-     * @type {() => number}
-     */
-    getLastPartiallyVisibleRow: () => number;
-    /**
-     * Gets the count of rendered rows.
-     *
-     * @type {() => number}
-     */
-    getRenderedRowsCount: () => number;
-    /**
-     * Gets the count of visible rows.
-     *
-     * @type {() => number}
-     */
-    getVisibleRowsCount: () => number;
-    /**
-     * Gets the count of column headers.
-     *
-     * @type {() => number}
-     */
-    getColumnHeadersCount: () => number;
-    /**
-     * Gets the index of the first rendered column.
-     *
-     * @type {() => number}
-     */
-    getFirstRenderedColumn: () => number;
-    /**
-     * Gets the index of the first visible column.
-     *
-     * @type {() => number}
-     */
-    getFirstVisibleColumn: () => number;
-    /**
-     * Gets the index of the first partially visible column.
-     *
-     * @type {() => number}
-     */
-    getFirstPartiallyVisibleColumn: () => number;
-    /**
-     * Gets the index of the last rendered column.
-     *
-     * @type {() => number}
-     */
-    getLastRenderedColumn: () => number;
-    /**
-     * Gets the index of the last visible column.
-     *
-     * @type {() => number}
-     */
-    getLastVisibleColumn: () => number;
-    /**
-     * Gets the index of the last partially visible column.
-     *
-     * @type {() => number}
-     */
-    getLastPartiallyVisibleColumn: () => number;
-    /**
-     * Gets the count of rendered columns.
-     *
-     * @type {() => number}
-     */
-    getRenderedColumnsCount: () => number;
-    /**
-     * Gets the count of visible columns.
-     *
-     * @type {() => number}
-     */
-    getVisibleColumnsCount: () => number;
-    /**
-     * Gets the count of row headers.
-     *
-     * @type {() => number}
-     */
-    getRowHeadersCount: () => number;
-    /**
-     * Aligns overlays with the trimming container.
-     *
-     * @returns {void}
-     */
-    alignOverlaysWithTrimmingContainer(): void;
-    /**
-     * Marks oversized column headers.
-     *
-     * @returns {void}
-     */
-    markOversizedColumnHeaders(): void;
-    /**
-     *
-     * @abstract
-     * @param {TableDao} dataAccessObject The data access object.
-     * @param {FacadeGetter} facadeGetter Function which return proper facade.
-     * @param {DomBindings} domBindings Bindings into DOM.
-     * @param {Settings} wtSettings The Walkontable settings.
-     * @param {'master'|CLONE_TYPES_ENUM} name Overlay name.
-     */
-    constructor(dataAccessObject: DataAccessObject, facadeGetter: Function, domBindings: DomBindings, wtSettings: Settings, name: string);
-    /**
-     * Returns a boolean that is true if this Table represents a specific overlay, identified by the overlay name.
-     * For MasterTable, it returns false.
-     *
-     * @param {string} overlayTypeName The overlay type.
-     * @returns {boolean}
-     */
-    is(overlayTypeName: string): boolean;
-    /**
-     *
-     */
-    fixTableDomTree(): void;
-    /**
-     * @param {HTMLTableElement} table An element to process.
-     * @returns {HTMLElement}
-     */
-    createSpreader(table: HTMLTableElement): HTMLDivElement | undefined;
-    /**
-     * @param {HTMLElement} spreader An element to the hider element is injected.
-     * @returns {HTMLElement}
-     */
-    createHider(spreader: HTMLElement): HTMLDivElement | undefined;
-    /**
-     *
-     * @param {HTMLElement} hider An element to the holder element is injected.
-     * @returns {HTMLElement}
-     */
-    createHolder(hider: HTMLElement): HTMLDivElement | undefined;
-    /**
-     * Redraws the table.
-     *
-     * @param {boolean} [fastDraw=false] If TRUE, will try to avoid full redraw and only update the border positions.
-     *                                   If FALSE or UNDEFINED, will perform a full redraw.
-     * @returns {Table}
-     */
-    draw(fastDraw?: boolean): this;
-    /**
-     * @param {number} col The visual column index.
-     */
-    markIfOversizedColumnHeader(col: number): void;
-    /**
-     *
-     */
-    adjustColumnHeaderHeights(): void;
-    /**
-     * After the master table applies `oversizedColumnHeaders` via `adjustColumnHeaderHeights`,
-     * the actual THEAD row heights may exceed the stored values when header content (e.g.,
-     * wrapping text) pushes cells taller than the configured `columnHeaderHeight`. This method
-     * re-reads the rendered THEAD row heights and updates `oversizedColumnHeaders` so that
-     * overlay tables receive the correct values during their own `adjustColumnHeaderHeights`.
-     */
-    syncOversizedColumnHeadersWithDOM(): void;
-    /**
-     * Frozen column headers (e.g., with `white-space: normal`) are rendered only in the frozen
-     * overlays, never in the master table's THEAD. When such a header is taller than the headers
-     * of the scrollable columns, the master and top overlay THEADs render shorter than the corner
-     * and inline-start overlays, so the frozen overlay body rows sit shifted against the master.
-     * The gap can be sub-pixel: under browser zoom the frozen header content is a fraction of a
-     * pixel taller than the applied height, and that fraction accumulates into a visible 1px shift.
-     *
-     * This method runs after the frozen overlays have rendered. It reads the corner overlay's
-     * content-driven THEAD row heights with sub-pixel precision and forces the matching master and
-     * top overlay header cells to the same height so every overlay THEAD ends up the same height
-     * and the body rows stay pixel-aligned.
-     *
-     * It deliberately does NOT write to `wtViewport.oversizedColumnHeaders`. That cache is applied
-     * back to the corner overlay on the next render; growing it here would inflate the corner cell,
-     * which would then be re-measured taller, ratcheting the height up every render. Reading the
-     * corner's natural (content-driven) height and only adjusting the master/top side keeps the
-     * synchronization stable and lets the header shrink again when the content allows.
-     */
-    syncOversizedColumnHeadersWithFrozenOverlays(): void;
-    /**
-     * Resets cache of row heights. The cache should be cached for each render cycle in a case
-     * when new cell values have content which increases/decreases cell height.
-     */
-    resetOversizedRows(): void;
-    /**
-     * Get cell element at coords.
-     * Negative coords.row or coords.col are used to retrieve header cells. If there are multiple header levels, the
-     * negative value corresponds to the distance from the working area. For example, when there are 3 levels of column
-     * headers, coords.col=-1 corresponds to the most inner header element, while coords.col=-3 corresponds to the
-     * outmost header element.
-     *
-     * In case an element for the coords is not rendered, the method returns an error code.
-     * To produce the error code, the input parameters are validated in the order in which they
-     * are given. Thus, if both the row and the column coords are out of the rendered bounds,
-     * the method returns the error code for the row.
-     *
-     * @param {CellCoords} coords The cell coordinates.
-     * @returns {HTMLElement|number} HTMLElement on success or Number one of the exit codes on error:
-     *  -1 row before viewport
-     *  -2 row after viewport
-     *  -3 column before viewport
-     *  -4 column after viewport.
-     */
-    getCell(coords: {
-        row: number | null;
-        col: number | null;
-    }): -1 | HTMLElement | -5 | -2 | -3 | -4;
-    /**
-     * Get the DOM element of the row with the provided index.
-     *
-     * @param {number} rowIndex Row index.
-     * @returns {HTMLTableRowElement|boolean} Return the row's DOM element or `false` if the row with the provided
-     * index doesn't exist.
-     */
-    getRow(rowIndex: number): HTMLTableRowElement | false;
-    /**
-     * GetColumnHeader.
-     *
-     * @param {number} col Column index.
-     * @param {number} [level=0] Header level (0 = most distant to the table).
-     * @returns {object} HTMLElement on success or undefined on error.
-     */
-    getColumnHeader(col: number, level?: number): HTMLElement | undefined;
-    /**
-     * Gets all columns headers (TH elements) from the table.
-     *
-     * @param {number} column A source column index.
-     * @returns {HTMLTableCellElement[]}
-     */
-    getColumnHeaders(column: number): HTMLTableCellElement[];
-    /**
-     * GetRowHeader.
-     *
-     * @param {number} row Row index.
-     * @param {number} [level=0] Header level (0 = most distant to the table).
-     * @returns {HTMLElement} HTMLElement on success or Number one of the exit codes on error: `null table doesn't have
-     *   row headers`.
-     */
-    getRowHeader(row: number, level?: number): HTMLElement | undefined;
-    /**
-     * Gets all rows headers (TH elements) from the table.
-     *
-     * @param {number} row A source row index.
-     * @returns {HTMLTableCellElement[]}
-     */
-    getRowHeaders(row: number): ChildNode[];
-    /**
-     * Returns cell coords object for a given TD (or a child element of a TD element).
-     *
-     * @param {HTMLTableCellElement} TD A cell DOM element (or a child of one).
-     * @returns {CellCoords|null} The coordinates of the provided TD element (or the closest TD element) or null, if the
-     *   provided element is not applicable.
-     */
-    getCoords(TD: HTMLTableCellElement | HTMLElement): import(".").CellCoords | null;
-    /**
-     * Check if any of the rendered rows is higher than expected, and if so, cache them.
-     */
-    markOversizedRows(): void;
-    /**
-     * @param {number} row The visual row index.
-     * @returns {HTMLTableRowElement}
-     */
-    getTrForRow(row: number): HTMLTableRowElement;
-    /**
-     * Checks if the column index (negative value from -1 to N) is rendered.
-     *
-     * @param {number} column The column index (negative value from -1 to N).
-     * @returns {boolean}
-     */
-    isColumnHeaderRendered(column: number): boolean;
-    /**
-     * Checks if the row index (negative value from -1 to N) is rendered.
-     *
-     * @param {number} row The row index (negative value from -1 to N).
-     * @returns {boolean}
-     */
-    isRowHeaderRendered(row: number): boolean;
-    /**
-     * Check if the given row index is lower than the index of the first row that
-     * is currently rendered and return TRUE in that case, or FALSE otherwise.
-     *
-     * Negative row index is used to check the columns' headers.
-     *
-     *  Headers
-     *           +--------------+                                     │
-     *       -3  │    │    │    │                                     │
-     *           +--------------+                                     │
-     *       -2  │    │    │    │                                     │ TRUE
-     *           +--------------+                                     │
-     *       -1  │    │    │    │                                     │
-     *  Cells  +==================+                                   │
-     *        0  ┇    ┇    ┇    ┇ <--- For fixedRowsTop: 1            │
-     *           +--------------+      the master overlay do       ---+ first rendered row (index 1)
-     *        1  │ A2 │ B2 │ C2 │      not render the first row.      │
-     *           +--------------+                                     │ FALSE
-     *        2  │ A3 │ B3 │ C3 │                                     │
-     *           +--------------+                                  ---+ last rendered row
-     *                                                                │
-     *                                                                │ FALSE
-     *
-     * @param {number} row The visual row index.
-     * @memberof Table#
-     * @function isRowBeforeRenderedRows
-     * @returns {boolean}
-     */
-    isRowBeforeRenderedRows(row: number): boolean;
-    /**
-     * Check if the given column index is greater than the index of the last column that
-     * is currently rendered and return TRUE in that case, or FALSE otherwise.
-     *
-     * The negative row index is used to check the columns' headers. However,
-     * keep in mind that for negative indexes, the method always returns FALSE as
-     * it is not possible to render headers partially. The "after" index can not be
-     * lower than -1.
-     *
-     *  Headers
-     *           +--------------+                                     │
-     *       -3  │    │    │    │                                     │
-     *           +--------------+                                     │
-     *       -2  │    │    │    │                                     │ FALSE
-     *           +--------------+                                     │
-     *       -1  │    │    │    │                                     │
-     *  Cells  +==================+                                   │
-     *        0  ┇    ┇    ┇    ┇ <--- For fixedRowsTop: 1            │
-     *           +--------------+      the master overlay do       ---+ first rendered row (index 1)
-     *        1  │ A2 │ B2 │ C2 │      not render the first rows      │
-     *           +--------------+                                     │ FALSE
-     *        2  │ A3 │ B3 │ C3 │                                     │
-     *           +--------------+                                  ---+ last rendered row
-     *                                                                │
-     *                                                                │ TRUE
-     *
-     * @param {number} row The visual row index.
-     * @memberof Table#
-     * @function isRowAfterRenderedRows
-     * @returns {boolean}
-     */
-    isRowAfterRenderedRows(row: number): boolean;
-    /**
-     * Check if the given column index is lower than the index of the first column that
-     * is currently rendered and return TRUE in that case, or FALSE otherwise.
-     *
-     * Negative column index is used to check the rows' headers.
-     *
-     *                            For fixedColumnsStart: 1 the master overlay
-     *                            do not render this first columns.
-     *  Headers    -3   -2   -1    |
-     *           +----+----+----║┄ ┄ +------+------+
-     *           │    │    │    ║    │  B1  │  C1  │
-     *           +--------------║┄ ┄ --------------│
-     *           │    │    │    ║    │  B2  │  C2  │
-     *           +--------------║┄ ┄ --------------│
-     *           │    │    │    ║    │  B3  │  C3  │
-     *           +----+----+----║┄ ┄ +------+------+
-     *                               ╷             ╷
-     *      -------------------------+-------------+---------------->
-     *          TRUE             first    FALSE   last         FALSE
-     *                           rendered         rendered
-     *                           column           column
-     *
-     * @param {number} column The visual column index.
-     * @memberof Table#
-     * @function isColumnBeforeRenderedColumns
-     * @returns {boolean}
-     */
-    isColumnBeforeRenderedColumns(column: number): boolean;
-    /**
-     * Check if the given column index is greater than the index of the last column that
-     * is currently rendered and return TRUE in that case, or FALSE otherwise.
-     *
-     * The negative column index is used to check the rows' headers. However,
-     * keep in mind that for negative indexes, the method always returns FALSE as
-     * it is not possible to render headers partially. The "after" index can not be
-     * lower than -1.
-     *
-     *                            For fixedColumnsStart: 1 the master overlay
-     *                            do not render this first columns.
-     *  Headers    -3   -2   -1    |
-     *           +----+----+----║┄ ┄ +------+------+
-     *           │    │    │    ║    │  B1  │  C1  │
-     *           +--------------║┄ ┄ --------------│
-     *           │    │    │    ║    │  B2  │  C2  │
-     *           +--------------║┄ ┄ --------------│
-     *           │    │    │    ║    │  B3  │  C3  │
-     *           +----+----+----║┄ ┄ +------+------+
-     *                               ╷             ╷
-     *      -------------------------+-------------+---------------->
-     *          FALSE             first    FALSE   last         TRUE
-     *                           rendered         rendered
-     *                           column           column
-     *
-     * @param {number} column The visual column index.
-     * @memberof Table#
-     * @function isColumnAfterRenderedColumns
-     * @returns {boolean}
-     */
-    isColumnAfterRenderedColumns(column: number): boolean | null;
-    /**
-     * Checks if the column is after the last visible column.
-     *
-     * @param {number} column The visual column index.
-     * @returns {boolean}
-     */
-    isColumnAfterViewport(column: number): boolean | null;
-    /**
-     * Checks if the row is after the last visible row.
-     *
-     * @param {number} row The visual row index.
-     * @returns {boolean}
-     */
-    isRowAfterViewport(row: number): boolean | null;
-    /**
-     * Checks if the column is before the first visible column.
-     *
-     * @param {number} column The visual column index.
-     * @returns {boolean}
-     */
-    isColumnBeforeViewport(column: number): boolean | null;
-    /**
-     * Checks if the last row is fully visible.
-     *
-     * @returns {boolean}
-     */
-    isLastRowFullyVisible(): boolean;
-    /**
-     * Checks if the last column is fully visible.
-     *
-     * @returns {boolean}
-     */
-    isLastColumnFullyVisible(): boolean;
-    /**
-     * Checks if all rows fit in the viewport.
-     *
-     * @returns {boolean}
-     */
-    allRowsInViewport(): boolean;
-    /**
-     * Checks if all columns fit in the viewport.
-     *
-     * @returns {boolean}
-     */
-    allColumnsInViewport(): boolean;
-    /**
-     * Checks if any of the row's cells content exceeds its initial height, and if so, returns the oversized height.
-     *
-     * @param {number} sourceRow The physical row index.
-     * @returns {number}
-     */
-    getRowHeight(sourceRow: number): number | undefined;
-    /**
-     * @param {number} level The column level.
-     * @returns {number}
-     */
-    getColumnHeaderHeight(level: number): number;
-    /**
-     * @param {number} sourceColumn The physical column index.
-     * @returns {number}
-     */
-    getColumnWidth(sourceColumn: number): number;
-    /**
-     * Checks if the table has defined size. It returns `true` when the table has width and height
-     * set bigger than `0px`.
-     *
-     * @returns {boolean}
-     */
-    hasDefinedSize(): boolean;
-    /**
-     * Gets table's width. The returned width is the width of the rendered cells that fit in the
-     * current viewport. The value may change depends on the viewport position (scroll position).
-     *
-     * @returns {number}
-     */
-    getWidth(): number;
-    /**
-     * Gets table's height. The returned height is the height of the rendered cells that fit in the
-     * current viewport. The value may change depends on the viewport position (scroll position).
-     *
-     * @returns {number}
-     */
-    getHeight(): number;
-    /**
-     * Gets table's total width. The returned width is the width of all rendered cells (including headers)
-     * that can be displayed in the table.
-     *
-     * @returns {number}
-     */
-    getTotalWidth(): number;
-    /**
-     * Gets table's total height. The returned height is the height of all rendered cells (including headers)
-     * that can be displayed in the table.
-     *
-     * @returns {number}
-     */
-    getTotalHeight(): number;
-    /**
-     * Checks if the table is visible. It returns `true` when the holder element (or its parents)
-     * has CSS 'display' property different than 'none'.
-     *
-     * @returns {boolean}
-     */
-    isVisible(): boolean;
-    /**
-     * Modify row header widths provided by user in class contructor.
-     *
-     * @private
-     * @param {Function | number | null} rowHeaderWidthFactory The function which can provide default width values for rows..
-     * @returns {number}
-     */
-    _modifyRowHeaderWidth(rowHeaderWidthFactory: ((...args: unknown[]) => number | number[]) | number | null): number | number[];
-    /**
-     * Correct row header width if necessary.
-     *
-     * @private
-     * @param {number | null} width The width to process.
-     * @returns {number}
-     */
-    _correctRowHeaderWidth(width: number | null): number;
-    /**
-     * Destroys the table instance. Overridden by MasterTable to release DOM resources.
-     */
-    destroy(): void;
-}
-export default Table;