handsontable 0.0.0-next-08765b9-20230809 → 0.0.0-next-912c214-20230818

package/3rdparty/walkontable/src/facade/core.js

@@ -50,8 +50,8 @@ class WalkontableFacade {
     return this._wot.cloneOverlay; // todo create facade
   }
 
-  get selectionManager() {
-    return this._wot.selectionManager; // todo create facade
+  get selections() {
+    return this._wot.selections; // todo create facade
   }
 
   get wtViewport() {

package/3rdparty/walkontable/src/facade/core.mjs

@@ -46,8 +46,8 @@ export default class WalkontableFacade {
     return this._wot.cloneOverlay; // todo create facade
   }
 
-  get selectionManager() {
-    return this._wot.selectionManager; // todo create facade
+  get selections() {
+    return this._wot.selections; // todo create facade
   }
 
   get wtViewport() {

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

@@ -12,16 +12,8 @@ exports.CellRange = _range.default;
 var _core = _interopRequireDefault(require("./facade/core"));
 exports.default = _core.default;
 exports.Core = _core.default;
-var _selection = require("./selection");
-exports.Selection = _selection.Selection;
-exports.HIGHLIGHT_ACTIVE_HEADER_TYPE = _selection.ACTIVE_HEADER_TYPE;
-exports.HIGHLIGHT_AREA_TYPE = _selection.AREA_TYPE;
-exports.HIGHLIGHT_FOCUS_TYPE = _selection.FOCUS_TYPE;
-exports.HIGHLIGHT_FILL_TYPE = _selection.FILL_TYPE;
-exports.HIGHLIGHT_HEADER_TYPE = _selection.HEADER_TYPE;
-exports.HIGHLIGHT_ROW_TYPE = _selection.ROW_TYPE;
-exports.HIGHLIGHT_COLUMN_TYPE = _selection.COLUMN_TYPE;
-exports.HIGHLIGHT_CUSTOM_SELECTION_TYPE = _selection.CUSTOM_SELECTION_TYPE;
+var _selection = _interopRequireDefault(require("./selection"));
+exports.Selection = _selection.default;
 var Renderer = _interopRequireWildcard(require("./renderer"));
 exports.Renderer = Renderer;
 var _orderView = require("./utils/orderView");

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

@@ -3,8 +3,8 @@ import ViewportRowsCalculator from "./calculator/viewportRows.mjs";
 import CellCoords from "./cell/coords.mjs";
 import CellRange from "./cell/range.mjs";
 import Walkontable from "./facade/core.mjs";
-import { Selection, ACTIVE_HEADER_TYPE, AREA_TYPE, FOCUS_TYPE, FILL_TYPE, HEADER_TYPE, ROW_TYPE, COLUMN_TYPE, CUSTOM_SELECTION_TYPE } from "./selection/index.mjs";
+import Selection from "./selection.mjs";
 import * as Renderer from "./renderer/index.mjs";
 import { OrderView, SharedOrderView } from "./utils/orderView/index.mjs";
 import { getListenersCounter } from "../../../eventManager.mjs";
-export { ViewportColumnsCalculator, ViewportRowsCalculator, CellCoords, CellRange, Walkontable as default, Walkontable as Core, Selection, ACTIVE_HEADER_TYPE as HIGHLIGHT_ACTIVE_HEADER_TYPE, AREA_TYPE as HIGHLIGHT_AREA_TYPE, FOCUS_TYPE as HIGHLIGHT_FOCUS_TYPE, FILL_TYPE as HIGHLIGHT_FILL_TYPE, HEADER_TYPE as HIGHLIGHT_HEADER_TYPE, ROW_TYPE as HIGHLIGHT_ROW_TYPE, COLUMN_TYPE as HIGHLIGHT_COLUMN_TYPE, CUSTOM_SELECTION_TYPE as HIGHLIGHT_CUSTOM_SELECTION_TYPE, Renderer, OrderView, SharedOrderView, getListenersCounter };
+export { ViewportColumnsCalculator, ViewportRowsCalculator, CellCoords, CellRange, Walkontable as default, Walkontable as Core, Selection, Renderer, OrderView, SharedOrderView, getListenersCounter };

package/3rdparty/walkontable/src/overlay/_base.js

@@ -281,7 +281,7 @@ class Overlay {
       // todo ioc , or factor func if used only here
       event: this.wot.wtEvent,
       // todo ioc , or factory func if used only here
-      selectionManager: this.wot.selectionManager // todo ioc , or factory func if used only here
+      selections: this.wot.selections // todo ioc , or factory func if used only here
     });
   }
 

package/3rdparty/walkontable/src/overlay/_base.mjs

@@ -277,7 +277,7 @@ export class Overlay {
       // todo ioc , or factor func if used only here
       event: this.wot.wtEvent,
       // todo ioc , or factory func if used only here
-      selectionManager: this.wot.selectionManager // todo ioc , or factory func if used only here
+      selections: this.wot.selections // todo ioc , or factory func if used only here
     });
   }
 

