handsontable 14.4.0-next-1ffa7bc-20240606 → 14.5.0-next-ede811d-20240717

package/shortcuts/utils.js

@@ -1,13 +1,6 @@
 "use strict";
 
 exports.__esModule = true;
-require("core-js/modules/esnext.set.difference.v2.js");
-require("core-js/modules/esnext.set.intersection.v2.js");
-require("core-js/modules/esnext.set.is-disjoint-from.v2.js");
-require("core-js/modules/esnext.set.is-subset-of.v2.js");
-require("core-js/modules/esnext.set.is-superset-of.v2.js");
-require("core-js/modules/esnext.set.symmetric-difference.v2.js");
-require("core-js/modules/esnext.set.union.v2.js");
 // This file handles key-name discrepancies between browsers.
 // For the list of discrepancies, go to: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values.
 const mappings = new Map([[' ', 'space'],
@@ -42,36 +35,34 @@ exports.normalizeKeys = normalizeKeys;
 const getKeysList = normalizedKeys => {
   return normalizedKeys.split('+');
 };
-
-/**
- * The regex tests if the event.code matches to the pattern and it's used to extract letters and digits from
- * the string.
- */
 exports.getKeysList = getKeysList;
-const codeToKeyRegExp = new RegExp('^(?:Key|Digit)([A-Z0-9])$');
-const keyCodeNames = new Set(['Backquote', 'Minus', 'Equal', 'BracketLeft', 'BracketRight', 'Backslash', 'Semicolon', 'Quote', 'Comma', 'Period', 'Slash']);
+const specialCharactersSet = new Map([[186, 'semicolon'], [187, 'equal'], [188, 'comma'], [189, 'minus'], [190, 'period'], [191, 'slash'], [192, 'backquote'], [219, 'bracketleft'], [220, 'backslash'], [221, 'bracketright'], [222, 'quote']]);
 
 /**
- * Normalizes a keyboard event key value to a key before its modification. When the keyboard event
- * is triggered with Alt, Control or Shift keys the `key` property contains modified key e.g. for Alt+L
- * it will be `ł`. But that value is only valid for polish keyboard layout. To fix that limitations, for
- * letters and digits the value is taken from the `code` property which holds original value before
- * transformation.
+ * Normalizes a keyboard event key value to a key before its modification.
+ *
+ * Keep in mind that there is difference between `key` and `code` properties of the KeyboardEvent object.
+ * The `key` property represents the logical key on the keyboard (after applying modifiers and taking
+ * the keyboard layout into account), where the `code` property represents the physical key
+ * (regardless of what is printed on the key). Using the `keyCode` for alphanumeric keys,
+ * solves the problem and allows to get the correct key value. The value that takes the keyboard layout
+ * into account but is not modified by the modifiers (e.g. Alt + L would give polish "ł" we want "l").
  *
  * @param {Event} event The KeyboardEvent object.
  * @returns {string}
  */
 const normalizeEventKey = _ref => {
   let {
-    key,
-    code
+    which,
+    key
   } = _ref;
-  let normalizedKey = key;
-  if (codeToKeyRegExp.test(code)) {
-    normalizedKey = code.replace(codeToKeyRegExp, '$1');
-  } else if (keyCodeNames.has(code)) {
-    normalizedKey = code;
+  if (specialCharactersSet.has(which)) {
+    return specialCharactersSet.get(which);
+  }
+  const normalizedKey = String.fromCharCode(which).toLowerCase();
+  if (/^[a-z0-9]$/.test(normalizedKey)) {
+    return normalizedKey;
   }
-  return normalizedKey.toLowerCase();
+  return key.toLowerCase();
 };
 exports.normalizeEventKey = normalizeEventKey;

package/shortcuts/utils.mjs

@@ -1,10 +1,3 @@
-import "core-js/modules/esnext.set.difference.v2.js";
-import "core-js/modules/esnext.set.intersection.v2.js";
-import "core-js/modules/esnext.set.is-disjoint-from.v2.js";
-import "core-js/modules/esnext.set.is-subset-of.v2.js";
-import "core-js/modules/esnext.set.is-superset-of.v2.js";
-import "core-js/modules/esnext.set.symmetric-difference.v2.js";
-import "core-js/modules/esnext.set.union.v2.js";
 // This file handles key-name discrepancies between browsers.
 // For the list of discrepancies, go to: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values.
 const mappings = new Map([[' ', 'space'],
@@ -38,34 +31,32 @@ export const normalizeKeys = keys => {
 export const getKeysList = normalizedKeys => {
   return normalizedKeys.split('+');
 };
+const specialCharactersSet = new Map([[186, 'semicolon'], [187, 'equal'], [188, 'comma'], [189, 'minus'], [190, 'period'], [191, 'slash'], [192, 'backquote'], [219, 'bracketleft'], [220, 'backslash'], [221, 'bracketright'], [222, 'quote']]);
 
 /**
- * The regex tests if the event.code matches to the pattern and it's used to extract letters and digits from
- * the string.
- */
-const codeToKeyRegExp = new RegExp('^(?:Key|Digit)([A-Z0-9])$');
-const keyCodeNames = new Set(['Backquote', 'Minus', 'Equal', 'BracketLeft', 'BracketRight', 'Backslash', 'Semicolon', 'Quote', 'Comma', 'Period', 'Slash']);
-
-/**
- * Normalizes a keyboard event key value to a key before its modification. When the keyboard event
- * is triggered with Alt, Control or Shift keys the `key` property contains modified key e.g. for Alt+L
- * it will be `ł`. But that value is only valid for polish keyboard layout. To fix that limitations, for
- * letters and digits the value is taken from the `code` property which holds original value before
- * transformation.
+ * Normalizes a keyboard event key value to a key before its modification.
+ *
+ * Keep in mind that there is difference between `key` and `code` properties of the KeyboardEvent object.
+ * The `key` property represents the logical key on the keyboard (after applying modifiers and taking
+ * the keyboard layout into account), where the `code` property represents the physical key
+ * (regardless of what is printed on the key). Using the `keyCode` for alphanumeric keys,
+ * solves the problem and allows to get the correct key value. The value that takes the keyboard layout
+ * into account but is not modified by the modifiers (e.g. Alt + L would give polish "ł" we want "l").
  *
  * @param {Event} event The KeyboardEvent object.
  * @returns {string}
  */
 export const normalizeEventKey = _ref => {
   let {
-    key,
-    code
+    which,
+    key
   } = _ref;
-  let normalizedKey = key;
-  if (codeToKeyRegExp.test(code)) {
-    normalizedKey = code.replace(codeToKeyRegExp, '$1');
-  } else if (keyCodeNames.has(code)) {
-    normalizedKey = code;
+  if (specialCharactersSet.has(which)) {
+    return specialCharactersSet.get(which);
+  }
+  const normalizedKey = String.fromCharCode(which).toLowerCase();
+  if (/^[a-z0-9]$/.test(normalizedKey)) {
+    return normalizedKey;
   }
-  return normalizedKey.toLowerCase();
+  return key.toLowerCase();
 };

package/tableView.js

@@ -10,11 +10,11 @@ var _src = _interopRequireDefault(require("./3rdparty/walkontable/src"));
 var _mouseEventHandler = require("./selection/mouseEventHandler");
 var _rootInstance = require("./utils/rootInstance");
 var _a11y = require("./helpers/a11y");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-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 _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 _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
+function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
+function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
 function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
@@ -340,7 +340,7 @@ class TableView {
       // immediate click on "holder" means click on the right side of vertical scrollbar
       const {
         holder
-      } = this.hot.view._wt.wtTable;
+      } = this._wt.wtTable;
       if (next === holder) {
         const scrollbarWidth = (0, _element.getScrollbarWidth)(rootDocument);
         if (rootDocument.elementFromPoint(eventX + scrollbarWidth, eventY) !== holder || rootDocument.elementFromPoint(eventX, eventY + scrollbarWidth) !== holder) {
@@ -687,6 +687,11 @@ class TableView {
         const visualIndex = this.hot.rowIndexMapper.getVisualFromRenderableIndex(renderedRowIndex);
         return this.hot.getRowHeight(visualIndex === null ? renderedRowIndex : visualIndex);
       },
+      rowHeightByOverlayName: (renderedRowIndex, overlayType) => {
+        const visualIndex = this.hot.rowIndexMapper.getVisualFromRenderableIndex(renderedRowIndex);
+        const visualRowIndex = visualIndex === null ? renderedRowIndex : visualIndex;
+        return this.hot.runHooks('modifyRowHeightByOverlayName', this.hot.getRowHeight(visualRowIndex), visualRowIndex, overlayType);
+      },
       cellRenderer: (renderedRowIndex, renderedColumnIndex, TD) => {
         const [visualRowIndex, visualColumnIndex] = this.translateFromRenderableToVisualIndex(renderedRowIndex, renderedColumnIndex);
 
@@ -1015,7 +1020,7 @@ class TableView {
     if ((0, _element.isInput)(el)) {
       return true;
     }
-    const isChildOfTableBody = (0, _element.isChildOf)(el, this.hot.view._wt.wtTable.spreader);
+    const isChildOfTableBody = (0, _element.isChildOf)(el, this._wt.wtTable.spreader);
     if (this.settings.fragmentSelection === true && isChildOfTableBody) {
       return true;
     }
@@ -1135,10 +1140,16 @@ class TableView {
   appendColHeader(visualColumnIndex, TH) {
     let label = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.hot.getColHeader;
     let headerLevel = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+    const getColumnHeaderClassNames = () => {
+      const metaHeaderClassNames = visualColumnIndex >= 0 ? this.hot.getColumnMeta(visualColumnIndex).headerClassName : null;
+      return metaHeaderClassNames ? metaHeaderClassNames.split(' ') : [];
+    };
     if (TH.firstChild) {
       const container = TH.firstChild;
       if ((0, _element.hasClass)(container, 'relative')) {
         this.updateCellHeader(container.querySelector('.colHeader'), visualColumnIndex, label, headerLevel);
+        container.className = '';
+        (0, _element.addClass)(container, ['relative', ...getColumnHeaderClassNames()]);
       } else {
         (0, _element.empty)(TH);
         this.appendColHeader(visualColumnIndex, TH, label, headerLevel);
@@ -1149,7 +1160,8 @@ class TableView {
       } = this.hot;
       const div = rootDocument.createElement('div');
       const span = rootDocument.createElement('span');
-      div.className = 'relative';
+      const classNames = getColumnHeaderClassNames();
+      div.classList.add('relative', ...classNames);
       span.className = 'colHeader';
       if (this.settings.ariaTags) {
         (0, _element.setAttribute)(div, ...(0, _a11y.A11Y_PRESENTATION)());
@@ -1246,75 +1258,131 @@ class TableView {
   }
 
   /**
-   * Returns the first fully visible row in the table viewport.
+   * Returns the first rendered row in the DOM (usually is not visible in the table's viewport).
+   *
+   * @returns {number | null}
+   */
+  getFirstRenderedVisibleRow() {
+    if (!this._wt.wtViewport.rowsRenderCalculator) {
+      return null;
+    }
+    return this.hot.rowIndexMapper.getNearestNotHiddenIndex(this._wt.wtTable.getFirstRenderedRow(), 1);
+  }
+
+  /**
+   * Returns the last rendered row in the DOM (usually is not visible in the table's viewport).
+   *
+   * @returns {number | null}
+   */
+  getLastRenderedVisibleRow() {
+    if (!this._wt.wtViewport.rowsRenderCalculator) {
+      return null;
+    }
+    return this.hot.rowIndexMapper.getNearestNotHiddenIndex(this._wt.wtTable.getLastRenderedRow(), -1);
+  }
+
+  /**
+   * Returns the first rendered column in the DOM (usually is not visible in the table's viewport).
+   *
+   * @returns {number | null}
+   */
+  getFirstRenderedVisibleColumn() {
+    if (!this._wt.wtViewport.columnsRenderCalculator) {
+      return null;
+    }
+    return this.hot.columnIndexMapper.getNearestNotHiddenIndex(this._wt.wtTable.getFirstRenderedColumn(), 1);
+  }
+
+  /**
+   * Returns the last rendered column in the DOM (usually is not visible in the table's viewport).
+   *
+   * @returns {number | null}
+   */
+  getLastRenderedVisibleColumn() {
+    if (!this._wt.wtViewport.columnsRenderCalculator) {
+      return null;
+    }
+    return this.hot.columnIndexMapper.getNearestNotHiddenIndex(this._wt.wtTable.getLastRenderedColumn(), -1);
+  }
+
+  /**
+   * Returns the first fully visible row in the table viewport. When the table has overlays the method returns
+   * the first row of the master table that is not overlapped by overlay.
    *
    * @returns {number}
    */
   getFirstFullyVisibleRow() {
-    return this.hot.rowIndexMapper.getVisualFromRenderableIndex(this.hot.view._wt.wtScroll.getFirstVisibleRow());
+    return this.hot.rowIndexMapper.getVisualFromRenderableIndex(this._wt.wtScroll.getFirstVisibleRow());
   }
 
   /**
-   * Returns the last fully visible row in the table viewport.
+   * Returns the last fully visible row in the table viewport. When the table has overlays the method returns
+   * the first row of the master table that is not overlapped by overlay.
    *
    * @returns {number}
    */
   getLastFullyVisibleRow() {
-    return this.hot.rowIndexMapper.getVisualFromRenderableIndex(this.hot.view._wt.wtScroll.getLastVisibleRow());
+    return this.hot.rowIndexMapper.getVisualFromRenderableIndex(this._wt.wtScroll.getLastVisibleRow());
   }
 
   /**
-   * Returns the first fully visible column in the table viewport.
+   * Returns the first fully visible column in the table viewport. When the table has overlays the method returns
+   * the first row of the master table that is not overlapped by overlay.
    *
    * @returns {number}
    */
   getFirstFullyVisibleColumn() {
-    return this.hot.columnIndexMapper.getVisualFromRenderableIndex(this.hot.view._wt.wtScroll.getFirstVisibleColumn());
+    return this.hot.columnIndexMapper.getVisualFromRenderableIndex(this._wt.wtScroll.getFirstVisibleColumn());
   }
 
   /**
-   * Returns the last fully visible column in the table viewport.
+   * Returns the last fully visible column in the table viewport. When the table has overlays the method returns
+   * the first row of the master table that is not overlapped by overlay.
    *
    * @returns {number}
    */
   getLastFullyVisibleColumn() {
-    return this.hot.columnIndexMapper.getVisualFromRenderableIndex(this.hot.view._wt.wtScroll.getLastVisibleColumn());
+    return this.hot.columnIndexMapper.getVisualFromRenderableIndex(this._wt.wtScroll.getLastVisibleColumn());
   }
 
   /**
-   * Returns the first partially visible row in the table viewport.
+   * Returns the first partially visible row in the table viewport. When the table has overlays the method returns
+   * the first row of the master table that is not overlapped by overlay.
    *
    * @returns {number}
    */
   getFirstPartiallyVisibleRow() {
-    return this.hot.rowIndexMapper.getVisualFromRenderableIndex(this.hot.view._wt.wtScroll.getFirstPartiallyVisibleRow());
+    return this.hot.rowIndexMapper.getVisualFromRenderableIndex(this._wt.wtScroll.getFirstPartiallyVisibleRow());
   }
 
   /**
-   * Returns the last partially visible row in the table viewport.
+   * Returns the last partially visible row in the table viewport. When the table has overlays the method returns
+   * the first row of the master table that is not overlapped by overlay.
    *
    * @returns {number}
    */
   getLastPartiallyVisibleRow() {
-    return this.hot.rowIndexMapper.getVisualFromRenderableIndex(this.hot.view._wt.wtScroll.getLastPartiallyVisibleRow());
+    return this.hot.rowIndexMapper.getVisualFromRenderableIndex(this._wt.wtScroll.getLastPartiallyVisibleRow());
   }
 
   /**
-   * Returns the first partially visible column in the table viewport.
+   * Returns the first partially visible column in the table viewport. When the table has overlays the method returns
+   * the first row of the master table that is not overlapped by overlay.
    *
    * @returns {number}
    */
   getFirstPartiallyVisibleColumn() {
-    return this.hot.columnIndexMapper.getVisualFromRenderableIndex(this.hot.view._wt.wtScroll.getFirstPartiallyVisibleColumn());
+    return this.hot.columnIndexMapper.getVisualFromRenderableIndex(this._wt.wtScroll.getFirstPartiallyVisibleColumn());
   }
 
   /**
-   * Returns the last partially visible column in the table viewport.
+   * Returns the last partially visible column in the table viewport. When the table has overlays the method returns
+   * the first row of the master table that is not overlapped by overlay.
    *
    * @returns {number}
    */
   getLastPartiallyVisibleColumn() {
-    return this.hot.columnIndexMapper.getVisualFromRenderableIndex(this.hot.view._wt.wtScroll.getLastPartiallyVisibleColumn());
+    return this.hot.columnIndexMapper.getVisualFromRenderableIndex(this._wt.wtScroll.getLastPartiallyVisibleColumn());
   }
 
   /**
@@ -1343,7 +1411,7 @@ class TableView {
    * @returns {number}
    */
   getViewportWidth() {
-    return this.hot.view._wt.wtViewport.getViewportWidth();
+    return this._wt.wtViewport.getViewportWidth();
   }
 
   /**
@@ -1352,7 +1420,7 @@ class TableView {
    * @returns {number}
    */
   getWorkspaceWidth() {
-    return this.hot.view._wt.wtViewport.getWorkspaceWidth();
+    return this._wt.wtViewport.getWorkspaceWidth();
   }
 
   /**
@@ -1363,7 +1431,7 @@ class TableView {
    * @returns {number}
    */
   getViewportHeight() {
-    return this.hot.view._wt.wtViewport.getViewportHeight();
+    return this._wt.wtViewport.getViewportHeight();
   }
 
   /**
@@ -1372,7 +1440,37 @@ class TableView {
    * @returns {number}
    */
   getWorkspaceHeight() {
-    return this.hot.view._wt.wtViewport.getWorkspaceHeight();
+    return this._wt.wtViewport.getWorkspaceHeight();
+  }
+
+  /**
+   * Checks to what overlay the provided element belongs.
+   *
+   * @param {HTMLElement} element The DOM element to check.
+   * @returns {'master'|'inline_start'|'top'|'top_inline_start_corner'|'bottom'|'bottom_inline_start_corner'}
+   */
+  getElementOverlayName(element) {
+    var _this$_wt$wtOverlays$;
+    return ((_this$_wt$wtOverlays$ = this._wt.wtOverlays.getParentOverlay(element)) !== null && _this$_wt$wtOverlays$ !== void 0 ? _this$_wt$wtOverlays$ : this._wt).wtTable.name;
+  }
+
+  /**
+   * Gets the overlay instance by its name.
+   *
+   * @param {'inline_start'|'top'|'top_inline_start_corner'|'bottom'|'bottom_inline_start_corner'} overlayName The overlay name.
+   * @returns {Overlay | null}
+   */
+  getOverlayByName(overlayName) {
+    return this._wt.getOverlayByName(overlayName);
+  }
+
+  /**
+   * Checks if the table is visible or not.
+   *
+   * @returns {boolean}
+   */
+  isVisible() {
+    return this._wt.wtTable.isVisible();
   }
   /**
    * Destroys internal WalkOnTable's instance. Detaches all of the bonded listeners.