handsontable 14.3.0-next-dda3c4b-20240415 → 14.4.0-next-f62dd73-20240521

package/CHANGELOG.md

@@ -9,25 +9,69 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 <!-- UNVERSIONED -->
 
+## [14.4.0] - 2024-05-28
+
+### Added
+- Improved UX for column filtering [#10454](https://github.com/handsontable/handsontable/issues/10454)
+- Extended the `manualRowResize` plugin with a method that retrieves the row height value from the last attempt at manually changing said row height. [#10941](https://github.com/handsontable/handsontable/pull/10941)
+- Added an option to place the hook callbacks in a different order. [#10970](https://github.com/handsontable/handsontable/pull/10970)
+- Add new `dataDotNotation` option which, when set as `false` allows using object keys with dots. [#10973](https://github.com/handsontable/handsontable/pull/10973)
+
+### Changed
+- Improved editor's behavior after dataset altering [#10963](https://github.com/handsontable/handsontable/pull/10963)
+- React: Synchronized the `rollup` version between the wrappers and updated the `rollup` plugin dependencies.  [#10962](https://github.com/handsontable/handsontable/pull/10962)
+
+### Fixed
+- Fixed unwanted table re-rerender for oversized rows/columns. [#10912](https://github.com/handsontable/handsontable/pull/10912)
+- Fixed `Ctrl/Cmd` + `Enter` keyboard shortcut for comments [#10920](https://github.com/handsontable/handsontable/pull/10920)
+- Fixed rows and columns unfreeze issue when headers are disabled [#10926](https://github.com/handsontable/handsontable/pull/10926)
+- Fixed `imeFastEdit` option being reset after `updateSettings` call [#10933](https://github.com/handsontable/handsontable/pull/10933)
+- Added horizontal scroll to the Filter's "by value" component [#10940](https://github.com/handsontable/handsontable/pull/10940)
+- Improved fast typing values between editors [#10947](https://github.com/handsontable/handsontable/pull/10947)
+- Removed double borders for column headers [#10948](https://github.com/handsontable/handsontable/pull/10948)
+- Fixed column widths calculations when `stretchH: 'all'` option was used. [#10954](https://github.com/handsontable/handsontable/pull/10954)
+- Fixed columns summary cell meta missing state after calling the `updateSettings` method. [#10955](https://github.com/handsontable/handsontable/pull/10955)
+- Fixed sorting of the time of the `time` column types [#10956](https://github.com/handsontable/handsontable/pull/10956)
+- Fixed data populate error when `correctFormat` was used [#10957](https://github.com/handsontable/handsontable/pull/10957)
+- Fixed cell meta coordinates overwrite by _GhostTable_ [#10961](https://github.com/handsontable/handsontable/pull/10961)
+- Fixed a problem where `setDataAtRowProp` threw an error when trying to save data into a trimmed-out column. [#10964](https://github.com/handsontable/handsontable/pull/10964)
+- Fixed a problem where the table scrolled all the way right after inserting a new row over a table-wide selection. [#10965](https://github.com/handsontable/handsontable/pull/10965)
+- Fixed a bug that prevents copy/cut/paste from outside elements [#10976](https://github.com/handsontable/handsontable/pull/10976)
+- Fixed a problem where the autocomplete dropdown was not displayed with the right dimensions after previously filtering out all the choices. [#10977](https://github.com/handsontable/handsontable/pull/10977)
+- Fixed a bug related to not clearing the dataset correctly for formulas [#10983](https://github.com/handsontable/handsontable/pull/10983)
+- Improved typings for the ContextMenu plugin. [#10984](https://github.com/handsontable/handsontable/pull/10984)
+- Added missing type for `namedExpressions` [#10986](https://github.com/handsontable/handsontable/pull/10986)
+- Fixed double borders for row/column headers [#10988](https://github.com/handsontable/handsontable/pull/10988)
+- Fixed a problem, where trying to render a hidden instance made it render all of its rows by disabling the rendering for hidden instances. [#10989](https://github.com/handsontable/handsontable/pull/10989)
+- Fixed an error in numeric cell types that occur after entering non-numeric values. [#10931](https://github.com/handsontable/handsontable/pull/10931)
+- React: Prevented the react wrapper from throwing errors on updating component props when the component had any init-only settings pre-declared. [#10921](https://github.com/handsontable/handsontable/pull/10921)
+
 ## [14.3.0] - 2024-04-16
 
 ### Added
-- Added new feature which is navigation and edit cells within a range [#10732](https://github.com/handsontable/handsontable/pull/10732)
+- Added new feature, Navigation within selection and edit cells within a range [#10732](https://github.com/handsontable/handsontable/pull/10732)
 
 ### Changed
-- Stopped using `dtslint` in favor of `@typescript-eslint/eslint-plugin`. [#10841](https://github.com/handsontable/handsontable/pull/10841)
-- Made the cursor turn to `grabbing` for all the elements in the table while moving the columns or rows. [#10852](https://github.com/handsontable/handsontable/pull/10852)
+- Updated dependencies based on npm audit, most notably we upgraded to angular 17.0 [#10889](https://github.com/handsontable/handsontable/pull/10889)
 
 ### Fixed
-- Fixed a problem, where `TAB` would not move the selection when the select-typed cell was being edited in the "fast edit" mode. [#10849](https://github.com/handsontable/handsontable/pull/10849)
-- Blocked the `Cmd/Ctrl + A` action for situations where the focus is placed on the headers. [#10853](https://github.com/handsontable/handsontable/pull/10853)
-- Unified the `source` arguments of the `beforeChange`/`afterChange` hooks when being triggered by the Merge Cells plugin. [#10857](https://github.com/handsontable/handsontable/pull/10857)
-- Maintain focus after column collapsing. [#10865](https://github.com/handsontable/handsontable/pull/10865)
-- Fixed a problem where the bottom/right cell borders were not visible in the viewport after scrolling from the absolute top/left positions of the table using the API. [#10887](https://github.com/handsontable/handsontable/pull/10887)
-- Fixed Dropdown plugin logic that in some cases could block click events coming from custom editors. [#10888](https://github.com/handsontable/handsontable/pull/10888)
-- Fixed datepicker position of the date cell type. [#10892](https://github.com/handsontable/handsontable/pull/10892)
-- Vue: Fixed a problem where updating the hook callback in the Vue and Vue3 wrappers did not update the underlying instance's settings. [#10686](https://github.com/handsontable/handsontable/issues/10686)
-- Vue: Fixed a problem where the Vue/Vue3 wrappers' `simpleEqual` helper return incorrect result when comparing identical objects. [#10896](https://github.com/handsontable/handsontable/pull/10896)
+
+- Ensured the cursor changes to 'grabbing' for all table elements during column or row movement[#10852](https://github.com/handsontable/handsontable/pull/10852)
+- Resolved an issue where the `TAB` key failed to move selection when editing select-type cells in 'fast edit' mode. [#10849](https://github.com/handsontable/handsontable/pull/10849)
+- Prevent the `Cmd/Ctrl + A` action when the focus is on headers. [#10853](https://github.com/handsontable/handsontable/pull/10853)
+- Unified `source` arguments in `beforeChange` and `afterChange` hooks triggered by the Merge Cells plugin. [#10857](https://github.com/handsontable/handsontable/pull/10857)
+- Ensured focus retention after column collapsing. [#10865](https://github.com/handsontable/handsontable/pull/10865)
+- Fixed visibility issue with bottom/right cell borders after scrolling from the absolute top/left positions using the api. [#10887](https://github.com/handsontable/handsontable/pull/10887)
+- Fixed Dropdown plugin logic to prevent blocking click events from custom editors. [#10888](https://github.com/handsontable/handsontable/pull/10888)
+- Fixed datepicker position for the date cell type. [#10892](https://github.com/handsontable/handsontable/pull/10892)
+- Vue: Fixed an issue in the Vue and Vue3 wrappers where updating the hook callback didn't reflect changes in the underlying instance's settings. [#10686](https://github.com/handsontable/handsontable/issues/10686)
+- Vue: Fixed the behavior of the Vue/Vue3 wrappers' `simpleEqual` helper, which previously returned incorrect results when comparing identical objects. [#10896](https://github.com/handsontable/handsontable/pull/10896)
+
+For more information on Handsontable 14.3.0, see:
+
+- [Blog post (14.3.0)](https://handsontable.com/blog/handsontable-14.3.0-enhanced-navigation-and-bug-fixes)
+- [Documentation (14.3)](https://handsontable.com/docs/14.3)
+- [Release notes (14.3.0)](https://handsontable.com/docs/release-notes/#_14-3-0)
 
 ## [14.2.0] - 2024-03-06
 

package/base.js

@@ -45,8 +45,8 @@ Handsontable.hooks = _pluginHooks.default.getSingleton();
 Handsontable.CellCoords = _src.CellCoords;
 Handsontable.CellRange = _src.CellRange;
 Handsontable.packageName = 'handsontable';
-Handsontable.buildDate = "15/04/2024 20:43:14";
-Handsontable.version = "14.3.0-next-dda3c4b-20240415";
+Handsontable.buildDate = "21/05/2024 10:09:58";
+Handsontable.version = "14.4.0-next-f62dd73-20240521";
 Handsontable.languages = {
   dictionaryKeys: _registry.dictionaryKeys,
   getLanguageDictionary: _registry.getLanguageDictionary,

package/base.mjs

@@ -35,8 +35,8 @@ Handsontable.hooks = Hooks.getSingleton();
 Handsontable.CellCoords = CellCoords;
 Handsontable.CellRange = CellRange;
 Handsontable.packageName = 'handsontable';
-Handsontable.buildDate = "15/04/2024 20:43:20";
-Handsontable.version = "14.3.0-next-dda3c4b-20240415";
+Handsontable.buildDate = "21/05/2024 10:10:04";
+Handsontable.version = "14.4.0-next-f62dd73-20240521";
 Handsontable.languages = {
   dictionaryKeys,
   getLanguageDictionary,

package/core.d.ts

@@ -25,8 +25,8 @@ type AlterActions = 'insert_row_above' | 'insert_row_below' |
                     'remove_row' | 'remove_col';
 
 export default class Core {
-  addHook<K extends keyof Events>(key: K, callback: Events[K] | Array<Events[K]>): void;
-  addHookOnce<K extends keyof Events>(key: K, callback: Events[K] | Array<Events[K]>): void;
+  addHook<K extends keyof Events>(key: K, callback: Events[K] | Array<Events[K]>, orderIndex?: number): void;
+  addHookOnce<K extends keyof Events>(key: K, callback: Events[K] | Array<Events[K]>, orderIndex?: number): void;
   alter(action: AlterActions, index?: number | Array<[number, number]>, amount?: number, source?: string, keepEmptyRows?: boolean): void;
   batch<R>(wrappedOperations: () => R): R;
   batchExecution<R>(wrappedOperations: () => R, forceFlushChanges: boolean): R;

package/core.js

@@ -4,6 +4,13 @@ exports.__esModule = true;
 exports.default = Core;
 require("core-js/modules/es.error.cause.js");
 require("core-js/modules/es.array.push.js");
+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");
 require("core-js/modules/web.immediate.js");
 var _element = require("./helpers/dom/element");
 var _function = require("./helpers/function");
@@ -330,7 +337,7 @@ function Core(rootElement, userSettings) {
       hiddenIndexesChanged
     } = _ref;
     if (hiddenIndexesChanged) {
-      this.selection.refresh();
+      this.selection.commit();
     }
   };
   this.columnIndexMapper.addLocalHook('cacheUpdated', onIndexMapperCacheUpdate);
@@ -365,7 +372,11 @@ function Core(rootElement, userSettings) {
     } else {
       (0, _element.removeClass)(this.rootElement, ['ht__selection--rows', 'ht__selection--columns']);
     }
-    this._refreshBorders(null);
+    if (selection.getSelectionSource() !== 'shift') {
+      editorManager.closeEditor(null);
+    }
+    instance.view.render();
+    editorManager.prepareEditor();
   });
   this.selection.addLocalHook('beforeSetFocus', cellCoords => {
     this.runHooks('beforeSelectionFocusSet', cellCoords.row, cellCoords.col);
@@ -376,7 +387,9 @@ function Core(rootElement, userSettings) {
     if (!preventScrolling.isTouched() || preventScrolling.isTouched() && !preventScrolling.value) {
       viewportScroller.scrollTo(cellCoords);
     }
-    this._refreshBorders(null);
+    editorManager.closeEditor();
+    instance.view.render();
+    editorManager.prepareEditor();
   });
   this.selection.addLocalHook('afterSelectionFinished', cellRanges => {
     const selectionLayerLevel = cellRanges.length - 1;
@@ -394,8 +407,8 @@ function Core(rootElement, userSettings) {
     }
   });
   this.selection.addLocalHook('afterDeselect', () => {
-    editorManager.destroyEditor();
-    this._refreshBorders();
+    editorManager.closeEditor();
+    instance.view.render();
     (0, _element.removeClass)(this.rootElement, ['ht__selection--rows', 'ht__selection--columns']);
     this.runHooks('afterDeselect');
   });
@@ -550,39 +563,7 @@ function Core(rootElement, userSettings) {
             source,
             mode: insertRowMode
           });
-          if (rowDelta) {
-            const currentSelectedRange = selection.selectedRange.current();
-            const currentFromRange = currentSelectedRange === null || currentSelectedRange === void 0 ? void 0 : currentSelectedRange.from;
-            const currentFromRow = currentFromRange === null || currentFromRange === void 0 ? void 0 : currentFromRange.row;
-            const startVisualRowIndex = instance.toVisualRow(startRowPhysicalIndex);
-            if (selection.isSelectedByCorner()) {
-              selection.selectAll(true, true, {
-                disableHeadersHighlight: true
-              });
-            } else if ((0, _mixed.isDefined)(currentFromRow) && currentFromRow >= startVisualRowIndex) {
-              // Moving the selection (if it exists) downward – it should be applied to the "old" row.
-              // TODO: The logic here should be handled by selection module.
-              const {
-                row: currentToRow,
-                col: currentToColumn
-              } = currentSelectedRange.to;
-              let currentFromColumn = currentFromRange.col;
-
-              // Workaround: headers are not stored inside selection.
-              if (selection.isSelectedByRowHeader()) {
-                currentFromColumn = -1;
-              }
-
-              // Remove from the stack the last added selection as that selection below will be
-              // replaced by new transformed selection.
-              selection.getSelectedRange().pop();
-              // I can't use transforms as they don't work in negative indexes.
-              selection.setRangeStartOnly(instance._createCellCoords(currentFromRow + rowDelta, currentFromColumn), true);
-              selection.setRangeEnd(instance._createCellCoords(currentToRow + rowDelta, currentToColumn)); // will call render() internally
-            } else {
-              instance._refreshBorders(); // it will call render and prepare methods
-            }
-          }
+          selection.shiftRows(instance.toVisualRow(startRowPhysicalIndex), rowDelta);
           break;
         case 'insert_col_start':
         case 'insert_col_end':
@@ -605,38 +586,7 @@ function Core(rootElement, userSettings) {
               spliceArray.length += colDelta; // inserts empty (undefined) elements at the end of an array
               Array.prototype.splice.apply(tableMeta.colHeaders, spliceArray); // inserts empty (undefined) elements into the colHeader array
             }
-            const currentSelectedRange = selection.selectedRange.current();
-            const currentFromRange = currentSelectedRange === null || currentSelectedRange === void 0 ? void 0 : currentSelectedRange.from;
-            const currentFromColumn = currentFromRange === null || currentFromRange === void 0 ? void 0 : currentFromRange.col;
-            const startVisualColumnIndex = instance.toVisualColumn(startColumnPhysicalIndex);
-            if (selection.isSelectedByCorner()) {
-              selection.selectAll(true, true, {
-                disableHeadersHighlight: true
-              });
-            } else if ((0, _mixed.isDefined)(currentFromColumn) && currentFromColumn >= startVisualColumnIndex) {
-              // Moving the selection (if it exists) rightward – it should be applied to the "old" column.
-              // TODO: The logic here should be handled by selection module.
-              const {
-                row: currentToRow,
-                col: currentToColumn
-              } = currentSelectedRange.to;
-              let currentFromRow = currentFromRange.row;
-
-              // Workaround: headers are not stored inside selection.
-              if (selection.isSelectedByColumnHeader()) {
-                currentFromRow = -1;
-              }
-
-              // Remove from the stack the last added selection as that selection below will be
-              // replaced by new transformed selection.
-              selection.getSelectedRange().pop();
-
-              // I can't use transforms as they don't work in negative indexes.
-              selection.setRangeStartOnly(instance._createCellCoords(currentFromRow, currentFromColumn + colDelta), true);
-              selection.setRangeEnd(instance._createCellCoords(currentToRow, currentToColumn + colDelta)); // will call render() internally
-            } else {
-              instance._refreshBorders(); // it will call render and prepare methods
-            }
+            selection.shiftColumns(instance.toVisualColumn(startColumnPhysicalIndex), colDelta);
           }
           break;
         case 'remove_row':
@@ -661,7 +611,22 @@ function Core(rootElement, userSettings) {
               if (!wasRemoved) {
                 return;
               }
+              if (selection.isSelected()) {
+                const {
+                  row
+                } = instance.getSelectedRangeLast().highlight;
+                if (row >= groupIndex && row <= groupIndex + groupAmount - 1) {
+                  editorManager.closeEditor(true);
+                }
+              }
               const totalRows = instance.countRows();
+              if (totalRows === 0) {
+                selection.deselect();
+              } else if (source === 'ContextMenu.removeRow') {
+                selection.refresh();
+              } else {
+                selection.shiftRows(groupIndex, -groupAmount);
+              }
               const fixedRowsTop = tableMeta.fixedRowsTop;
               if (fixedRowsTop >= calcIndex + 1) {
                 tableMeta.fixedRowsTop -= Math.min(groupAmount, fixedRowsTop - calcIndex);
@@ -678,8 +643,6 @@ function Core(rootElement, userSettings) {
           } else {
             removeRow([[index, amount]]);
           }
-          grid.adjustRowsAndCols();
-          instance._refreshBorders(); // it will call render and prepare methods
           break;
         case 'remove_col':
           const removeCol = indexes => {
@@ -704,6 +667,22 @@ function Core(rootElement, userSettings) {
               if (!wasRemoved) {
                 return;
               }
+              if (selection.isSelected()) {
+                const {
+                  col
+                } = instance.getSelectedRangeLast().highlight;
+                if (col >= groupIndex && col <= groupIndex + groupAmount - 1) {
+                  editorManager.closeEditor(true);
+                }
+              }
+              const totalColumns = instance.countCols();
+              if (totalColumns === 0) {
+                selection.deselect();
+              } else if (source === 'ContextMenu.removeColumn') {
+                selection.refresh();
+              } else {
+                selection.shiftColumns(groupIndex, -groupAmount);
+              }
               const fixedColumnsStart = tableMeta.fixedColumnsStart;
               if (fixedColumnsStart >= calcIndex + 1) {
                 tableMeta.fixedColumnsStart -= Math.min(groupAmount, fixedColumnsStart - calcIndex);
@@ -722,13 +701,11 @@ function Core(rootElement, userSettings) {
           } else {
             removeCol([[index, amount]]);
           }
-          grid.adjustRowsAndCols();
-          instance._refreshBorders(); // it will call render and prepare methods
-
           break;
         default:
           throw new Error(`There is no such action "${action}"`);
       }
+      instance.view.render();
       if (!keepEmptyRows) {
         grid.adjustRowsAndCols(); // makes sure that we did not add rows that will be removed in next refresh
       }
@@ -743,9 +720,6 @@ function Core(rootElement, userSettings) {
       const minSpareRows = tableMeta.minSpareRows;
       const minCols = tableMeta.minCols;
       const minSpareCols = tableMeta.minSpareCols;
-      if (instance.countRows() === 0 && instance.countCols() === 0) {
-        selection.deselect();
-      }
       if (minRows) {
         // should I add empty rows to data source to meet minRows?
         const nrOfRows = instance.countRows();
@@ -804,55 +778,6 @@ function Core(rootElement, userSettings) {
           });
         }
       }
-      if (selection.isSelected()) {
-        const rowCount = instance.countRows();
-        const colCount = instance.countCols();
-        (0, _array.arrayEach)(selection.selectedRange, range => {
-          let selectionChanged = false;
-          let fromRow = range.from.row;
-          let fromCol = range.from.col;
-          let toRow = range.to.row;
-          let toCol = range.to.col;
-
-          // if selection is outside, move selection to last row
-          if (fromRow > rowCount - 1) {
-            fromRow = rowCount - 1;
-            selectionChanged = true;
-            if (toRow > fromRow) {
-              toRow = fromRow;
-            }
-          } else if (toRow > rowCount - 1) {
-            toRow = rowCount - 1;
-            selectionChanged = true;
-            if (fromRow > toRow) {
-              fromRow = toRow;
-            }
-          }
-          // if selection is outside, move selection to last row
-          if (fromCol > colCount - 1) {
-            fromCol = colCount - 1;
-            selectionChanged = true;
-            if (toCol > fromCol) {
-              toCol = fromCol;
-            }
-          } else if (toCol > colCount - 1) {
-            toCol = colCount - 1;
-            selectionChanged = true;
-            if (fromCol > toCol) {
-              fromCol = toCol;
-            }
-          }
-          if (selectionChanged) {
-            if (fromCol < 0) {
-              instance.selectRows(fromRow, toRow, fromCol);
-            } else if (fromRow < 0) {
-              instance.selectColumns(fromCol, toCol, fromRow);
-            } else {
-              instance.selectCell(fromRow, fromCol, toRow, toCol);
-            }
-          }
-        });
-      }
       if (instance.view) {
         instance.view.adjustElementsSize();
       }
@@ -1197,8 +1122,18 @@ function Core(rootElement, userSettings) {
     };
     for (let i = changes.length - 1; i >= 0; i--) {
       const [row, prop,, newValue] = changes[i];
-      const col = datamap.propToCol(prop);
-      const cellProperties = instance.getCellMeta(row, col);
+      const visualCol = datamap.propToCol(prop);
+      let cellProperties;
+      if (Number.isInteger(visualCol)) {
+        cellProperties = instance.getCellMeta(row, visualCol);
+      } else {
+        // If there's no requested visual column, we can use the table meta as the cell properties when retrieving
+        // the cell validator.
+        cellProperties = {
+          ...Object.getPrototypeOf(tableMeta),
+          ...tableMeta
+        };
+      }
       if (cellProperties.type === 'numeric' && typeof newValue === 'string' && (0, _number.isNumericLike)(newValue)) {
         changes[i][3] = getParsedNumber(newValue);
       }
@@ -1289,9 +1224,9 @@ function Core(rootElement, userSettings) {
     instance.forceFullRender = true; // used when data was changed
     grid.adjustRowsAndCols();
     instance.runHooks('beforeChangeRender', changes, source);
-    editorManager.lockEditor();
-    instance._refreshBorders(null);
-    editorManager.unlockEditor();
+    editorManager.closeEditor();
+    instance.view.render();
+    editorManager.prepareEditor();
     instance.view.adjustElementsSize();
     instance.runHooks('afterChange', changes, source || 'edit');
     const activeEditor = instance.getActiveEditor();
@@ -1502,6 +1437,9 @@ function Core(rootElement, userSettings) {
     for (i = 0, ilen = input.length; i < ilen; i++) {
       changes.push([input[i][0], input[i][1], dataSource.getAtCell(this.toPhysicalRow(input[i][0]), input[i][1]), input[i][2]]);
     }
+
+    // TODO: I don't think `prop` should be used as `changeSource` here, but removing it would be a breaking change.
+    // We should remove it with the next major release.
     if (!changeSource && typeof row === 'object') {
       changeSource = prop;
     }
@@ -1568,7 +1506,11 @@ function Core(rootElement, userSettings) {
   this.destroyEditor = function () {
     let revertOriginal = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
     let prepareEditorIfNeeded = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-    instance._refreshBorders(revertOriginal, prepareEditorIfNeeded);
+    editorManager.closeEditor(revertOriginal);
+    instance.view.render();
+    if (prepareEditorIfNeeded && selection.isSelected()) {
+      editorManager.prepareEditor();
+    }
   };
 
   /**
@@ -1831,7 +1773,7 @@ function Core(rootElement, userSettings) {
       if (this.renderCall) {
         this.render();
       } else {
-        this._refreshBorders(null);
+        instance.view.render();
       }
     }
   };
@@ -1852,9 +1794,7 @@ function Core(rootElement, userSettings) {
       this.forceFullRender = true; // used when data was changed
 
       if (!this.isRenderSuspended()) {
-        editorManager.lockEditor();
-        this._refreshBorders(null);
-        editorManager.unlockEditor();
+        instance.view.render();
       }
     }
   };
@@ -2121,6 +2061,7 @@ function Core(rootElement, userSettings) {
       instance.columnIndexMapper.fitToLength(this.getInitialColumnCount());
       instance.rowIndexMapper.fitToLength(this.countSourceRows());
       grid.adjustRowsAndCols();
+      selection.refresh();
     }, {
       hotInstance: instance,
       dataMap: datamap,
@@ -2161,6 +2102,7 @@ function Core(rootElement, userSettings) {
       metaManager.clearCellsCache();
       instance.initIndexMappers();
       grid.adjustRowsAndCols();
+      selection.refresh();
       if (firstRun) {
         firstRun = [null, 'loadData'];
       }
@@ -2448,10 +2390,8 @@ function Core(rootElement, userSettings) {
     grid.adjustRowsAndCols();
     if (instance.view && !firstRun) {
       instance.forceFullRender = true; // used when data was changed
-      editorManager.lockEditor();
-      instance._refreshBorders(null);
+      instance.view.render();
       instance.view._wt.wtOverlays.adjustElementsSize();
-      editorManager.unlockEditor();
     }
     if (!init && instance.view && (currentHeight === '' || height === '' || height === undefined) && currentHeight !== height) {
       instance.view._wt.wtOverlays.updateMainScrollableElements();
@@ -2603,7 +2543,7 @@ function Core(rootElement, userSettings) {
       }
       renderableRowIndex = this.rowIndexMapper.getRenderableFromVisualIndex(row);
     }
-    if (renderableRowIndex === null || renderableColumnIndex === null) {
+    if (renderableRowIndex === null || renderableColumnIndex === null || renderableRowIndex === undefined || renderableColumnIndex === undefined) {
       return null;
     }
     return instance.view.getCellAtCoords(instance._createCellCoords(renderableRowIndex, renderableColumnIndex), topmost);
@@ -4349,13 +4289,17 @@ function Core(rootElement, userSettings) {
    * @see Hooks#add
    * @param {string} key Hook name (see {@link Hooks}).
    * @param {Function|Array} callback Function or array of functions.
+   * @param {number} [orderIndex] Order index of the callback.
+   *                              If > 0, the callback will be added after the others, for example, with an index of 1, the callback will be added before the ones with an index of 2, 3, etc., but after the ones with an index of 0 and lower.
+   *                              If < 0, the callback will be added before the others, for example, with an index of -1, the callback will be added after the ones with an index of -2, -3, etc., but before the ones with an index of 0 and higher.
+   *                              If 0 or no order index is provided, the callback will be added between the "negative" and "positive" indexes.
    * @example
    * ```js
    * hot.addHook('beforeInit', myCallback);
    * ```
    */
-  this.addHook = function (key, callback) {
-    _pluginHooks.default.getSingleton().add(key, callback, instance);
+  this.addHook = function (key, callback, orderIndex) {
+    _pluginHooks.default.getSingleton().add(key, callback, instance, orderIndex);
   };
 
   /**
@@ -4386,13 +4330,17 @@ function Core(rootElement, userSettings) {
    * @see Hooks#once
    * @param {string} key Hook name (see {@link Hooks}).
    * @param {Function|Array} callback Function or array of functions.
+   * @param {number} [orderIndex] Order index of the callback.
+   *                              If > 0, the callback will be added after the others, for example, with an index of 1, the callback will be added before the ones with an index of 2, 3, etc., but after the ones with an index of 0 and lower.
+   *                              If < 0, the callback will be added before the others, for example, with an index of -1, the callback will be added after the ones with an index of -2, -3, etc., but before the ones with an index of 0 and higher.
+   *                              If 0 or no order index is provided, the callback will be added between the "negative" and "positive" indexes.
    * @example
    * ```js
    * hot.addHookOnce('beforeInit', myCallback);
    * ```
    */
-  this.addHookOnce = function (key, callback) {
-    _pluginHooks.default.getSingleton().once(key, callback, instance);
+  this.addHookOnce = function (key, callback, orderIndex) {
+    _pluginHooks.default.getSingleton().once(key, callback, instance, orderIndex);
   };
 
   /**
@@ -4529,23 +4477,6 @@ function Core(rootElement, userSettings) {
     });
   };
 
-  /**
-   * Refresh selection borders. This is temporary method relic after selection rewrite.
-   *
-   * @private
-   * @param {boolean} [revertOriginal=false] If `true`, the previous value will be restored. Otherwise, the edited value will be saved.
-   * @param {boolean} [prepareEditorIfNeeded=true] If `true` the editor under the selected cell will be prepared to open.
-   */
-  this._refreshBorders = function () {
-    let revertOriginal = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-    let prepareEditorIfNeeded = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-    editorManager.destroyEditor(revertOriginal);
-    instance.view.render();
-    if (prepareEditorIfNeeded && selection.isSelected()) {
-      editorManager.prepareEditor();
-    }
-  };
-
   /**
    * Gets the instance of the EditorManager.
    *