handsontable 0.0.0-next-08765b9-20230809 → 0.0.0-next-7e1ba35-20230821

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

@@ -1,9 +1,9 @@
-import "core-js/modules/es.error.cause.js";
 import "core-js/modules/es.array.push.js";
+import "core-js/modules/es.error.cause.js";
 function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
 function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-import { hasClass, index, offset, removeTextNodes, overlayContainsElement, closest, outerHeight, outerWidth, innerHeight, isVisible } from "../../../helpers/dom/element.mjs";
+import { hasClass, index, offset, removeClass, removeTextNodes, overlayContainsElement, closest, outerHeight, outerWidth, innerHeight, isVisible } from "../../../helpers/dom/element.mjs";
 import { isFunction } from "../../../helpers/function.mjs";
 import ColumnFilter from "./filter/column.mjs";
 import RowFilter from "./filter/row.mjs";
@@ -341,7 +341,7 @@ class Table {
       wtOverlays.refreshAll(); // `refreshAll()` internally already calls `refreshSelections()` method
       wtOverlays.adjustElementsSize();
     } else {
-      this.dataAccessObject.selectionManager.setActiveOverlay(this.facadeGetter()).render(runFastDraw);
+      this.refreshSelections(runFastDraw);
     }
     if (syncScroll) {
       wtOverlays.syncScrollWithMaster();
@@ -433,6 +433,75 @@ class Table {
     }
   }
 
+  /**
+   * @param {string} className The CSS class name to remove from the table cells.
+   */
+  removeClassFromCells(className) {
+    const nodes = this.TABLE.querySelectorAll(`.${className}`);
+    for (let i = 0, len = nodes.length; i < len; i++) {
+      removeClass(nodes[i], className);
+    }
+  }
+
+  /**
+   * Refresh the table selection by re-rendering Selection instances connected with that instance.
+   *
+   * @param {boolean} fastDraw If fast drawing is enabled than additionally className clearing is applied.
+   */
+  refreshSelections(fastDraw) {
+    const {
+      wtSettings
+    } = this;
+    const {
+      selections
+    } = this.dataAccessObject;
+    if (!selections) {
+      return;
+    }
+    const highlights = Array.from(selections);
+    const len = highlights.length;
+    if (fastDraw) {
+      const classesToRemove = [];
+      for (let i = 0; i < len; i++) {
+        const {
+          highlightHeaderClassName,
+          highlightRowClassName,
+          highlightColumnClassName
+        } = highlights[i].settings;
+        const classNames = highlights[i].classNames;
+        const classNamesLength = classNames.length;
+        for (let j = 0; j < classNamesLength; j++) {
+          if (!classesToRemove.includes(classNames[j])) {
+            classesToRemove.push(classNames[j]);
+          }
+        }
+        if (highlightHeaderClassName && !classesToRemove.includes(highlightHeaderClassName)) {
+          classesToRemove.push(highlightHeaderClassName);
+        }
+        if (highlightRowClassName && !classesToRemove.includes(highlightRowClassName)) {
+          classesToRemove.push(highlightRowClassName);
+        }
+        if (highlightColumnClassName && !classesToRemove.includes(highlightColumnClassName)) {
+          classesToRemove.push(highlightColumnClassName);
+        }
+      }
+      const additionalClassesToRemove = wtSettings.getSetting('onBeforeRemoveCellClassNames');
+      if (Array.isArray(additionalClassesToRemove)) {
+        for (let i = 0; i < additionalClassesToRemove.length; i++) {
+          classesToRemove.push(additionalClassesToRemove[i]);
+        }
+      }
+      const classesToRemoveLength = classesToRemove.length;
+      for (let i = 0; i < classesToRemoveLength; i++) {
+        // there was no rerender, so we need to remove classNames by ourselves
+        this.removeClassFromCells(classesToRemove[i]);
+      }
+    }
+    for (let i = 0; i < len; i++) {
+      highlights[i].draw(this.facadeGetter(), fastDraw);
+    }
+  }
+
   /**
    * Get cell element at coords.
    * Negative coords.row or coords.col are used to retrieve header cells. If there are multiple header levels, the
@@ -554,14 +623,14 @@ class Table {
    */
   getRowHeader(row) {
     let level = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    if (this.columnFilter.sourceColumnToVisibleRowHeadedColumn(0) === 0) {
+      return;
+    }
     const rowHeadersCount = this.wtSettings.getSetting('rowHeaders').length;
     if (level >= rowHeadersCount) {
       return;
     }
-    const renderedRow = this.rowFilter.sourceToRendered(row);
-    const visibleRow = renderedRow < 0 ? this.rowFilter.sourceRowToVisibleColHeadedRow(row) : renderedRow;
-    const parentElement = renderedRow < 0 ? this.THEAD : this.TBODY;
-    const TR = parentElement.childNodes[visibleRow];
+    const TR = this.TBODY.childNodes[this.rowFilter.sourceToRendered(row)];
     return TR === null || TR === void 0 ? void 0 : TR.childNodes[level];
   }
 
