handsontable 18.0.0 → 18.1.0-rc7

package/3rdparty/walkontable/src/table/rangeQuery/viewportPredicates.mjs

@@ -0,0 +1,241 @@
+/**
+ * Viewport / rendered-range predicates for `Table` and every subclass.
+ *
+ * These answer "is this row/column a header, before/after the rendered band, before/after the visible
+ * band, fully visible, or entirely within the viewport" by reading the range-query outputs
+ * (`getFirstRenderedRow`, `getLastVisibleColumn`, …) supplied by the `withRowRangeQuery` /
+ * `withColumnRangeQuery` mixins plus the row/column filters and settings. They are universal — every
+ * table type needs them — so the mixin is applied once to the base `Table` (`mixin(Table,
+ * viewportPredicates)` in `baseTable.ts`) and inherited by all subclasses. The methods run on the
+ * `Table` instance (`this`), reading its public fields (`rowFilter`/`columnFilter`/`wtSettings`) and
+ * range-query methods. They use no `#`-private state, so no `deps` getter is needed here.
+ */ const viewportPredicates = {
+    /**
+   * 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}
+   * @this Table
+   */ isColumnHeaderRendered (column) {
+        if (column >= 0) {
+            return false;
+        }
+        const rowHeaders = this.wtSettings.getSetting('rowHeaders');
+        const rowHeadersCount = rowHeaders.length;
+        return Math.abs(column) <= rowHeadersCount;
+    },
+    /**
+   * 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}
+   * @this Table
+   */ isRowHeaderRendered (row) {
+        if (row >= 0) {
+            return false;
+        }
+        const columnHeaders = this.wtSettings.getSetting('columnHeaders');
+        const columnHeadersCount = columnHeaders.length;
+        return Math.abs(row) <= columnHeadersCount;
+    },
+    /**
+   * 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}
+   * @this Table
+   */ isRowBeforeRenderedRows (row) {
+        const first = this.getFirstRenderedRow();
+        // Check the headers only in case when the first rendered row is -1 or 0.
+        // This is an indication that the overlay is placed on the most top position.
+        if (row < 0 && first <= 0) {
+            return !this.isRowHeaderRendered(row);
+        }
+        return row < first;
+    },
+    /**
+   * 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}
+   * @this Table
+   */ isRowAfterRenderedRows (row) {
+        return row > this.getLastRenderedRow();
+    },
+    /**
+   * 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}
+   * @this Table
+   */ isColumnBeforeRenderedColumns (column) {
+        const first = this.getFirstRenderedColumn();
+        // Check the headers only in case when the first rendered column is -1 or 0.
+        // This is an indication that the overlay is placed on the most left position.
+        if (column < 0 && first <= 0) {
+            return !this.isColumnHeaderRendered(column);
+        }
+        return column < first;
+    },
+    /**
+   * 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}
+   * @this Table
+   */ isColumnAfterRenderedColumns (column) {
+        return this.columnFilter && column > this.getLastRenderedColumn();
+    },
+    /**
+   * Checks if the column is after the last visible column.
+   *
+   * @param {number} column The visual column index.
+   * @returns {boolean}
+   * @this Table
+   */ isColumnAfterViewport (column) {
+        return this.columnFilter && column > this.getLastVisibleColumn();
+    },
+    /**
+   * Checks if the row is after the last visible row.
+   *
+   * @param {number} row The visual row index.
+   * @returns {boolean}
+   * @this Table
+   */ isRowAfterViewport (row) {
+        return this.rowFilter && row > this.getLastVisibleRow();
+    },
+    /**
+   * Checks if the column is before the first visible column.
+   *
+   * @param {number} column The visual column index.
+   * @returns {boolean}
+   * @this Table
+   */ isColumnBeforeViewport (column) {
+        return this.columnFilter && this.columnFilter.sourceToRendered(column) < 0 && column >= 0;
+    },
+    /**
+   * Checks if the last row is fully visible.
+   *
+   * @returns {boolean}
+   * @this Table
+   */ isLastRowFullyVisible () {
+        return this.getLastVisibleRow() === this.getLastRenderedRow();
+    },
+    /**
+   * Checks if the last column is fully visible.
+   *
+   * @returns {boolean}
+   * @this Table
+   */ isLastColumnFullyVisible () {
+        return this.getLastVisibleColumn() === this.getLastRenderedColumn();
+    },
+    /**
+   * Checks if all rows fit in the viewport.
+   *
+   * @returns {boolean}
+   * @this Table
+   */ allRowsInViewport () {
+        return this.wtSettings.getSetting('totalRows') === this.getVisibleRowsCount();
+    },
+    /**
+   * Checks if all columns fit in the viewport.
+   *
+   * @returns {boolean}
+   * @this Table
+   */ allColumnsInViewport () {
+        return this.wtSettings.getSetting('totalColumns') === this.getVisibleColumnsCount();
+    }
+};
+export default viewportPredicates;