package/3rdparty/walkontable/src/overlay/inlineStart.js

@@ -5,7 +5,6 @@ require("core-js/modules/es.error.cause.js");
 var _element = require("../../../../helpers/dom/element");
 var _inlineStart = _interopRequireDefault(require("../table/inlineStart"));
 var _base = require("./_base");
-var _selection = require("../selection");
 var _constants = require("./constants");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 /**
@@ -173,10 +172,15 @@ class InlineStartOverlay extends _base.Overlay {
    * Adjust overlay root childs size.
    */
   adjustRootChildrenSize() {
+    var _selections$getCell$g;
     const {
       holder
     } = this.clone.wtTable;
-    const selectionCornerOffset = this.wot.selectionManager.getFocusSelection() ? parseInt(_selection.CORNER_DEFAULT_STYLE.width, 10) / 2 : 0;
+    const {
+      selections
+    } = this.wot;
+    const facade = this.facadeGetter();
+    const selectionCornerOffset = Math.abs((_selections$getCell$g = selections === null || selections === void 0 ? void 0 : selections.getCell().getBorder(facade).cornerCenterPointOffset) !== null && _selections$getCell$g !== void 0 ? _selections$getCell$g : 0);
     this.clone.wtTable.hider.style.height = this.hider.style.height;
     holder.style.height = holder.parentNode.style.height;
     // Add selection corner protruding part to the holder total width to make sure that

package/3rdparty/walkontable/src/overlay/inlineStart.mjs

@@ -2,7 +2,6 @@ import "core-js/modules/es.error.cause.js";
 import { addClass, getScrollbarWidth, getScrollLeft, getWindowScrollTop, hasClass, outerWidth, removeClass, setOverlayPosition, resetCssTransform } from "../../../../helpers/dom/element.mjs";
 import InlineStartOverlayTable from "../table/inlineStart.mjs";
 import { Overlay } from "./_base.mjs";
-import { CORNER_DEFAULT_STYLE } from "../selection/index.mjs";
 import { CLONE_INLINE_START } from "./constants.mjs";
 /**
  * @class InlineStartOverlay
@@ -169,10 +168,15 @@ export class InlineStartOverlay extends Overlay {
    * Adjust overlay root childs size.
    */
   adjustRootChildrenSize() {
+    var _selections$getCell$g;
     const {
       holder
     } = this.clone.wtTable;
-    const selectionCornerOffset = this.wot.selectionManager.getFocusSelection() ? parseInt(CORNER_DEFAULT_STYLE.width, 10) / 2 : 0;
+    const {
+      selections
+    } = this.wot;
+    const facade = this.facadeGetter();
+    const selectionCornerOffset = Math.abs((_selections$getCell$g = selections === null || selections === void 0 ? void 0 : selections.getCell().getBorder(facade).cornerCenterPointOffset) !== null && _selections$getCell$g !== void 0 ? _selections$getCell$g : 0);
     this.clone.wtTable.hider.style.height = this.hider.style.height;
     holder.style.height = holder.parentNode.style.height;
     // Add selection corner protruding part to the holder total width to make sure that

package/3rdparty/walkontable/src/overlay/top.js

@@ -5,7 +5,6 @@ require("core-js/modules/es.error.cause.js");
 var _element = require("../../../../helpers/dom/element");
 var _top = _interopRequireDefault(require("./../table/top"));
 var _base = require("./_base");
-var _selection = require("../selection");
 var _constants = require("./constants");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 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; }
@@ -200,10 +199,15 @@ class TopOverlay extends _base.Overlay {
    * Adjust overlay root childs size.
    */
   adjustRootChildrenSize() {
+    var _selections$getCell$g;
     const {
       holder
     } = this.clone.wtTable;
-    const selectionCornerOffset = this.wot.selectionManager.getFocusSelection() ? parseInt(_selection.CORNER_DEFAULT_STYLE.height, 10) / 2 : 0;
+    const {
+      selections
+    } = this.wot;
+    const facade = this.facadeGetter();
+    const selectionCornerOffset = Math.abs((_selections$getCell$g = selections === null || selections === void 0 ? void 0 : selections.getCell().getBorder(facade).cornerCenterPointOffset) !== null && _selections$getCell$g !== void 0 ? _selections$getCell$g : 0);
     this.clone.wtTable.hider.style.width = this.hider.style.width;
     holder.style.width = holder.parentNode.style.width;
     // Add selection corner protruding part to the holder total height to make sure that

package/3rdparty/walkontable/src/overlay/top.mjs

@@ -5,7 +5,6 @@ function _toPrimitive(input, hint) { if (typeof input !== "object" || input ===
 import { addClass, getScrollbarWidth, getScrollTop, getWindowScrollLeft, hasClass, outerHeight, removeClass, setOverlayPosition, resetCssTransform } from "../../../../helpers/dom/element.mjs";
 import TopOverlayTable from "./../table/top.mjs";
 import { Overlay } from "./_base.mjs";
-import { CORNER_DEFAULT_STYLE } from "../selection/index.mjs";
 import { CLONE_TOP } from "./constants.mjs";
 /**
  * @class TopOverlay
@@ -196,10 +195,15 @@ export class TopOverlay extends Overlay {
    * Adjust overlay root childs size.
    */
   adjustRootChildrenSize() {
+    var _selections$getCell$g;
     const {
       holder
     } = this.clone.wtTable;
-    const selectionCornerOffset = this.wot.selectionManager.getFocusSelection() ? parseInt(CORNER_DEFAULT_STYLE.height, 10) / 2 : 0;
+    const {
+      selections
+    } = this.wot;
+    const facade = this.facadeGetter();
+    const selectionCornerOffset = Math.abs((_selections$getCell$g = selections === null || selections === void 0 ? void 0 : selections.getCell().getBorder(facade).cornerCenterPointOffset) !== null && _selections$getCell$g !== void 0 ? _selections$getCell$g : 0);
     this.clone.wtTable.hider.style.width = this.hider.style.width;
     holder.style.width = holder.parentNode.style.width;
     // Add selection corner protruding part to the holder total height to make sure that

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

@@ -0,0 +1,295 @@
+"use strict";
+
+exports.__esModule = true;
+require("core-js/modules/es.array.push.js");
+var _element = require("./../../../helpers/dom/element");
+var _border = _interopRequireDefault(require("./border"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * @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.default(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);
+        }
+      }
+      (0, _element.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 ((0, _element.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);
+            }
+            (0, _element.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);
+            }
+            (0, _element.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());
+  }
+}
+var _default = Selection;
+exports.default = _default;