@@ -572,6 +641,9 @@ class Table {
    * @returns {HTMLTableCellElement[]}
    */
   getRowHeaders(row) {
+    if (this.columnFilter.sourceColumnToVisibleRowHeadedColumn(0) === 0) {
+      return [];
+    }
     const THs = [];
     const rowHeadersCount = this.wtSettings.getSetting('rowHeaders').length;
     for (let renderedRowIndex = 0; renderedRowIndex < rowHeadersCount; renderedRowIndex++) {

package/base.js

@@ -43,8 +43,8 @@ Handsontable.hooks = _pluginHooks.default.getSingleton();
 Handsontable.CellCoords = _src.CellCoords;
 Handsontable.CellRange = _src.CellRange;
 Handsontable.packageName = 'handsontable';
-Handsontable.buildDate = "09/08/2023 12:55:28";
-Handsontable.version = "0.0.0-next-08765b9-20230809";
+Handsontable.buildDate = "21/08/2023 09:11:33";
+Handsontable.version = "0.0.0-next-7e1ba35-20230821";
 Handsontable.languages = {
   dictionaryKeys: _registry.dictionaryKeys,
   getLanguageDictionary: _registry.getLanguageDictionary,

package/base.mjs

@@ -35,8 +35,8 @@ Handsontable.hooks = Hooks.getSingleton();
 Handsontable.CellCoords = CellCoords;
 Handsontable.CellRange = CellRange;
 Handsontable.packageName = 'handsontable';
-Handsontable.buildDate = "09/08/2023 12:55:36";
-Handsontable.version = "0.0.0-next-08765b9-20230809";
+Handsontable.buildDate = "21/08/2023 09:11:44";
+Handsontable.version = "0.0.0-next-7e1ba35-20230821";
 Handsontable.languages = {
   dictionaryKeys,
   getLanguageDictionary,

package/common.d.ts

@@ -12,7 +12,7 @@ export type CellValue = any;
 /**
  * A cell change represented by `[row, column, prevValue, nextValue]`.
  */
-export type CellChange = [number, string | number, CellValue, CellValue];
+export type CellChange = [number, string | number | ColumnDataGetterSetterFunction, CellValue, CellValue];
 
 /**
  * A row object, one of the two ways to supply data to the table, the alternative being an array of values.

package/core.d.ts

@@ -45,8 +45,6 @@ export default class Core {
   countSourceRows(): number;
   countVisibleCols(): number;
   countVisibleRows(): number;
-  countRowHeaders(): number;
-  countColHeaders(): number;
   deselectCell(): void;
   destroy(): void;
   destroyEditor(revertOriginal?: boolean, prepareEditorIfNeeded?: boolean): void;
@@ -131,13 +129,12 @@ export default class Core {
   rowIndexMapper: IndexMapper;
   runHooks(key: keyof Events, p1?: any, p2?: any, p3?: any, p4?: any, p5?: any, p6?: any): any;
   scrollViewportTo(row?: number, column?: number, snapToBottom?: boolean, snapToRight?: boolean, considerHiddenIndexes?: boolean): boolean;
-  scrollToFocusedCell(callback?: () => void): void;
-  selectAll(includeRowHeaders?: boolean, includeColumnHeaders?: boolean, focusPosition?: { row?: number, col?: number }): void;
+  selectAll(): void;
   selectCell(row: number, col: number, endRow?: number, endCol?: number, scrollToCell?: boolean, changeListener?: boolean): boolean;
   selectCellByProp(row: number, prop: string, endRow?: number, endProp?: string, scrollToCell?: boolean): boolean;
   selectCells(coords: Array<[number, number | string, number, number | string]> | CellRange[], scrollToCell?: boolean, changeListener?: boolean): boolean;
-  selectColumns(startColumn: number | string, endColumn?: number | string, focusPosition?: number): boolean;
-  selectRows(startRow: number, endRow?: number, focusPosition?: number): boolean;
+  selectColumns(startColumn: number | string, endColumn?: number | string): boolean;
+  selectRows(startRow: number, endRow?: number): boolean;
   setCellMeta(row: number, col: number, key: string, val: any): void;
   setCellMeta<K extends keyof CellMeta>(row: number, col: number, key: K, val: CellMeta[K]): void;
   setCellMetaObject(row: number, col: number, prop: CellMeta): void;