package/3rdparty/walkontable/src/table/rangeQuery/virtualRange.d.mts

@@ -0,0 +1 @@
+export * from './virtualRange.js';

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

@@ -0,0 +1,14 @@
+import type { RowRangeQuery, ColumnRangeQuery } from './renderedRange';
+/**
+ * Row range-query mixin. Implements `RowRangeQuery` by reading the current row calculators.
+ *
+ * @type {RowRangeQuery}
+ */
+declare const rowRangeQuery: RowRangeQuery;
+/**
+ * Column range-query mixin. Implements `ColumnRangeQuery` by reading the current column calculators.
+ *
+ * @type {ColumnRangeQuery}
+ */
+declare const columnRangeQuery: ColumnRangeQuery;
+export { rowRangeQuery, columnRangeQuery };

package/3rdparty/walkontable/src/table/rangeQuery/virtualRange.js

@@ -0,0 +1,196 @@
+/**
+ * Calculator-backed adapters for the range-query ports (`RowRangeQuery` / `ColumnRangeQuery`).
+ *
+ * These mixin objects implement the ports by reading the current render / visible / partially-visible
+ * calculators off the viewport and reporting the rendered range. They used to live in two separate
+ * files (`table/mixin/calculatedRows` and `table/mixin/calculatedColumns`).
+ *
+ * Selectivity is unchanged: `MasterTable` mixes both groups, the top/bottom overlays mix the column
+ * group, the inline-start overlay mixes the row group, and the corner overlays mix neither. The mixin
+ * objects are applied with the same `mixin()` helper the sticky-overlay mixins use, so a table type
+ * that does not mix a group has no runtime implementation for it (calling one throws — exactly as
+ * before). Each method reads the calculator fresh through `this.deps.getWtViewport()`, so the
+ * per-draw calculator objects are never captured.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get columnRangeQuery () {
+        return columnRangeQuery;
+    },
+    get rowRangeQuery () {
+        return rowRangeQuery;
+    }
+});
+const _object = require("../../../../../helpers/object");
+/**
+ * Row range-query mixin. Implements `RowRangeQuery` by reading the current row calculators.
+ *
+ * @type {RowRangeQuery}
+ */ const rowRangeQuery = {
+    /**
+   * Get the source index of the first rendered row, or -1 when no rows are rendered.
+   *
+   * @returns {number}
+   * @this Table
+   */ getFirstRenderedRow () {
+        return this.deps.getWtViewport().rowsRenderCalculator?.startRow ?? -1;
+    },
+    /**
+   * Get the source index of the first fully visible row, or -1 when none are.
+   *
+   * @returns {number}
+   * @this Table
+   */ getFirstVisibleRow () {
+        return this.deps.getWtViewport().rowsVisibleCalculator?.startRow ?? -1;
+    },
+    /**
+   * Get the source index of the first partially visible row, or -1 when none are.
+   *
+   * @returns {number}
+   * @this Table
+   */ getFirstPartiallyVisibleRow () {
+        return this.deps.getWtViewport().rowsPartiallyVisibleCalculator?.startRow ?? -1;
+    },
+    /**
+   * Get the source index of the last rendered row, or -1 when no rows are rendered.
+   *
+   * @returns {number}
+   * @this Table
+   */ getLastRenderedRow () {
+        return this.deps.getWtViewport().rowsRenderCalculator?.endRow ?? -1;
+    },
+    /**
+   * Get the source index of the last fully visible row, or -1 when none are.
+   *
+   * @returns {number}
+   * @this Table
+   */ getLastVisibleRow () {
+        return this.deps.getWtViewport().rowsVisibleCalculator?.endRow ?? -1;
+    },
+    /**
+   * Get the source index of the last partially visible row, or -1 when none are.
+   *
+   * @returns {number}
+   * @this Table
+   */ getLastPartiallyVisibleRow () {
+        return this.deps.getWtViewport().rowsPartiallyVisibleCalculator?.endRow ?? -1;
+    },
+    /**
+   * Get the number of rendered rows.
+   *
+   * @returns {number}
+   * @this Table
+   */ getRenderedRowsCount () {
+        return this.deps.getWtViewport().rowsRenderCalculator?.count ?? 0;
+    },
+    /**
+   * Get the number of fully visible rows.
+   *
+   * @returns {number}
+   * @this Table
+   */ getVisibleRowsCount () {
+        return this.deps.getWtViewport().rowsVisibleCalculator?.count ?? 0;
+    },
+    /**
+   * Get the number of column headers.
+   *
+   * @returns {number}
+   * @this Table
+   */ getColumnHeadersCount () {
+        return this.deps.getColumnHeaders().length;
+    }
+};
+(0, _object.defineGetter)(rowRangeQuery, 'MIXIN_NAME', 'calculatedRows', {
+    writable: false,
+    enumerable: false
+});
+/**
+ * Column range-query mixin. Implements `ColumnRangeQuery` by reading the current column calculators.
+ *
+ * @type {ColumnRangeQuery}
+ */ const columnRangeQuery = {
+    /**
+   * Get the source index of the first rendered column, or -1 when no columns are rendered.
+   *
+   * @returns {number}
+   * @this Table
+   */ getFirstRenderedColumn () {
+        return this.deps.getWtViewport().columnsRenderCalculator?.startColumn ?? -1;
+    },
+    /**
+   * Get the source index of the first fully visible column, or -1 when none are.
+   *
+   * @returns {number}
+   * @this Table
+   */ getFirstVisibleColumn () {
+        return this.deps.getWtViewport().columnsVisibleCalculator?.startColumn ?? -1;
+    },
+    /**
+   * Get the source index of the first partially visible column, or -1 when none are.
+   *
+   * @returns {number}
+   * @this Table
+   */ getFirstPartiallyVisibleColumn () {
+        return this.deps.getWtViewport().columnsPartiallyVisibleCalculator?.startColumn ?? -1;
+    },
+    /**
+   * Get the source index of the last rendered column, or -1 when no columns are rendered.
+   *
+   * @returns {number}
+   * @this Table
+   */ getLastRenderedColumn () {
+        return this.deps.getWtViewport().columnsRenderCalculator?.endColumn ?? -1;
+    },
+    /**
+   * Get the source index of the last fully visible column, or -1 when none are.
+   *
+   * @returns {number}
+   * @this Table
+   */ getLastVisibleColumn () {
+        return this.deps.getWtViewport().columnsVisibleCalculator?.endColumn ?? -1;
+    },
+    /**
+   * Get the source index of the last partially visible column, or -1 when none are.
+   *
+   * @returns {number}
+   * @this Table
+   */ getLastPartiallyVisibleColumn () {
+        return this.deps.getWtViewport().columnsPartiallyVisibleCalculator?.endColumn ?? -1;
+    },
+    /**
+   * Get the number of rendered columns.
+   *
+   * @returns {number}
+   * @this Table
+   */ getRenderedColumnsCount () {
+        return this.deps.getWtViewport().columnsRenderCalculator?.count ?? 0;
+    },
+    /**
+   * Get the number of fully visible columns.
+   *
+   * @returns {number}
+   * @this Table
+   */ getVisibleColumnsCount () {
+        return this.deps.getWtViewport().columnsVisibleCalculator?.count ?? 0;
+    },
+    /**
+   * Get the number of row headers.
+   *
+   * @returns {number}
+   * @this Table
+   */ getRowHeadersCount () {
+        return this.deps.getRowHeaders().length;
+    }
+};
+(0, _object.defineGetter)(columnRangeQuery, 'MIXIN_NAME', 'calculatedColumns', {
+    writable: false,
+    enumerable: false
+});

