handsontable 11.1.0 → 12.1.0

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

@@ -4,9 +4,8 @@ function _defineProperties(target, props) { for (var i = 0; i < props.length; i+
 
 function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
 
-import { getScrollbarWidth, getStyle, offset, outerHeight, outerWidth } from "./../../../helpers/dom/element.mjs";
-import { objectEach } from "./../../../helpers/object.mjs";
-import EventManager from "./../../../eventManager.mjs";
+import { getScrollbarWidth, getStyle, offset, outerHeight, outerWidth } from "../../../helpers/dom/element.mjs";
+import { objectEach } from "../../../helpers/object.mjs";
 import { RENDER_TYPE, FULLY_VISIBLE_TYPE, ViewportColumnsCalculator, ViewportRowsCalculator } from "./calculator/index.mjs";
 /**
  * @class Viewport
@@ -14,16 +13,24 @@ import { RENDER_TYPE, FULLY_VISIBLE_TYPE, ViewportColumnsCalculator, ViewportRow
 
 var Viewport = /*#__PURE__*/function () {
   /**
-   * @param {Walkontable} wotInstance The Walkontable instance.
+   * @param {ViewportDao} dataAccessObject The Walkontable instance.
+   * @param {DomBindings} domBindings Bindings into DOM.
+   * @param {Settings} wtSettings The Walkontable settings.
+   * @param {EventManager} eventManager The instance event manager.
+   * @param {Table} wtTable The table.
    */
-  function Viewport(wotInstance) {
+  function Viewport(dataAccessObject, domBindings, wtSettings, eventManager, wtTable) {
     var _this = this;
 
     _classCallCheck(this, Viewport);
 
-    this.wot = wotInstance; // legacy support
+    this.dataAccessObject = dataAccessObject; // legacy support
 
+    this.wot = dataAccessObject.wot;
     this.instance = this.wot;
+    this.domBindings = domBindings;
+    this.wtSettings = wtSettings;
+    this.wtTable = wtTable;
     this.oversizedRows = [];
     this.oversizedColumnHeaders = [];
     this.hasOversizedColumnHeadersMarked = {};
@@ -32,8 +39,8 @@ var Viewport = /*#__PURE__*/function () {
     this.rowHeaderWidth = NaN;
     this.rowsVisibleCalculator = null;
     this.columnsVisibleCalculator = null;
-    this.eventManager = new EventManager(this.wot);
-    this.eventManager.addEventListener(this.wot.rootWindow, 'resize', function () {
+    this.eventManager = eventManager;
+    this.eventManager.addEventListener(this.domBindings.rootWindow, 'resize', function () {
       _this.clientHeight = _this.getWorkspaceHeight();
     });
   }
@@ -45,11 +52,11 @@ var Viewport = /*#__PURE__*/function () {
   _createClass(Viewport, [{
     key: "getWorkspaceHeight",
     value: function getWorkspaceHeight() {
-      var currentDocument = this.wot.rootDocument;
-      var trimmingContainer = this.instance.wtOverlays.topOverlay.trimmingContainer;
+      var currentDocument = this.domBindings.rootDocument;
+      var trimmingContainer = this.dataAccessObject.topOverlayTrimmingContainer;
       var height = 0;
 
-      if (trimmingContainer === this.wot.rootWindow) {
+      if (trimmingContainer === this.domBindings.rootWindow) {
         height = currentDocument.documentElement.clientHeight;
       } else {
         var elemHeight = outerHeight(trimmingContainer); // returns height without DIV scrollbar
@@ -62,24 +69,29 @@ var Viewport = /*#__PURE__*/function () {
   }, {
     key: "getWorkspaceWidth",
     value: function getWorkspaceWidth() {
-      var wot = this.wot;
-      var rootDocument = wot.rootDocument,
-          rootWindow = wot.rootWindow;
-      var trimmingContainer = this.instance.wtOverlays.leftOverlay.trimmingContainer;
+      var wtSettings = this.wtSettings;
+      var _this$domBindings = this.domBindings,
+          rootDocument = _this$domBindings.rootDocument,
+          rootWindow = _this$domBindings.rootWindow;
+      var trimmingContainer = this.dataAccessObject.inlineStartOverlayTrimmingContainer;
       var docOffsetWidth = rootDocument.documentElement.offsetWidth;
-      var totalColumns = wot.getSetting('totalColumns');
-      var preventOverflow = wot.getSetting('preventOverflow');
+      var totalColumns = wtSettings.getSetting('totalColumns');
+      var preventOverflow = wtSettings.getSetting('preventOverflow');
+      var isRtl = wtSettings.getSetting('rtlMode');
+      var tableRect = this.wtTable.TABLE.getBoundingClientRect();
+      var inlineStart = isRtl ? tableRect.right - docOffsetWidth : tableRect.left;
+      var tableOffset = docOffsetWidth - inlineStart;
       var width;
       var overflow;
 
       if (preventOverflow) {
-        return outerWidth(this.instance.wtTable.wtRootElement);
+        return outerWidth(this.wtTable.wtRootElement);
       }
 
-      if (wot.getSetting('freezeOverlays')) {
-        width = Math.min(docOffsetWidth - this.getWorkspaceOffset().left, docOffsetWidth);
+      if (wtSettings.getSetting('freezeOverlays')) {
+        width = Math.min(tableOffset, docOffsetWidth);
       } else {
-        width = Math.min(this.getContainerFillWidth(), docOffsetWidth - this.getWorkspaceOffset().left, docOffsetWidth);
+        width = Math.min(this.getContainerFillWidth(), tableOffset, docOffsetWidth);
       }
 
       if (trimmingContainer === rootWindow && totalColumns > 0 && this.sumColumnWidths(0, totalColumns - 1) > width) {
@@ -91,7 +103,7 @@ var Viewport = /*#__PURE__*/function () {
       }
 
       if (trimmingContainer !== rootWindow) {
-        overflow = getStyle(this.instance.wtOverlays.leftOverlay.trimmingContainer, 'overflow', rootWindow);
+        overflow = getStyle(this.dataAccessObject.inlineStartOverlayTrimmingContainer, 'overflow', rootWindow);
 
         if (overflow === 'scroll' || overflow === 'hidden' || overflow === 'auto') {
           // this is used in `scroll.html`
@@ -100,11 +112,11 @@ var Viewport = /*#__PURE__*/function () {
         }
       }
 
-      var stretchSetting = wot.getSetting('stretchH');
+      var stretchSetting = wtSettings.getSetting('stretchH');
 
       if (stretchSetting === 'none' || !stretchSetting) {
         // if no stretching is used, return the maximum used workspace width
-        return Math.max(width, outerWidth(this.instance.wtTable.TABLE));
+        return Math.max(width, outerWidth(this.wtTable.TABLE));
       } // if stretching is used, return the actual container width, so the columns can fit inside it
 
 
@@ -119,7 +131,7 @@ var Viewport = /*#__PURE__*/function () {
   }, {
     key: "hasVerticalScroll",
     value: function hasVerticalScroll() {
-      return this.getWorkspaceActualHeight() > this.getWorkspaceHeight();
+      return this.wtTable.hider.offsetHeight > this.getWorkspaceHeight();
     }
     /**
      * Checks if viewport has horizontal scroll.
@@ -130,7 +142,7 @@ var Viewport = /*#__PURE__*/function () {
   }, {
     key: "hasHorizontalScroll",
     value: function hasHorizontalScroll() {
-      return this.getWorkspaceActualWidth() > this.getWorkspaceWidth();
+      return this.wtTable.hider.offsetWidth > this.getWorkspaceWidth();
     }
     /**
      * @param {number} from The visual column index from the width sum is start calculated.
@@ -141,12 +153,11 @@ var Viewport = /*#__PURE__*/function () {
   }, {
     key: "sumColumnWidths",
     value: function sumColumnWidths(from, length) {
-      var wtTable = this.wot.wtTable;
       var sum = 0;
       var column = from;
 
       while (column < length) {
-        sum += wtTable.getColumnWidth(column);
+        sum += this.wtTable.getColumnWidth(column);
         column += 1;
       }
 
@@ -163,8 +174,8 @@ var Viewport = /*#__PURE__*/function () {
         return this.containerWidth;
       }
 
-      var mainContainer = this.instance.wtTable.holder;
-      var dummyElement = this.wot.rootDocument.createElement('div');
+      var mainContainer = this.wtTable.holder;
+      var dummyElement = this.domBindings.rootDocument.createElement('div');
       dummyElement.style.width = '100%';
       dummyElement.style.height = '1px';
       mainContainer.appendChild(dummyElement);
@@ -180,26 +191,7 @@ var Viewport = /*#__PURE__*/function () {
   }, {
     key: "getWorkspaceOffset",
     value: function getWorkspaceOffset() {
-      return offset(this.wot.wtTable.TABLE);
-    }
-    /**
-     * @returns {number}
-     */
-
-  }, {
-    key: "getWorkspaceActualHeight",
-    value: function getWorkspaceActualHeight() {
-      return outerHeight(this.wot.wtTable.TABLE);
-    }
-    /**
-     * @returns {number}
-     */
-
-  }, {
-    key: "getWorkspaceActualWidth",
-    value: function getWorkspaceActualWidth() {
-      var wtTable = this.wot.wtTable;
-      return outerWidth(wtTable.TABLE) || outerWidth(wtTable.TBODY) || outerWidth(wtTable.THEAD); // IE8 reports 0 as <table> offsetWidth;
+      return offset(this.wtTable.TABLE);
     }
     /**
      * @returns {number}
@@ -208,12 +200,12 @@ var Viewport = /*#__PURE__*/function () {
   }, {
     key: "getColumnHeaderHeight",
     value: function getColumnHeaderHeight() {
-      var columnHeaders = this.instance.getSetting('columnHeaders');
+      var columnHeaders = this.wtSettings.getSetting('columnHeaders');
 
       if (!columnHeaders.length) {
         this.columnHeaderHeight = 0;
       } else if (isNaN(this.columnHeaderHeight)) {
-        this.columnHeaderHeight = outerHeight(this.wot.wtTable.THEAD);
+        this.columnHeaderHeight = outerHeight(this.wtTable.THEAD);
       }
 
       return this.columnHeaderHeight;
@@ -246,8 +238,8 @@ var Viewport = /*#__PURE__*/function () {
   }, {
     key: "getRowHeaderWidth",
     value: function getRowHeaderWidth() {
-      var rowHeadersWidthSetting = this.instance.getSetting('rowHeaderWidth');
-      var rowHeaders = this.instance.getSetting('rowHeaders');
+      var rowHeadersWidthSetting = this.wtSettings.getSetting('rowHeaderWidth');
+      var rowHeaders = this.wtSettings.getSetting('rowHeaders');
 
       if (rowHeadersWidthSetting) {
         this.rowHeaderWidth = 0;
@@ -257,13 +249,9 @@ var Viewport = /*#__PURE__*/function () {
         }
       }
 
-      if (this.wot.cloneSource) {
-        return this.wot.cloneSource.wtViewport.getRowHeaderWidth();
-      }
-
       if (isNaN(this.rowHeaderWidth)) {
         if (rowHeaders.length) {
-          var TH = this.instance.wtTable.TABLE.querySelector('TH');
+          var TH = this.wtTable.TABLE.querySelector('TH');
           this.rowHeaderWidth = 0;
 
           for (var _i = 0, _len = rowHeaders.length; _i < _len; _i++) {
@@ -281,7 +269,7 @@ var Viewport = /*#__PURE__*/function () {
         }
       }
 
-      this.rowHeaderWidth = this.instance.getSetting('onModifyRowHeaderWidth', this.rowHeaderWidth) || this.rowHeaderWidth;
+      this.rowHeaderWidth = this.wtSettings.getSetting('onModifyRowHeaderWidth', this.rowHeaderWidth) || this.rowHeaderWidth;
       return this.rowHeaderWidth;
     }
     /**
@@ -319,57 +307,54 @@ var Viewport = /*#__PURE__*/function () {
     key: "createRowsCalculator",
     value: function createRowsCalculator() {
       var calculationType = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : RENDER_TYPE;
-      var wot = this.wot;
-      var wtSettings = wot.wtSettings,
-          wtOverlays = wot.wtOverlays,
-          wtTable = wot.wtTable,
-          rootDocument = wot.rootDocument;
+      var wtSettings = this.wtSettings,
+          wtTable = this.wtTable;
       var height;
       var scrollbarHeight;
       var fixedRowsHeight;
       this.rowHeaderWidth = NaN;
 
-      if (wtSettings.settings.renderAllRows && calculationType === RENDER_TYPE) {
+      if (wtSettings.getSetting('renderAllRows') && calculationType === RENDER_TYPE) {
         height = Infinity;
       } else {
         height = this.getViewportHeight();
       }
 
-      var pos = wtOverlays.topOverlay.getScrollPosition() - wtOverlays.topOverlay.getTableParentOffset();
+      var pos = this.dataAccessObject.topScrollPosition - this.dataAccessObject.topParentOffset;
 
       if (pos < 0) {
         pos = 0;
       }
 
-      var fixedRowsTop = wot.getSetting('fixedRowsTop');
-      var fixedRowsBottom = wot.getSetting('fixedRowsBottom');
-      var totalRows = wot.getSetting('totalRows');
+      var fixedRowsTop = wtSettings.getSetting('fixedRowsTop');
+      var fixedRowsBottom = wtSettings.getSetting('fixedRowsBottom');
+      var totalRows = wtSettings.getSetting('totalRows');
 
       if (fixedRowsTop) {
-        fixedRowsHeight = wtOverlays.topOverlay.sumCellSizes(0, fixedRowsTop);
+        fixedRowsHeight = this.dataAccessObject.topOverlay.sumCellSizes(0, fixedRowsTop);
         pos += fixedRowsHeight;
         height -= fixedRowsHeight;
       }
 
-      if (fixedRowsBottom && wtOverlays.bottomOverlay.clone) {
-        fixedRowsHeight = wtOverlays.bottomOverlay.sumCellSizes(totalRows - fixedRowsBottom, totalRows);
+      if (fixedRowsBottom && this.dataAccessObject.bottomOverlay.clone) {
+        fixedRowsHeight = this.dataAccessObject.bottomOverlay.sumCellSizes(totalRows - fixedRowsBottom, totalRows);
         height -= fixedRowsHeight;
       }
 
       if (wtTable.holder.clientHeight === wtTable.holder.offsetHeight) {
         scrollbarHeight = 0;
       } else {
-        scrollbarHeight = getScrollbarWidth(rootDocument);
+        scrollbarHeight = getScrollbarWidth(this.domBindings.rootDocument);
       }
 
       return new ViewportRowsCalculator({
         viewportSize: height,
         scrollOffset: pos,
-        totalItems: wot.getSetting('totalRows'),
+        totalItems: wtSettings.getSetting('totalRows'),
         itemSizeFn: function itemSizeFn(sourceRow) {
           return wtTable.getRowHeight(sourceRow);
         },
-        overrideFn: wtSettings.settings.viewportRowCalculatorOverride,
+        overrideFn: wtSettings.getSettingPure('viewportRowCalculatorOverride'),
         calculationType: calculationType,
         scrollbarHeight: scrollbarHeight
       });
@@ -381,50 +366,47 @@ var Viewport = /*#__PURE__*/function () {
      *
      * @param {number} calculationType The render type ID, which determines for what type of
      *                                 calculation calculator is created.
-     * @returns {ViewportRowsCalculator}
+     * @returns {ViewportColumnsCalculator}
      */
 
   }, {
     key: "createColumnsCalculator",
     value: function createColumnsCalculator() {
       var calculationType = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : RENDER_TYPE;
-      var wot = this.wot;
-      var wtSettings = wot.wtSettings,
-          wtOverlays = wot.wtOverlays,
-          wtTable = wot.wtTable,
-          rootDocument = wot.rootDocument;
+      var wtSettings = this.wtSettings,
+          wtTable = this.wtTable;
       var width = this.getViewportWidth();
-      var pos = wtOverlays.leftOverlay.getScrollPosition() - wtOverlays.leftOverlay.getTableParentOffset();
+      var pos = Math.abs(this.dataAccessObject.inlineStartScrollPosition) - this.dataAccessObject.inlineStartParentOffset;
       this.columnHeaderHeight = NaN;
 
       if (pos < 0) {
         pos = 0;
       }
 
-      var fixedColumnsLeft = wot.getSetting('fixedColumnsLeft');
+      var fixedColumnsStart = wtSettings.getSetting('fixedColumnsStart');
 
-      if (fixedColumnsLeft) {
-        var fixedColumnsWidth = wtOverlays.leftOverlay.sumCellSizes(0, fixedColumnsLeft);
+      if (fixedColumnsStart) {
+        var fixedColumnsWidth = this.dataAccessObject.inlineStartOverlay.sumCellSizes(0, fixedColumnsStart);
         pos += fixedColumnsWidth;
         width -= fixedColumnsWidth;
       }
 
       if (wtTable.holder.clientWidth !== wtTable.holder.offsetWidth) {
-        width -= getScrollbarWidth(rootDocument);
+        width -= getScrollbarWidth(this.domBindings.rootDocument);
       }
 
       return new ViewportColumnsCalculator({
         viewportSize: width,
-        scrollOffset: pos,
-        totalItems: wot.getSetting('totalColumns'),
+        scrollOffset: Math.abs(pos),
+        totalItems: wtSettings.getSetting('totalColumns'),
         itemSizeFn: function itemSizeFn(sourceCol) {
-          return wot.wtTable.getColumnWidth(sourceCol);
+          return wtTable.getColumnWidth(sourceCol);
         },
-        overrideFn: wtSettings.settings.viewportColumnCalculatorOverride,
+        overrideFn: wtSettings.getSettingPure('viewportColumnCalculatorOverride'),
         calculationType: calculationType,
-        stretchMode: wot.getSetting('stretchH'),
+        stretchMode: wtSettings.getSetting('stretchH'),
         stretchingItemWidthFn: function stretchingItemWidthFn(stretchedWidth, column) {
-          return wot.getSetting('onBeforeStretchingColumnWidth', stretchedWidth, column);
+          return wtSettings.getSetting('onBeforeStretchingColumnWidth', stretchedWidth, column);
         }
       });
     }
@@ -490,14 +472,19 @@ var Viewport = /*#__PURE__*/function () {
       }
 
       var startRow = proposedRowsVisibleCalculator.startRow,
-          endRow = proposedRowsVisibleCalculator.endRow;
+          endRow = proposedRowsVisibleCalculator.endRow; // if there are no fully visible rows at all, return false
+
+      if (startRow === null && endRow === null) {
+        return false;
+      }
+
       var _this$rowsRenderCalcu = this.rowsRenderCalculator,
           renderedStartRow = _this$rowsRenderCalcu.startRow,
           renderedEndRow = _this$rowsRenderCalcu.endRow;
 
       if (startRow < renderedStartRow || startRow === renderedStartRow && startRow > 0) {
         return false;
-      } else if (endRow > renderedEndRow || endRow === renderedEndRow && endRow < this.wot.getSetting('totalRows') - 1) {
+      } else if (endRow > renderedEndRow || endRow === renderedEndRow && endRow < this.wtSettings.getSetting('totalRows') - 1) {
         return false;
       }
 
@@ -520,14 +507,19 @@ var Viewport = /*#__PURE__*/function () {
       }
 
       var startColumn = proposedColumnsVisibleCalculator.startColumn,
-          endColumn = proposedColumnsVisibleCalculator.endColumn;
+          endColumn = proposedColumnsVisibleCalculator.endColumn; // if there are no fully visible columns at all, return false
+
+      if (startColumn === null && endColumn === null) {
+        return false;
+      }
+
       var _this$columnsRenderCa = this.columnsRenderCalculator,
           renderedStartColumn = _this$columnsRenderCa.startColumn,
           renderedEndColumn = _this$columnsRenderCa.endColumn;
 
       if (startColumn < renderedStartColumn || startColumn === renderedStartColumn && startColumn > 0) {
         return false;
-      } else if (endColumn > renderedEndColumn || endColumn === renderedEndColumn && endColumn < this.wot.getSetting('totalColumns') - 1) {
+      } else if (endColumn > renderedEndColumn || endColumn === renderedEndColumn && endColumn < this.wtSettings.getSetting('totalColumns') - 1) {
         return false;
       }
 

package/CHANGELOG.md

@@ -8,6 +8,98 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 <!-- UNVERSIONED -->
 
+## [12.1.0] - 2022-06-28
+
+For more information on this release, see:
+- [Release notes](https://handsontable.com/docs/release-notes/#_12-1-0)
+- [Blog post](https://handsontable.com/blog/handsontable-12.1.0-data-grid-new-hooks-new-translations-and-rendering-improvements)
+
+### Added
+- Added smoother row and column moving when some row or columns are hidden. [#7613](https://github.com/handsontable/handsontable/issues/7613)
+- Added `getNearestNotHiddenIndex()`, a new method that finds the visual index of the nearest not-hidden row or column and works even with large numbers of hidden rows or columns. The previous method, `getFirstNotHiddenIndex()`, still works, but is marked as deprecated. [#9064](https://github.com/handsontable/handsontable/issues/9064)
+- Added a Czech translation. [#9343](https://github.com/handsontable/handsontable/issues/9343)
+- Added a Serbian translation. [#9469](https://github.com/handsontable/handsontable/issues/9469)
+- Added new hooks: `beforeColumnFreeze`, `afterColumnFreeze`, `beforeColumnUnfreeze`, and `afterColumnUnfreeze`. [#9248](https://github.com/handsontable/handsontable/issues/9248)
+
+### Changed
+- Replaced HTML entities appearing in Handsontable's license texts with canonical counterparts. [#9487](https://github.com/handsontable/handsontable/issues/9487)
+- Updated the Pikaday optional dependency to 1.8.2, to let Handsontable work with Parcel 2 without errors. [#9410](https://github.com/handsontable/handsontable/issues/9410)
+- *React:* Changed the wrapper's lifecycle methods, to let Handsontable work with React 17+ without warnings. [#8748](https://github.com/handsontable/handsontable/issues/8748)
+- *Angular:* Moved the `@angular/core` dependency to peer dependencies. [#9574](https://github.com/handsontable/handsontable/issues/9574)
+
+### Fixed
+- Fixed an issue where dropdown and autocomplete cell editors rendered incorrectly if the `preventOverflow` option was set to `'horizontal'`. [#3828](https://github.com/handsontable/handsontable/issues/3828)
+- Fixed an issue where frozen rows were getting duplicated. [#4454](https://github.com/handsontable/handsontable/issues/4454)
+- Fixed an issue where comments rendered outside the viewport. [#4785](https://github.com/handsontable/handsontable/issues/4785)
+- Fixed an issue where comments got positioned incorrectly when Handsontable ran within a scrollable element. [#6744](https://github.com/handsontable/handsontable/issues/6744)
+- Fixed an issue that occurred when Handsontable ran within an HTML `<form>`: pressing <kbd>Enter</kbd> inside another form's `<input>` could open Handsontable's dropdown menu. [#9295](https://github.com/handsontable/handsontable/issues/9295)
+- Fixed an issue where it was impossible to unmerge cells in the RTL layout direction. [#9362](https://github.com/handsontable/handsontable/issues/9362)
+- Fixed an issue where columns wider than the viewport's width and rows higher than the viewport's height didn't render correctly. [#9473](https://github.com/handsontable/handsontable/issues/9473)
+- Fixed an issue where dragging-to-scroll on mobile didn't work properly in the RTL layout direction. [#9475](https://github.com/handsontable/handsontable/issues/9475)
+- Fixed an issue where hiding columns with nested headers caused incorrect column width calculation (for the `stretchH: 'all'` option). [#9496](https://github.com/handsontable/handsontable/issues/9496)
+- Fixed an issue where `ShortcutManager` unnecessarily handled `keyup` events with no `key` defined. [#9562](https://github.com/handsontable/handsontable/issues/9562)
+
+## [12.0.1] - 2022-05-16
+
+For more information on this release, see:
+- [Release notes](https://handsontable.com/docs/release-notes/#_12-0-1)
+
+### Fixed
+- Fixed an issue where checking or unchecking a checkbox in a row with `autoRowSize: true` and multi-line cell values caused rows to align incorrectly. [#7102](https://github.com/handsontable/handsontable/issues/7102)
+- Fixed an issue where checking or unchecking a checkbox changed the cell width. [#8211](https://github.com/handsontable/handsontable/issues/8211)
+- Fixed an issue where using a single Handsontable instance with multiple HyperFormula sheets could lead to an uncaught `TypeError`. [#8268](https://github.com/handsontable/handsontable/issues/8268)
+- Fixed an issue where nested column headers didn't expand properly. [#9099](https://github.com/handsontable/handsontable/issues/9099)
+- Fixed an issue where updating custom borders could lead to uncaught error exceptions. [#9455](https://github.com/handsontable/handsontable/issues/9455)
+
+## [12.0.0] - 2022-04-28
+
+For more information on this release, see:
+- [Release notes](https://handsontable.com/docs/release-notes/#_12-0-0)
+- [Blog post](https://handsontable.com/blog/articles/2022/4/handsontable-12.0.0-data-grid-rtl-support-and-a-new-keyboard-shortcuts-api)
+- [Migration guide](https://handsontable.com/docs/migration-from-11.1-to-12.0/)
+
+### Added
+- Added `ShortcutManager`, a new API for customizing keyboard shortcuts. [#8942](https://github.com/handsontable/handsontable/issues/8942)
+- Added support for right-to-left (RTL) languages, introducing a new configuration option: `layoutDirection`. [#8760](https://github.com/handsontable/handsontable/issues/8760)
+- Added an Arabic translation. [#9208](https://github.com/handsontable/handsontable/issues/9208)
+- Added a new configuration option: `fixedColumnsStart`. [#8760](https://github.com/handsontable/handsontable/issues/8760)
+- Added a new keyboard shortcut (<kbd>Ctrl</kbd>/<kbd>Cmd</kbd> + <kbd>Enter</kbd>) for filling the selected range of cells with the value of the active cell. [#9366](https://github.com/handsontable/handsontable/issues/9366)
+- Added support for the <kbd>Home</kbd> and <kbd>End</kbd> keys inside cell editors, for moving the cursor to the beginning or end of the text. [#9367](https://github.com/handsontable/handsontable/issues/9367)
+- Added support for the latest Node LTS version. [#9149](https://github.com/handsontable/handsontable/issues/9149)
+
+### Changed
+- **Breaking change**: Changed how `updateSettings()` handles data updates, to improve performance and the consistency of user experience. Now, when provided with a new data object, `updateSettings()` updates the data without resetting any states. [#7263](https://github.com/handsontable/handsontable/issues/7263)
+- **Breaking change**: Changed how `updatePlugin()` reacts to `updateSettings()` calls, to improve performance and the consistency of user experience. Now, calls to `updateSettings()` update a plugin's state only when the options object contains a configuration option that's relevant to that particular plugin. [#9021](https://github.com/handsontable/handsontable/issues/9021)
+- **Breaking change**: Changed the order of execution for two hooks: now, `beforeKeyDown` is properly fired before `afterDocumentKeyDown`. [#6236](https://github.com/handsontable/handsontable/issues/6236)
+- **Breaking change**: Changed how default keyboard shortcuts are defined, to improve keyboard navigation consistency. Most of the shortcuts did not change and are now properly documented in the [keyboard shortcuts](https://handsontable.com/docs/keyboard-shortcuts/#default-keyboard-shortcuts) guide. However, some shortcuts that were not defined explicitly, and were not listed in the documentation, don't work anymore (e.g., <kbd>Enter</kbd> opens a cell's editor, but <kbd>Ctrl</kbd> + <kbd>Enter</kbd> doesn't). This change doesn't affect custom keyboard shortcuts. [#8942](https://github.com/handsontable/handsontable/issues/8942)
+- **Breaking change**: Split a cross-platform modifier key (<kbd>Ctrl</kbd>/<kbd>Cmd</kbd>) into two separate keys, to improve keyboard navigation consistency. Now, the <kbd>Cmd</kbd> key triggers actions on macOS where the <kbd>Ctrl</kbd> key triggers actions on Windows. For example, on macOS, <kbd>Ctrl</kbd> + <kbd>A</kbd> doesn't work anymore: <kbd>Cmd</kbd> + <kbd>A</kbd> is used instead. [#9369](https://github.com/handsontable/handsontable/issues/9369)
+- **Breaking change**: Changed the actions of the following [keyboard shortcuts](https://handsontable.com/docs/keyboard-shortcuts/#default-keyboard-shortcuts), to match the usual spreadsheet software behavior, and provide a more intuitive user experience: <kbd>Ctrl</kbd>/<kbd>Cmd</kbd> + <kbd>↑</kbd>, <kbd>Ctrl</kbd>/<kbd>Cmd</kbd> + <kbd>Shift</kbd> + <kbd>↑</kbd>, <kbd>Ctrl</kbd>/<kbd>Cmd</kbd> + <kbd>↓</kbd>, <kbd>Ctrl</kbd>/<kbd>Cmd</kbd> + <kbd>Shift</kbd> + <kbd>↓</kbd>, <kbd>Ctrl</kbd>/<kbd>Cmd</kbd> + <kbd>←</kbd>, <kbd>Ctrl</kbd>/<kbd>Cmd</kbd> + <kbd>Shift</kbd> + <kbd>←</kbd>, <kbd>Ctrl</kbd>/<kbd>Cmd</kbd> + <kbd>→</kbd>, <kbd>Ctrl</kbd>/<kbd>Cmd</kbd> + <kbd>Shift</kbd> + <kbd>→</kbd>, <kbd>Home</kbd>, <kbd>Ctrl</kbd>/<kbd>Cmd</kbd> + <kbd>Home</kbd>, <kbd>End</kbd>, <kbd>Ctrl</kbd>/<kbd>Cmd</kbd> + <kbd>End</kbd>, <kbd>Shift</kbd> + <kbd>Page Up</kbd>, and <kbd>Shift</kbd> + <kbd>Page Down</kbd>. [#9363](https://github.com/handsontable/handsontable/issues/9363) [#9364](https://github.com/handsontable/handsontable/issues/9364) [#9365](https://github.com/handsontable/handsontable/issues/9365)
+- Changed two scripts of the main Handsontable workspace (`./`), to speed up the build process: now, the `npm run build` and `npm run test` scripts don't build or test the Handsontable examples (`./examples`). [#9412](https://github.com/handsontable/handsontable/issues/9412)
+- Changed the version of the Moment.js dependency from 2.24.0 to 2.29.3, in reaction to a recently-found Moment.js security vulnerability that did not directly affect Handsontable. [#9381](https://github.com/handsontable/handsontable/issues/9381)
+- Changed the version of the HyperFormula optional dependency from ^1.2.0 to ^2.0.0. [#9411](https://github.com/handsontable/handsontable/issues/9411)
+- Changed an internal property name, from `hot.view.wt` to `hot.view._wt`, where `hot` is the name of your Handsontable instance. The intention of this change is to make it clear that Walkontable (Handsontable's rendering engine) is not a part of Handsontable's public API. [#8760](https://github.com/handsontable/handsontable/issues/8760)
+
+### Fixed
+- *React, Angular, Vue 2, Vue 3:* Fixed an issue where using `updateSettings()` caused problems for state managers. [#8372](https://github.com/handsontable/handsontable/issues/8372)
+- Fixed an issue where using `updateSettings()` caused hidden columns to reappear. [#7165](https://github.com/handsontable/handsontable/issues/7165)
+- Fixed an issue where using `updateSettings()` caused merged cells to unmerge. [#3315](https://github.com/handsontable/handsontable/issues/3315)
+- Fixed an issue where using `updateSettings()` caused the state of nested rows to reset. [#8838](https://github.com/handsontable/handsontable/issues/8838)
+- Fixed an issue where using `updateSettings()` caused problems with column sorting. [#7688](https://github.com/handsontable/handsontable/issues/7688)
+- *React:* Fixed an issue where using React's `setState()` within the `afterFilter` hook broke filtering. [#7567](https://github.com/handsontable/handsontable/issues/7567)
+- *Vue 2:* Fixed an issue where repeatedly changing Handsontable's height through `updateSettings()` caused Handsontable to crash. [#7546](https://github.com/handsontable/handsontable/issues/7546)
+- *Vue 2:* Fixed an issue where the `failed` validation status got erased when editing a new row. [#7541](https://github.com/handsontable/handsontable/issues/7541)
+- Fixed an issue where cell filtering did not use formula results. [#5455](https://github.com/handsontable/handsontable/issues/5455)
+- Fixed a wrong TypeScript definition in the `BasePlugin` class. [#9175](https://github.com/handsontable/handsontable/issues/9175)
+- Fixed an issue where the <kbd>Ctrl</kbd>/<kbd>Cmd</kbd> + <kbd>Z</kbd> and <kbd>Ctrl</kbd>/<kbd>Cmd</kbd> + <kbd>Shift</kbd> + <kbd>Z</kbd> keyboard shortcuts didn't behave properly inside cell editors. [#9367](https://github.com/handsontable/handsontable/issues/9367)
+- Fixed an issue where the dropdown menu contained unwanted rectangle elements. [#9240](https://github.com/handsontable/handsontable/issues/9240)
+- *React, Vue 2, Vue 3:* Fixed an issue with registering modules for the React, Vue 2, and Vue 3 wrappers, by adding an `"exports"` field to their `package.json` files. [#9140](https://github.com/handsontable/handsontable/issues/9140)
+
+### Removed
+- **Breaking change**: Removed the <kbd>Cmd</kbd> + <kbd>M</kbd> keyboard shortcut (used for cell merging), as it conflicted with window minimizing on macOS. The <kbd>Ctrl</kbd> + <kbd>M</kbd> keyboard shortcut works the same as before. [#9368](https://github.com/handsontable/handsontable/issues/9368)
+- **Breaking change**: Removed the <kbd>Shift</kbd> + <kbd>Page Up</kbd>/<kbd>Page Down</kbd> keyboard shortcuts from the cell editing context. [#9401](https://github.com/handsontable/handsontable/issues/9401)
+- Dropped support for Internet Explorer 11 and Edge Legacy (the non-Chromium version of Edge). Handsontable 11.x becomes the long-term support (LTS) version for Internet Explorer 11 and Edge Legacy, until the end of 2023. [#7026](https://github.com/handsontable/handsontable/issues/7026)
+- *React:* Removed the `enzyme` dependency from the React wrapper. [#9151](https://github.com/handsontable/handsontable/issues/9151)
+
 ## [11.1.0] - 2022-01-13
 
 ### Added

package/LICENSE.txt

@@ -18,7 +18,7 @@ license agreement.
 In any case, you must not make any such use of this software as to develop software which may be
 considered competitive with this software.
 
-UNLESS EXPRESSLY AGREED OTHERWISE, HANDSONCODE PROVIDES THIS SOFTWARE ON AN "AS IS"
+UNLESS EXPRESSLY AGREED OTHERWISE, HANDSONCODE PROVIDES THIS SOFTWARE ON AN "AS IS"
 BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, AND IN NO EVENT AND UNDER NO
 LEGAL THEORY, SHALL HANDSONCODE BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY DIRECT,
 INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER ARISING FROM

package/README.md

@@ -9,7 +9,6 @@ It provides data binding, data validation, filtering, sorting, and CRUD operatio
 [![npm](https://img.shields.io/npm/dm/handsontable.svg)](https://npmjs.com/package/handsontable)
 [![CI status](https://github.com/handsontable/handsontable/actions/workflows/test.yml/badge.svg?branch=master)](https://github.com/handsontable/handsontable/actions/workflows/test.yml?query=branch%3Amaster)
 [![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fhandsontable%2Fhandsontable.svg?type=shield)](https://app.fossa.io/projects/git%2Bgithub.com%2Fhandsontable%2Fhandsontable?ref=badge_shield)
-[![Known Vulnerabilities](https://snyk.io/test/github/handsontable/handsontable/badge.svg?targetFile=handsontable/package.json)](https://snyk.io/test/github/handsontable/handsontable?targetFile=handsontable/package.json)
 [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=handsontable_handsontable&metric=alert_status)](https://sonarcloud.io/dashboard?id=handsontable_handsontable)
 
 ---

package/base.js

@@ -52,8 +52,8 @@ Handsontable.Core = function (rootElement) {
 Handsontable.DefaultSettings = (0, _dataMap.metaSchemaFactory)();
 Handsontable.hooks = _pluginHooks.default.getSingleton();
 Handsontable.packageName = 'handsontable';
-Handsontable.buildDate = "13/01/2022 12:29:52";
-Handsontable.version = "11.1.0";
+Handsontable.buildDate = "28/06/2022 12:07:10";
+Handsontable.version = "12.1.0";
 Handsontable.languages = {
   dictionaryKeys: _registry.dictionaryKeys,
   getLanguageDictionary: _registry.getLanguageDictionary,

package/base.mjs

@@ -37,8 +37,8 @@ Handsontable.Core = function (rootElement) {
 Handsontable.DefaultSettings = metaSchemaFactory();
 Handsontable.hooks = Hooks.getSingleton();
 Handsontable.packageName = 'handsontable';
-Handsontable.buildDate = "13/01/2022 12:30:03";
-Handsontable.version = "11.1.0";
+Handsontable.buildDate = "28/06/2022 12:07:22";
+Handsontable.version = "12.1.0";
 Handsontable.languages = {
   dictionaryKeys: dictionaryKeys,
   getLanguageDictionary: getLanguageDictionary,

package/cellTypes/timeType/timeType.d.ts

@@ -1,17 +1,17 @@
 import { CellTypeObject } from '../base';
-import { TextEditor } from '../../editors/textEditor';
-import { textRenderer } from '../../renderers/textRenderer';
+import { TimeEditor } from '../../editors/timeEditor';
+import { timeRenderer } from '../../renderers/timeRenderer';
 import { timeValidator } from '../../validators/timeValidator';
 
 export const CELL_TYPE: 'time';
 export interface TimeCellType extends CellTypeObject {
-  editor: typeof TextEditor;
-  renderer: typeof textRenderer;
+  editor: typeof TimeEditor;
+  renderer: typeof timeRenderer;
   validator: typeof timeValidator;
 }
 
 export namespace TimeCellType {
-  export { TextEditor as editor };
-  export { textRenderer as renderer };
+  export { TimeEditor as editor };
+  export { timeRenderer as renderer };
   export { timeValidator as validator };
 }

package/cellTypes/timeType/timeType.js

@@ -3,9 +3,9 @@
 exports.__esModule = true;
 exports.TimeCellType = exports.CELL_TYPE = void 0;
 
-var _textEditor = require("../../editors/textEditor");
+var _timeEditor = require("../../editors/timeEditor");
 
-var _textRenderer = require("../../renderers/textRenderer");
+var _timeRenderer = require("../../renderers/timeRenderer");
 
 var _timeValidator = require("../../validators/timeValidator");
 
@@ -13,9 +13,8 @@ var CELL_TYPE = 'time';
 exports.CELL_TYPE = CELL_TYPE;
 var TimeCellType = {
   CELL_TYPE: CELL_TYPE,
-  editor: _textEditor.TextEditor,
-  // displays small gray arrow on right side of the cell
-  renderer: _textRenderer.textRenderer,
+  editor: _timeEditor.TimeEditor,
+  renderer: _timeRenderer.timeRenderer,
   validator: _timeValidator.timeValidator
 };
 exports.TimeCellType = TimeCellType;