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

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

@@ -0,0 +1,290 @@
+import "core-js/modules/es.array.push.js";
+import { addClass, hasClass } from "./../../../helpers/dom/element.mjs";
+import Border from "./border.mjs";
+/**
+ * @class Selection
+ */
+class Selection {
+  /**
+   * @param {object} settings The selection settings object. @todo type.
+   * @param {CellRange} cellRange The cell range instance.
+   */
+  constructor(settings, cellRange) {
+    this.settings = settings;
+    this.cellRange = cellRange || null;
+    this.instanceBorders = {};
+    this.classNames = [this.settings.className];
+    this.classNameGenerator = this.linearClassNameGenerator(this.settings.className, this.settings.layerLevel);
+  }
+
+  /**
+   * Each Walkontable clone requires it's own border for every selection. This method creates and returns selection
+   * borders per instance.
+   *
+   * @param {WalkontableFacade} wotInstance The Walkontable instance.
+   * @returns {Border}
+   */
+  getBorder(wotInstance) {
+    if (!this.instanceBorders[wotInstance.guid]) {
+      this.instanceBorders[wotInstance.guid] = new Border(wotInstance, this.settings);
+    }
+    return this.instanceBorders[wotInstance.guid];
+  }
+
+  /**
+   * Checks if selection is empty.
+   *
+   * @returns {boolean}
+   */
+  isEmpty() {
+    return this.cellRange === null;
+  }
+
+  /**
+   * Adds a cell coords to the selection.
+   *
+   * @param {CellCoords} coords The cell coordinates to add.
+   * @returns {Selection}
+   */
+  add(coords) {
+    if (this.isEmpty()) {
+      this.cellRange = this.settings.createCellRange(coords);
+    } else {
+      this.cellRange.expand(coords);
+    }
+    return this;
+  }
+
+  /**
+   * If selection range from or to property equals oldCoords, replace it with newCoords. Return boolean
+   * information about success.
+   *
+   * @param {CellCoords} oldCoords An old cell coordinates to replace.
+   * @param {CellCoords} newCoords The new cell coordinates.
+   * @returns {boolean}
+   */
+  replace(oldCoords, newCoords) {
+    if (!this.isEmpty()) {
+      if (this.cellRange.from.isEqual(oldCoords)) {
+        this.cellRange.from = newCoords;
+        return true;
+      }
+      if (this.cellRange.to.isEqual(oldCoords)) {
+        this.cellRange.to = newCoords;
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Clears selection.
+   *
+   * @returns {Selection}
+   */
+  clear() {
+    this.cellRange = null;
+    return this;
+  }
+
+  /**
+   * Returns the top left (or top right in RTL) and bottom right (or bottom left in RTL) selection coordinates.
+   *
+   * @returns {Array} Returns array of coordinates for example `[1, 1, 5, 5]`.
+   */
+  getCorners() {
+    const topStart = this.cellRange.getOuterTopStartCorner();
+    const bottomEnd = this.cellRange.getOuterBottomEndCorner();
+    return [topStart.row, topStart.col, bottomEnd.row, bottomEnd.col];
+  }
+
+  /**
+   * Adds class name to cell element at given coords.
+   *
+   * @param {WalkontableFacade} wotInstance Walkontable instance.
+   * @param {number} sourceRow Cell row coord.
+   * @param {number} sourceColumn Cell column coord.
+   * @param {string} className Class name.
+   * @param {boolean} [markIntersections=false] If `true`, linear className generator will be used to add CSS classes
+   *                                            in a continuous way.
+   * @returns {Selection}
+   */
+  addClassAtCoords(wotInstance, sourceRow, sourceColumn, className) {
+    let markIntersections = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+    const TD = wotInstance.wtTable.getCell(this.settings.createCellCoords(sourceRow, sourceColumn));
+    if (typeof TD === 'object') {
+      let cellClassName = className;
+      if (markIntersections) {
+        cellClassName = this.classNameGenerator(TD);
+        if (!this.classNames.includes(cellClassName)) {
+          this.classNames.push(cellClassName);
+        }
+      }
+      addClass(TD, cellClassName);
+    }
+    return this;
+  }
+
+  /**
+   * Generate helper for calculating classNames based on previously added base className.
+   * The generated className is always generated as a continuation of the previous className. For example, when
+   * the currently checked element has 'area-2' className the generated new className will be 'area-3'. When
+   * the element doesn't have any classNames than the base className will be returned ('area');.
+   *
+   * @param {string} baseClassName Base className to be used.
+   * @param {number} layerLevelOwner Layer level which the instance of the Selection belongs to.
+   * @returns {Function}
+   */
+  linearClassNameGenerator(baseClassName, layerLevelOwner) {
+    // TODO: Make this recursive function Proper Tail Calls (TCO/PTC) friendly.
+    return function calcClassName(element) {
+      let previousIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : -1;
+      if (layerLevelOwner === 0 || previousIndex === 0) {
+        return baseClassName;
+      }
+      let index = previousIndex >= 0 ? previousIndex : layerLevelOwner;
+      let className = baseClassName;
+      index -= 1;
+      const previousClassName = index === 0 ? baseClassName : `${baseClassName}-${index}`;
+      if (hasClass(element, previousClassName)) {
+        const currentLayer = index + 1;
+        className = `${baseClassName}-${currentLayer}`;
+      } else {
+        className = calcClassName(element, index);
+      }
+      return className;
+    };
+  }
+
+  /**
+   * @param {WalkontableFacade} wotInstance The Walkontable instance.
+   */
+  draw(wotInstance) {
+    if (this.isEmpty()) {
+      if (this.settings.border) {
+        this.getBorder(wotInstance).disappear();
+      }
+      return;
+    }
+    const renderedRows = wotInstance.wtTable.getRenderedRowsCount();
+    const renderedColumns = wotInstance.wtTable.getRenderedColumnsCount();
+    const corners = this.getCorners();
+    const [topRow, topColumn, bottomRow, bottomColumn] = corners;
+    const {
+      highlightHeaderClassName,
+      highlightColumnClassName,
+      highlightRowClassName,
+      highlightOnlyClosestHeader,
+      selectionType
+    } = this.settings;
+    const isHeaderSelectionType = selectionType === void 0 || ['active-header', 'header'].includes(selectionType);
+    if (isHeaderSelectionType && topColumn !== null && bottomColumn !== null) {
+      let selectionColumnCursor = 0;
+      for (let column = 0; column < renderedColumns; column += 1) {
+        const sourceCol = wotInstance.wtTable.columnFilter.renderedToSource(column);
+        if (sourceCol >= topColumn && sourceCol <= bottomColumn) {
+          let THs = wotInstance.wtTable.getColumnHeaders(sourceCol);
+          const closestHeaderLevel = THs.length - 1;
+          if (highlightOnlyClosestHeader && THs.length > 1) {
+            THs = [THs[closestHeaderLevel]];
+          }
+          for (let headerLevel = 0; headerLevel < THs.length; headerLevel += 1) {
+            const newClasses = [];
+            let TH = THs[headerLevel];
+            if (highlightHeaderClassName) {
+              newClasses.push(highlightHeaderClassName);
+            }
+            if (highlightColumnClassName) {
+              newClasses.push(highlightColumnClassName);
+            }
+            headerLevel = highlightOnlyClosestHeader ? closestHeaderLevel : headerLevel;
+            const newSourceCol = wotInstance.getSetting('onBeforeHighlightingColumnHeader', sourceCol, headerLevel, {
+              selectionType,
+              columnCursor: selectionColumnCursor,
+              selectionWidth: bottomColumn - topColumn + 1,
+              classNames: newClasses
+            });
+            if (newSourceCol !== sourceCol) {
+              TH = wotInstance.wtTable.getColumnHeader(newSourceCol, headerLevel);
+            }
+            addClass(TH, newClasses);
+          }
+          selectionColumnCursor += 1;
+        }
+      }
+    }
+    if (topRow !== null && bottomRow !== null) {
+      let selectionRowCursor = 0;
+      for (let row = 0; row < renderedRows; row += 1) {
+        const sourceRow = wotInstance.wtTable.rowFilter.renderedToSource(row);
+        if (isHeaderSelectionType && sourceRow >= topRow && sourceRow <= bottomRow) {
+          let THs = wotInstance.wtTable.getRowHeaders(sourceRow);
+          const closestHeaderLevel = THs.length - 1;
+          if (highlightOnlyClosestHeader && THs.length > 1) {
+            THs = [THs[closestHeaderLevel]];
+          }
+          for (let headerLevel = 0; headerLevel < THs.length; headerLevel += 1) {
+            const newClasses = [];
+            let TH = THs[headerLevel];
+            if (highlightHeaderClassName) {
+              newClasses.push(highlightHeaderClassName);
+            }
+            if (highlightRowClassName) {
+              newClasses.push(highlightRowClassName);
+            }
+            headerLevel = highlightOnlyClosestHeader ? closestHeaderLevel : headerLevel;
+            const newSourceRow = wotInstance.getSetting('onBeforeHighlightingRowHeader', sourceRow, headerLevel, {
+              selectionType,
+              rowCursor: selectionRowCursor,
+              selectionHeight: bottomRow - topRow + 1,
+              classNames: newClasses
+            });
+            if (newSourceRow !== sourceRow) {
+              TH = wotInstance.wtTable.getRowHeader(newSourceRow, headerLevel);
+            }
+            addClass(TH, newClasses);
+          }
+          selectionRowCursor += 1;
+        }
+        if (topColumn !== null && bottomColumn !== null) {
+          for (let column = 0; column < renderedColumns; column += 1) {
+            const sourceCol = wotInstance.wtTable.columnFilter.renderedToSource(column);
+            if (sourceRow >= topRow && sourceRow <= bottomRow && sourceCol >= topColumn && sourceCol <= bottomColumn) {
+              // selected cell
+              if (this.settings.className) {
+                this.addClassAtCoords(wotInstance, sourceRow, sourceCol, this.settings.className, this.settings.markIntersections);
+              }
+            } else if (sourceRow >= topRow && sourceRow <= bottomRow) {
+              // selection is in this row
+              if (highlightRowClassName) {
+                this.addClassAtCoords(wotInstance, sourceRow, sourceCol, highlightRowClassName);
+              }
+            } else if (sourceCol >= topColumn && sourceCol <= bottomColumn) {
+              // selection is in this column
+              if (highlightColumnClassName) {
+                this.addClassAtCoords(wotInstance, sourceRow, sourceCol, highlightColumnClassName);
+              }
+            }
+            const additionalSelectionClass = wotInstance.getSetting('onAfterDrawSelection', sourceRow, sourceCol, this.settings.layerLevel);
+            if (typeof additionalSelectionClass === 'string') {
+              this.addClassAtCoords(wotInstance, sourceRow, sourceCol, additionalSelectionClass);
+            }
+          }
+        }
+      }
+    }
+    wotInstance.getSetting('onBeforeDrawBorders', corners, this.settings.className);
+    if (this.settings.border) {
+      // warning! border.appear modifies corners!
+      this.getBorder(wotInstance).appear(corners);
+    }
+  }
+
+  /**
+   * Cleans up all the DOM state related to a Selection instance. Call this prior to deleting a Selection instance.
+   */
+  destroy() {
+    Object.values(this.instanceBorders).forEach(border => border.destroy());
+  }
+}
+export default Selection;

package/3rdparty/walkontable/src/table/mixin/calculatedColumns.js

@@ -82,15 +82,6 @@ const calculatedColumns = {
    */
   getVisibleColumnsCount() {
     return this.dataAccessObject.countColumnsVisible;
-  },
-  /**
-   * Get the number of rendered row headers.
-   *
-   * @returns {number}
-   * @this Table
-   */
-  getRowHeadersCount() {
-    return this.dataAccessObject.rowHeaders.length;
   }
 };
 (0, _object.defineGetter)(calculatedColumns, 'MIXIN_NAME', MIXIN_NAME, {

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

@@ -79,15 +79,6 @@ const calculatedColumns = {
    */
   getVisibleColumnsCount() {
     return this.dataAccessObject.countColumnsVisible;
-  },
-  /**
-   * Get the number of rendered row headers.
-   *
-   * @returns {number}
-   * @this Table
-   */
-  getRowHeadersCount() {
-    return this.dataAccessObject.rowHeaders.length;
   }
 };
 defineGetter(calculatedColumns, 'MIXIN_NAME', MIXIN_NAME, {

package/3rdparty/walkontable/src/table/mixin/calculatedRows.js

@@ -82,15 +82,6 @@ const calculatedRows = {
    */
   getVisibleRowsCount() {
     return this.dataAccessObject.countRowsVisible;
-  },
-  /**
-   * Get the number of rendered column headers.
-   *
-   * @returns {number}
-   * @this Table
-   */
-  getColumnHeadersCount() {
-    return this.dataAccessObject.columnHeaders.length;
   }
 };
 (0, _object.defineGetter)(calculatedRows, 'MIXIN_NAME', MIXIN_NAME, {

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

@@ -79,15 +79,6 @@ const calculatedRows = {
    */
   getVisibleRowsCount() {
     return this.dataAccessObject.countRowsVisible;
-  },
-  /**
-   * Get the number of rendered column headers.
-   *
-   * @returns {number}
-   * @this Table
-   */
-  getColumnHeadersCount() {
-    return this.dataAccessObject.columnHeaders.length;
   }
 };
 defineGetter(calculatedRows, 'MIXIN_NAME', MIXIN_NAME, {

package/3rdparty/walkontable/src/table/mixin/stickyColumnsStart.js

@@ -74,15 +74,6 @@ const stickyColumnsStart = {
    */
   getVisibleColumnsCount() {
     return this.getRenderedColumnsCount();
-  },
-  /**
-   * Get the number of rendered row headers.
-   *
-   * @returns {number}
-   * @this Table
-   */
-  getRowHeadersCount() {
-    return this.dataAccessObject.rowHeaders.length;
   }
 };
 (0, _object.defineGetter)(stickyColumnsStart, 'MIXIN_NAME', MIXIN_NAME, {

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

@@ -71,15 +71,6 @@ const stickyColumnsStart = {
    */
   getVisibleColumnsCount() {
     return this.getRenderedColumnsCount();
-  },
-  /**
-   * Get the number of rendered row headers.
-   *
-   * @returns {number}
-   * @this Table
-   */
-  getRowHeadersCount() {
-    return this.dataAccessObject.rowHeaders.length;
   }
 };
 defineGetter(stickyColumnsStart, 'MIXIN_NAME', MIXIN_NAME, {

package/3rdparty/walkontable/src/table/mixin/stickyRowsBottom.js

@@ -79,15 +79,6 @@ const stickyRowsBottom = {
    */
   getVisibleRowsCount() {
     return this.getRenderedRowsCount();
-  },
-  /**
-   * Get the number of rendered column headers.
-   *
-   * @returns {number}
-   * @this Table
-   */
-  getColumnHeadersCount() {
-    return 0;
   }
 };
 (0, _object.defineGetter)(stickyRowsBottom, 'MIXIN_NAME', MIXIN_NAME, {

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

@@ -76,15 +76,6 @@ const stickyRowsBottom = {
    */
   getVisibleRowsCount() {
     return this.getRenderedRowsCount();
-  },
-  /**
-   * Get the number of rendered column headers.
-   *
-   * @returns {number}
-   * @this Table
-   */
-  getColumnHeadersCount() {
-    return 0;
   }
 };
 defineGetter(stickyRowsBottom, 'MIXIN_NAME', MIXIN_NAME, {

package/3rdparty/walkontable/src/table/mixin/stickyRowsTop.js

@@ -74,15 +74,6 @@ const stickyRowsTop = {
    */
   getVisibleRowsCount() {
     return this.getRenderedRowsCount();
-  },
-  /**
-   * Get the number of rendered column headers.
-   *
-   * @returns {number}
-   * @this Table
-   */
-  getColumnHeadersCount() {
-    return this.dataAccessObject.columnHeaders.length;
   }
 };
 (0, _object.defineGetter)(stickyRowsTop, 'MIXIN_NAME', MIXIN_NAME, {

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

@@ -71,15 +71,6 @@ const stickyRowsTop = {
    */
   getVisibleRowsCount() {
     return this.getRenderedRowsCount();
-  },
-  /**
-   * Get the number of rendered column headers.
-   *
-   * @returns {number}
-   * @this Table
-   */
-  getColumnHeadersCount() {
-    return this.dataAccessObject.columnHeaders.length;
   }
 };
 defineGetter(stickyRowsTop, 'MIXIN_NAME', MIXIN_NAME, {

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

@@ -1,8 +1,8 @@
 "use strict";
 
 exports.__esModule = true;
-require("core-js/modules/es.error.cause.js");
 require("core-js/modules/es.array.push.js");
+require("core-js/modules/es.error.cause.js");
 var _element = require("../../../helpers/dom/element");
 var _function = require("../../../helpers/function");
 var _column = _interopRequireDefault(require("./filter/column"));
@@ -345,7 +345,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();
@@ -437,6 +437,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++) {
+      (0, _element.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
@@ -558,14 +627,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];
   }
 
@@ -576,6 +645,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++) {