package/3rdparty/walkontable/src/table/rangeQuery/virtualRange.mjs

@@ -0,0 +1,179 @@
+/**
+ * Calculator-backed adapters for the range-query ports (`RowRangeQuery` / `ColumnRangeQuery`).
+ *
+ * These mixin objects implement the ports by reading the current render / visible / partially-visible
+ * calculators off the viewport and reporting the rendered range. They used to live in two separate
+ * files (`table/mixin/calculatedRows` and `table/mixin/calculatedColumns`).
+ *
+ * Selectivity is unchanged: `MasterTable` mixes both groups, the top/bottom overlays mix the column
+ * group, the inline-start overlay mixes the row group, and the corner overlays mix neither. The mixin
+ * objects are applied with the same `mixin()` helper the sticky-overlay mixins use, so a table type
+ * that does not mix a group has no runtime implementation for it (calling one throws — exactly as
+ * before). Each method reads the calculator fresh through `this.deps.getWtViewport()`, so the
+ * per-draw calculator objects are never captured.
+ */ import { defineGetter } from '../../../../../helpers/object.mjs';
+/**
+ * Row range-query mixin. Implements `RowRangeQuery` by reading the current row calculators.
+ *
+ * @type {RowRangeQuery}
+ */ const rowRangeQuery = {
+    /**
+   * Get the source index of the first rendered row, or -1 when no rows are rendered.
+   *
+   * @returns {number}
+   * @this Table
+   */ getFirstRenderedRow () {
+        return this.deps.getWtViewport().rowsRenderCalculator?.startRow ?? -1;
+    },
+    /**
+   * Get the source index of the first fully visible row, or -1 when none are.
+   *
+   * @returns {number}
+   * @this Table
+   */ getFirstVisibleRow () {
+        return this.deps.getWtViewport().rowsVisibleCalculator?.startRow ?? -1;
+    },
+    /**
+   * Get the source index of the first partially visible row, or -1 when none are.
+   *
+   * @returns {number}
+   * @this Table
+   */ getFirstPartiallyVisibleRow () {
+        return this.deps.getWtViewport().rowsPartiallyVisibleCalculator?.startRow ?? -1;
+    },
+    /**
+   * Get the source index of the last rendered row, or -1 when no rows are rendered.
+   *
+   * @returns {number}
+   * @this Table
+   */ getLastRenderedRow () {
+        return this.deps.getWtViewport().rowsRenderCalculator?.endRow ?? -1;
+    },
+    /**
+   * Get the source index of the last fully visible row, or -1 when none are.
+   *
+   * @returns {number}
+   * @this Table
+   */ getLastVisibleRow () {
+        return this.deps.getWtViewport().rowsVisibleCalculator?.endRow ?? -1;
+    },
+    /**
+   * Get the source index of the last partially visible row, or -1 when none are.
+   *
+   * @returns {number}
+   * @this Table
+   */ getLastPartiallyVisibleRow () {
+        return this.deps.getWtViewport().rowsPartiallyVisibleCalculator?.endRow ?? -1;
+    },
+    /**
+   * Get the number of rendered rows.
+   *
+   * @returns {number}
+   * @this Table
+   */ getRenderedRowsCount () {
+        return this.deps.getWtViewport().rowsRenderCalculator?.count ?? 0;
+    },
+    /**
+   * Get the number of fully visible rows.
+   *
+   * @returns {number}
+   * @this Table
+   */ getVisibleRowsCount () {
+        return this.deps.getWtViewport().rowsVisibleCalculator?.count ?? 0;
+    },
+    /**
+   * Get the number of column headers.
+   *
+   * @returns {number}
+   * @this Table
+   */ getColumnHeadersCount () {
+        return this.deps.getColumnHeaders().length;
+    }
+};
+defineGetter(rowRangeQuery, 'MIXIN_NAME', 'calculatedRows', {
+    writable: false,
+    enumerable: false
+});
+/**
+ * Column range-query mixin. Implements `ColumnRangeQuery` by reading the current column calculators.
+ *
+ * @type {ColumnRangeQuery}
+ */ const columnRangeQuery = {
+    /**
+   * Get the source index of the first rendered column, or -1 when no columns are rendered.
+   *
+   * @returns {number}
+   * @this Table
+   */ getFirstRenderedColumn () {
+        return this.deps.getWtViewport().columnsRenderCalculator?.startColumn ?? -1;
+    },
+    /**
+   * Get the source index of the first fully visible column, or -1 when none are.
+   *
+   * @returns {number}
+   * @this Table
+   */ getFirstVisibleColumn () {
+        return this.deps.getWtViewport().columnsVisibleCalculator?.startColumn ?? -1;
+    },
+    /**
+   * Get the source index of the first partially visible column, or -1 when none are.
+   *
+   * @returns {number}
+   * @this Table
+   */ getFirstPartiallyVisibleColumn () {
+        return this.deps.getWtViewport().columnsPartiallyVisibleCalculator?.startColumn ?? -1;
+    },
+    /**
+   * Get the source index of the last rendered column, or -1 when no columns are rendered.
+   *
+   * @returns {number}
+   * @this Table
+   */ getLastRenderedColumn () {
+        return this.deps.getWtViewport().columnsRenderCalculator?.endColumn ?? -1;
+    },
+    /**
+   * Get the source index of the last fully visible column, or -1 when none are.
+   *
+   * @returns {number}
+   * @this Table
+   */ getLastVisibleColumn () {
+        return this.deps.getWtViewport().columnsVisibleCalculator?.endColumn ?? -1;
+    },
+    /**
+   * Get the source index of the last partially visible column, or -1 when none are.
+   *
+   * @returns {number}
+   * @this Table
+   */ getLastPartiallyVisibleColumn () {
+        return this.deps.getWtViewport().columnsPartiallyVisibleCalculator?.endColumn ?? -1;
+    },
+    /**
+   * Get the number of rendered columns.
+   *
+   * @returns {number}
+   * @this Table
+   */ getRenderedColumnsCount () {
+        return this.deps.getWtViewport().columnsRenderCalculator?.count ?? 0;
+    },
+    /**
+   * Get the number of fully visible columns.
+   *
+   * @returns {number}
+   * @this Table
+   */ getVisibleColumnsCount () {
+        return this.deps.getWtViewport().columnsVisibleCalculator?.count ?? 0;
+    },
+    /**
+   * Get the number of row headers.
+   *
+   * @returns {number}
+   * @this Table
+   */ getRowHeadersCount () {
+        return this.deps.getRowHeaders().length;
+    }
+};
+defineGetter(columnRangeQuery, 'MIXIN_NAME', 'calculatedColumns', {
+    writable: false,
+    enumerable: false
+});
+export { rowRangeQuery, columnRangeQuery };

