handsontable 14.2.0-next-75c8bcd-20240306 → 14.3.0-next-13fe676-20240409

package/selection/transformation.js

@@ -8,12 +8,9 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
 function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
 function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
-function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
-function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
-function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
-function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
-function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
-function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
+function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
+function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
+function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
 /**
  * The Transformation class implements algorithms for transforming coordinates based on current settings
  * passed to the Handsontable. The class performs the calculations based on the renderable indexes.
@@ -32,67 +29,29 @@ function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.
 var _range = /*#__PURE__*/new WeakMap();
 var _options = /*#__PURE__*/new WeakMap();
 var _offset = /*#__PURE__*/new WeakMap();
-var _setOffsetSize = /*#__PURE__*/new WeakSet();
-var _clampCoords = /*#__PURE__*/new WeakSet();
-var _getTableSize = /*#__PURE__*/new WeakSet();
-var _visualToZeroBasedCoords = /*#__PURE__*/new WeakSet();
-var _zeroBasedToVisualCoords = /*#__PURE__*/new WeakSet();
+var _Transformation_brand = /*#__PURE__*/new WeakSet();
 class Transformation {
   constructor(range, options) {
-    /**
-     * Translates the zero-based coordinates to visual ones.
-     *
-     * @param {CellCoords} zeroBasedCoords The coordinates to process.
-     * @returns {CellCoords}
-     */
-    _classPrivateMethodInitSpec(this, _zeroBasedToVisualCoords);
-    /**
-     * Translates the visual coordinates to zero-based ones.
-     *
-     * @param {CellCoords} visualCoords The visual coords to process.
-     * @returns {CellCoords}
-     */
-    _classPrivateMethodInitSpec(this, _visualToZeroBasedCoords);
-    /**
-     * Gets the table size in number of rows with headers as "height" and number of columns with
-     * headers as "width".
-     *
-     * @returns {{width: number, height: number}}
-     */
-    _classPrivateMethodInitSpec(this, _getTableSize);
     /**
      * Clamps the coords to make sure they points to the cell (or header) in the table range.
      *
      * @param {CellCoords} zeroBasedCoords The coords object to clamp.
      * @returns {{rowDir: 1|0|-1, colDir: 1|0|-1}}
      */
-    _classPrivateMethodInitSpec(this, _clampCoords);
-    /**
-     * Sets the additional offset in table size that may occur when the `navigableHeaders` option
-     * is enabled.
-     *
-     * @param {{x: number, y: number}} offset Offset as x and y properties.
-     */
-    _classPrivateMethodInitSpec(this, _setOffsetSize);
+    _classPrivateMethodInitSpec(this, _Transformation_brand);
     /**
      * Instance of the SelectionRange, holder for visual coordinates applied to the table.
      *
      * @type {SelectionRange}
      */
-    _classPrivateFieldInitSpec(this, _range, {
-      writable: true,
-      value: void 0
-    });
+    _classPrivateFieldInitSpec(this, _range, void 0);
     /**
      * Additional options which define the state of the settings which can infer transformation and
      * give the possibility to translate indexes.
      *
      * @type {object}
      */
-    _classPrivateFieldInitSpec(this, _options, {
-      writable: true,
-      value: void 0
-    });
+    _classPrivateFieldInitSpec(this, _options, void 0);
     /**
      * Increases the table size by applying the offsets. The option is used by the `navigableHeaders`
      * option.
@@ -100,14 +59,11 @@ class Transformation {
      * @type {{ x: number, y: number }}
      */
     _classPrivateFieldInitSpec(this, _offset, {
-      writable: true,
-      value: {
-        x: 0,
-        y: 0
-      }
+      x: 0,
+      y: 0
     });
-    _classPrivateFieldSet(this, _range, range);
-    _classPrivateFieldSet(this, _options, options);
+    _classPrivateFieldSet(_range, this, range);
+    _classPrivateFieldSet(_options, this, options);
   }
 
   /**
@@ -121,13 +77,9 @@ class Transformation {
    */
   transformStart(rowDelta, colDelta) {
     let createMissingRecords = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-    _classPrivateMethodGet(this, _setOffsetSize, _setOffsetSize2).call(this, {
-      x: _classPrivateFieldGet(this, _options).navigableHeaders() ? _classPrivateFieldGet(this, _options).countRowHeaders() : 0,
-      y: _classPrivateFieldGet(this, _options).navigableHeaders() ? _classPrivateFieldGet(this, _options).countColHeaders() : 0
-    });
-    const delta = _classPrivateFieldGet(this, _options).createCellCoords(rowDelta, colDelta);
-    let visualCoords = _classPrivateFieldGet(this, _range).current().highlight;
-    const highlightRenderableCoords = _classPrivateFieldGet(this, _options).visualToRenderableCoords(visualCoords);
+    const delta = _classPrivateFieldGet(_options, this).createCellCoords(rowDelta, colDelta);
+    let visualCoords = _classPrivateFieldGet(_range, this).current().highlight;
+    const highlightRenderableCoords = _classPrivateFieldGet(_options, this).visualToRenderableCoords(visualCoords);
     let rowTransformDir = 0;
     let colTransformDir = 0;
     this.runLocalHooks('beforeTransformStart', delta);
@@ -135,32 +87,32 @@ class Transformation {
       const {
         width,
         height
-      } = _classPrivateMethodGet(this, _getTableSize, _getTableSize2).call(this);
+      } = _assertClassBrand(_Transformation_brand, this, _getTableSize).call(this);
       const {
         row,
         col
-      } = _classPrivateMethodGet(this, _visualToZeroBasedCoords, _visualToZeroBasedCoords2).call(this, visualCoords);
-      const fixedRowsBottom = _classPrivateFieldGet(this, _options).fixedRowsBottom();
-      const minSpareRows = _classPrivateFieldGet(this, _options).minSpareRows();
-      const minSpareCols = _classPrivateFieldGet(this, _options).minSpareCols();
-      const autoWrapRow = _classPrivateFieldGet(this, _options).autoWrapRow();
-      const autoWrapCol = _classPrivateFieldGet(this, _options).autoWrapCol();
-      const zeroBasedCoords = _classPrivateFieldGet(this, _options).createCellCoords(row + delta.row, col + delta.col);
+      } = _assertClassBrand(_Transformation_brand, this, _visualToZeroBasedCoords).call(this, visualCoords);
+      const fixedRowsBottom = _classPrivateFieldGet(_options, this).fixedRowsBottom();
+      const minSpareRows = _classPrivateFieldGet(_options, this).minSpareRows();
+      const minSpareCols = _classPrivateFieldGet(_options, this).minSpareCols();
+      const autoWrapRow = _classPrivateFieldGet(_options, this).autoWrapRow();
+      const autoWrapCol = _classPrivateFieldGet(_options, this).autoWrapCol();
+      const zeroBasedCoords = _classPrivateFieldGet(_options, this).createCellCoords(row + delta.row, col + delta.col);
       if (zeroBasedCoords.row >= height) {
         const isActionInterrupted = (0, _object.createObjectPropListener)(createMissingRecords && minSpareRows > 0 && fixedRowsBottom === 0);
         const nextColumn = zeroBasedCoords.col + 1;
-        const newCoords = _classPrivateFieldGet(this, _options).createCellCoords(zeroBasedCoords.row - height, nextColumn >= width ? nextColumn - width : nextColumn);
-        this.runLocalHooks('beforeColumnWrap', isActionInterrupted, _classPrivateMethodGet(this, _zeroBasedToVisualCoords, _zeroBasedToVisualCoords2).call(this, newCoords), nextColumn >= width);
+        const newCoords = _classPrivateFieldGet(_options, this).createCellCoords(zeroBasedCoords.row - height, nextColumn >= width ? nextColumn - width : nextColumn);
+        this.runLocalHooks('beforeColumnWrap', isActionInterrupted, _assertClassBrand(_Transformation_brand, this, _zeroBasedToVisualCoords).call(this, newCoords), nextColumn >= width);
         if (isActionInterrupted.value) {
-          this.runLocalHooks('insertRowRequire', _classPrivateFieldGet(this, _options).countRenderableRows());
+          this.runLocalHooks('insertRowRequire', _classPrivateFieldGet(_options, this).countRenderableRows());
         } else if (autoWrapCol) {
           zeroBasedCoords.assign(newCoords);
         }
       } else if (zeroBasedCoords.row < 0) {
         const isActionInterrupted = (0, _object.createObjectPropListener)(autoWrapCol);
         const previousColumn = zeroBasedCoords.col - 1;
-        const newCoords = _classPrivateFieldGet(this, _options).createCellCoords(height + zeroBasedCoords.row, previousColumn < 0 ? width + previousColumn : previousColumn);
-        this.runLocalHooks('beforeColumnWrap', isActionInterrupted, _classPrivateMethodGet(this, _zeroBasedToVisualCoords, _zeroBasedToVisualCoords2).call(this, newCoords), previousColumn < 0);
+        const newCoords = _classPrivateFieldGet(_options, this).createCellCoords(height + zeroBasedCoords.row, previousColumn < 0 ? width + previousColumn : previousColumn);
+        this.runLocalHooks('beforeColumnWrap', isActionInterrupted, _assertClassBrand(_Transformation_brand, this, _zeroBasedToVisualCoords).call(this, newCoords), previousColumn < 0);
         if (autoWrapCol) {
           zeroBasedCoords.assign(newCoords);
         }
@@ -168,18 +120,18 @@ class Transformation {
       if (zeroBasedCoords.col >= width) {
         const isActionInterrupted = (0, _object.createObjectPropListener)(createMissingRecords && minSpareCols > 0);
         const nextRow = zeroBasedCoords.row + 1;
-        const newCoords = _classPrivateFieldGet(this, _options).createCellCoords(nextRow >= height ? nextRow - height : nextRow, zeroBasedCoords.col - width);
-        this.runLocalHooks('beforeRowWrap', isActionInterrupted, _classPrivateMethodGet(this, _zeroBasedToVisualCoords, _zeroBasedToVisualCoords2).call(this, newCoords), nextRow >= height);
+        const newCoords = _classPrivateFieldGet(_options, this).createCellCoords(nextRow >= height ? nextRow - height : nextRow, zeroBasedCoords.col - width);
+        this.runLocalHooks('beforeRowWrap', isActionInterrupted, _assertClassBrand(_Transformation_brand, this, _zeroBasedToVisualCoords).call(this, newCoords), nextRow >= height);
         if (isActionInterrupted.value) {
-          this.runLocalHooks('insertColRequire', _classPrivateFieldGet(this, _options).countRenderableColumns());
+          this.runLocalHooks('insertColRequire', _classPrivateFieldGet(_options, this).countRenderableColumns());
         } else if (autoWrapRow) {
           zeroBasedCoords.assign(newCoords);
         }
       } else if (zeroBasedCoords.col < 0) {
         const isActionInterrupted = (0, _object.createObjectPropListener)(autoWrapRow);
         const previousRow = zeroBasedCoords.row - 1;
-        const newCoords = _classPrivateFieldGet(this, _options).createCellCoords(previousRow < 0 ? height + previousRow : previousRow, width + zeroBasedCoords.col);
-        this.runLocalHooks('beforeRowWrap', isActionInterrupted, _classPrivateMethodGet(this, _zeroBasedToVisualCoords, _zeroBasedToVisualCoords2).call(this, newCoords), previousRow < 0);
+        const newCoords = _classPrivateFieldGet(_options, this).createCellCoords(previousRow < 0 ? height + previousRow : previousRow, width + zeroBasedCoords.col);
+        this.runLocalHooks('beforeRowWrap', isActionInterrupted, _assertClassBrand(_Transformation_brand, this, _zeroBasedToVisualCoords).call(this, newCoords), previousRow < 0);
         if (autoWrapRow) {
           zeroBasedCoords.assign(newCoords);
         }
@@ -187,10 +139,10 @@ class Transformation {
       const {
         rowDir,
         colDir
-      } = _classPrivateMethodGet(this, _clampCoords, _clampCoords2).call(this, zeroBasedCoords);
+      } = _assertClassBrand(_Transformation_brand, this, _clampCoords).call(this, zeroBasedCoords);
       rowTransformDir = rowDir;
       colTransformDir = colDir;
-      visualCoords = _classPrivateMethodGet(this, _zeroBasedToVisualCoords, _zeroBasedToVisualCoords2).call(this, zeroBasedCoords);
+      visualCoords = _assertClassBrand(_Transformation_brand, this, _zeroBasedToVisualCoords).call(this, zeroBasedCoords);
     }
     this.runLocalHooks('afterTransformStart', visualCoords, rowTransformDir, colTransformDir);
     return visualCoords;
@@ -204,30 +156,53 @@ class Transformation {
    * @returns {CellCoords} Visual coordinates after transformation.
    */
   transformEnd(rowDelta, colDelta) {
-    _classPrivateMethodGet(this, _setOffsetSize, _setOffsetSize2).call(this, {
-      x: _classPrivateFieldGet(this, _options).navigableHeaders() ? _classPrivateFieldGet(this, _options).countRowHeaders() : 0,
-      y: _classPrivateFieldGet(this, _options).navigableHeaders() ? _classPrivateFieldGet(this, _options).countColHeaders() : 0
-    });
-    const delta = _classPrivateFieldGet(this, _options).createCellCoords(rowDelta, colDelta);
-    const cellRange = _classPrivateFieldGet(this, _range).current();
-    const highlightRenderableCoords = _classPrivateFieldGet(this, _options).visualToRenderableCoords(cellRange.highlight);
+    const delta = _classPrivateFieldGet(_options, this).createCellCoords(rowDelta, colDelta);
+    const cellRange = _classPrivateFieldGet(_range, this).current();
+    const highlightRenderableCoords = _classPrivateFieldGet(_options, this).visualToRenderableCoords(cellRange.highlight);
+    const toRow = _assertClassBrand(_Transformation_brand, this, _findFirstNonHiddenZeroBasedRow).call(this, cellRange.to.row, cellRange.from.row);
+    const toColumn = _assertClassBrand(_Transformation_brand, this, _findFirstNonHiddenZeroBasedColumn).call(this, cellRange.to.col, cellRange.from.col);
     const visualCoords = cellRange.to.clone();
     let rowTransformDir = 0;
     let colTransformDir = 0;
     this.runLocalHooks('beforeTransformEnd', delta);
-    if (highlightRenderableCoords.row !== null && highlightRenderableCoords.col !== null) {
+    if (highlightRenderableCoords.row !== null && highlightRenderableCoords.col !== null && toRow !== null && toColumn !== null) {
       const {
-        row,
-        col
-      } = _classPrivateMethodGet(this, _visualToZeroBasedCoords, _visualToZeroBasedCoords2).call(this, cellRange.to);
-      const coords = _classPrivateFieldGet(this, _options).createCellCoords(row + delta.row, col + delta.col);
+        row: highlightRow,
+        col: highlightColumn
+      } = _assertClassBrand(_Transformation_brand, this, _visualToZeroBasedCoords).call(this, cellRange.highlight);
+      const coords = _classPrivateFieldGet(_options, this).createCellCoords(toRow + delta.row, toColumn + delta.col);
+      const topStartCorner = cellRange.getTopStartCorner();
+      const topEndCorner = cellRange.getTopEndCorner();
+      const bottomEndCorner = cellRange.getBottomEndCorner();
+      const restDelta = {
+        row: coords.row - highlightRow,
+        col: coords.col - highlightColumn
+      };
+      if (delta.col < 0) {
+        if (toColumn >= highlightColumn && coords.col < highlightColumn) {
+          coords.col = _assertClassBrand(_Transformation_brand, this, _findFirstNonHiddenZeroBasedColumn).call(this, topStartCorner.col, topEndCorner.col) + restDelta.col;
+        }
+      } else if (delta.col > 0) {
+        if (toColumn <= highlightColumn && coords.col > highlightColumn) {
+          coords.col = _assertClassBrand(_Transformation_brand, this, _findFirstNonHiddenZeroBasedColumn).call(this, topEndCorner.col, topStartCorner.col) + restDelta.col;
+        }
+      }
+      if (delta.row < 0) {
+        if (toRow >= highlightRow && coords.row < highlightRow) {
+          coords.row = _assertClassBrand(_Transformation_brand, this, _findFirstNonHiddenZeroBasedRow).call(this, topStartCorner.row, bottomEndCorner.row) + restDelta.row;
+        }
+      } else if (delta.row > 0) {
+        if (toRow <= highlightRow && coords.row > highlightRow) {
+          coords.row = _assertClassBrand(_Transformation_brand, this, _findFirstNonHiddenZeroBasedRow).call(this, bottomEndCorner.row, topStartCorner.row) + restDelta.row;
+        }
+      }
       const {
         rowDir,
         colDir
-      } = _classPrivateMethodGet(this, _clampCoords, _clampCoords2).call(this, coords);
+      } = _assertClassBrand(_Transformation_brand, this, _clampCoords).call(this, coords);
       rowTransformDir = rowDir;
       colTransformDir = colDir;
-      const newVisualCoords = _classPrivateMethodGet(this, _zeroBasedToVisualCoords, _zeroBasedToVisualCoords2).call(this, coords);
+      const newVisualCoords = _assertClassBrand(_Transformation_brand, this, _zeroBasedToVisualCoords).call(this, coords);
       if (delta.row === 0 && delta.col !== 0) {
         visualCoords.col = newVisualCoords.col;
       } else if (delta.row !== 0 && delta.col === 0) {
@@ -240,22 +215,29 @@ class Transformation {
     this.runLocalHooks('afterTransformEnd', visualCoords, rowTransformDir, colTransformDir);
     return visualCoords;
   }
+
+  /**
+   * Sets the additional offset in table size that may occur when the `navigableHeaders` option
+   * is enabled.
+   *
+   * @param {{x: number, y: number}} offset Offset as x and y properties.
+   */
+  setOffsetSize(_ref) {
+    let {
+      x,
+      y
+    } = _ref;
+    _classPrivateFieldSet(_offset, this, {
+      x,
+      y
+    });
+  }
 }
-function _setOffsetSize2(_ref) {
-  let {
-    x,
-    y
-  } = _ref;
-  _classPrivateFieldSet(this, _offset, {
-    x,
-    y
-  });
-}
-function _clampCoords2(zeroBasedCoords) {
+function _clampCoords(zeroBasedCoords) {
   const {
     width,
     height
-  } = _classPrivateMethodGet(this, _getTableSize, _getTableSize2).call(this);
+  } = _assertClassBrand(_Transformation_brand, this, _getTableSize).call(this);
   let rowDir = 0;
   let colDir = 0;
   if (zeroBasedCoords.row < 0) {
@@ -277,24 +259,73 @@ function _clampCoords2(zeroBasedCoords) {
     colDir
   };
 }
-function _getTableSize2() {
+/**
+ * Gets the table size in number of rows with headers as "height" and number of columns with
+ * headers as "width".
+ *
+ * @returns {{width: number, height: number}}
+ */
+function _getTableSize() {
   return {
-    width: _classPrivateFieldGet(this, _offset).x + _classPrivateFieldGet(this, _options).countRenderableColumns(),
-    height: _classPrivateFieldGet(this, _offset).y + _classPrivateFieldGet(this, _options).countRenderableRows()
+    width: _classPrivateFieldGet(_offset, this).x + _classPrivateFieldGet(_options, this).countRenderableColumns(),
+    height: _classPrivateFieldGet(_offset, this).y + _classPrivateFieldGet(_options, this).countRenderableRows()
   };
 }
-function _visualToZeroBasedCoords2(visualCoords) {
+/**
+ * Finds the first non-hidden zero-based row in the table range.
+ *
+ * @param {number} visualRowFrom The visual row from which the search should start.
+ * @param {number} visualRowTo The visual row to which the search should end.
+ * @returns {number | null}
+ */
+function _findFirstNonHiddenZeroBasedRow(visualRowFrom, visualRowTo) {
+  const row = _classPrivateFieldGet(_options, this).findFirstNonHiddenRenderableRow(visualRowFrom, visualRowTo);
+  if (row === null) {
+    return null;
+  }
+  return _classPrivateFieldGet(_offset, this).y + row;
+}
+/**
+ * Finds the first non-hidden zero-based column in the table range.
+ *
+ * @param {number} visualColumnFrom The visual column from which the search should start.
+ * @param {number} visualColumnTo The visual column to which the search should end.
+ * @returns {number | null}
+ */
+function _findFirstNonHiddenZeroBasedColumn(visualColumnFrom, visualColumnTo) {
+  const column = _classPrivateFieldGet(_options, this).findFirstNonHiddenRenderableColumn(visualColumnFrom, visualColumnTo);
+  if (column === null) {
+    return null;
+  }
+  return _classPrivateFieldGet(_offset, this).x + column;
+}
+/**
+ * Translates the visual coordinates to zero-based ones.
+ *
+ * @param {CellCoords} visualCoords The visual coords to process.
+ * @returns {CellCoords}
+ */
+function _visualToZeroBasedCoords(visualCoords) {
   const {
     row,
     col
-  } = _classPrivateFieldGet(this, _options).visualToRenderableCoords(visualCoords);
-  return _classPrivateFieldGet(this, _options).createCellCoords(_classPrivateFieldGet(this, _offset).y + row, _classPrivateFieldGet(this, _offset).x + col);
+  } = _classPrivateFieldGet(_options, this).visualToRenderableCoords(visualCoords);
+  if (row === null || col === null) {
+    throw new Error('Renderable coords are not visible.');
+  }
+  return _classPrivateFieldGet(_options, this).createCellCoords(_classPrivateFieldGet(_offset, this).y + row, _classPrivateFieldGet(_offset, this).x + col);
 }
-function _zeroBasedToVisualCoords2(zeroBasedCoords) {
+/**
+ * Translates the zero-based coordinates to visual ones.
+ *
+ * @param {CellCoords} zeroBasedCoords The coordinates to process.
+ * @returns {CellCoords}
+ */
+function _zeroBasedToVisualCoords(zeroBasedCoords) {
   const coords = zeroBasedCoords.clone();
-  coords.col = zeroBasedCoords.col - _classPrivateFieldGet(this, _offset).x;
-  coords.row = zeroBasedCoords.row - _classPrivateFieldGet(this, _offset).y;
-  return _classPrivateFieldGet(this, _options).renderableToVisualCoords(coords);
+  coords.col = zeroBasedCoords.col - _classPrivateFieldGet(_offset, this).x;
+  coords.row = zeroBasedCoords.row - _classPrivateFieldGet(_offset, this).y;
+  return _classPrivateFieldGet(_options, this).renderableToVisualCoords(coords);
 }
 (0, _object.mixin)(Transformation, _localHooks.default);
 var _default = exports.default = Transformation;