package/3rdparty/walkontable/src/table/regions/bottomInlineStartCornerTable.d.mts

@@ -0,0 +1,2 @@
+export * from './bottomInlineStartCornerTable.js';
+export { default } from './bottomInlineStartCornerTable.js';

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

@@ -0,0 +1,16 @@
+import type { TableDeps } from '../baseTable';
+import Table from '../baseTable';
+/**
+ * Subclass of `Table` that provides the helper methods relevant to bottomInlineStartCornerOverlay
+ * (in RTL mode the overlay sits on the right of the screen), implemented through mixins.
+ *
+ * @mixes stickyRowsBottom
+ * @mixes stickyColumnsStart
+ */
+declare class BottomInlineStartCornerOverlayTable extends Table {
+    /**
+     * @param {TableDeps} deps The table module dependencies.
+     */
+    constructor(deps: TableDeps);
+}
+export default BottomInlineStartCornerOverlayTable;

package/3rdparty/walkontable/src/table/{bottomInlineStartCorner.js → regions/bottomInlineStartCornerTable.js}

@@ -8,11 +8,11 @@ Object.defineProperty(exports, "default", {
         return _default;
     }
 });
-const _table = /*#__PURE__*/ _interop_require_default(require("../table"));
-const _stickyRowsBottom = /*#__PURE__*/ _interop_require_default(require("./mixin/stickyRowsBottom"));
-const _stickyColumnsStart = /*#__PURE__*/ _interop_require_default(require("./mixin/stickyColumnsStart"));
-const _object = require("../../../../helpers/object");
-const _overlay = require("../overlay");
+const _baseTable = /*#__PURE__*/ _interop_require_default(require("../baseTable"));
+const _stickyRowsBottom = /*#__PURE__*/ _interop_require_default(require("../rangeQuery/stickyRowsBottom"));
+const _stickyColumnsStart = /*#__PURE__*/ _interop_require_default(require("../rangeQuery/stickyColumnsStart"));
+const _object = require("../../../../../helpers/object");
+const _overlay = require("../../overlay");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -24,14 +24,11 @@ function _interop_require_default(obj) {
  *
  * @mixes stickyRowsBottom
  * @mixes stickyColumnsStart
- */ class BottomInlineStartCornerOverlayTable extends _table.default {
+ */ class BottomInlineStartCornerOverlayTable extends _baseTable.default {
     /**
-   * @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.
-   */ constructor(dataAccessObject, facadeGetter, domBindings, wtSettings){
-        super(dataAccessObject, facadeGetter, domBindings, wtSettings, _overlay.CLONE_BOTTOM_INLINE_START_CORNER);
+   * @param {TableDeps} deps The table module dependencies.
+   */ constructor(deps){
+        super(deps, _overlay.CLONE_BOTTOM_INLINE_START_CORNER);
     }
 }
 (0, _object.mixin)(BottomInlineStartCornerOverlayTable, _stickyRowsBottom.default);