handsontable 12.3.3 → 12.4.0-next-acb5d99-20230512

package/plugins/formulas/formulas.mjs

@@ -2,8 +2,6 @@ function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableTo
 function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
 function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
 function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
 function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
 function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
@@ -19,6 +17,8 @@ import "core-js/modules/es.set.js";
 import "core-js/modules/es.string.iterator.js";
 import "core-js/modules/web.dom-collections.iterator.js";
 import "core-js/modules/es.array.map.js";
+import "core-js/modules/es.string.starts-with.js";
+import "core-js/modules/es.array.slice.js";
 import "core-js/modules/es.array.includes.js";
 import "core-js/modules/es.string.includes.js";
 import "core-js/modules/es.array.reverse.js";
@@ -35,13 +35,9 @@ import "core-js/modules/es.reflect.construct.js";
 import "core-js/modules/es.reflect.get.js";
 import "core-js/modules/es.object.get-own-property-descriptor.js";
 import "core-js/modules/es.symbol.iterator.js";
-import "core-js/modules/es.array.slice.js";
 import "core-js/modules/es.function.name.js";
 import "core-js/modules/es.array.from.js";
 import "core-js/modules/es.regexp.exec.js";
-import "core-js/modules/es.object.keys.js";
-import "core-js/modules/es.array.filter.js";
-import "core-js/modules/es.object.get-own-property-descriptors.js";
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
 function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
@@ -70,14 +66,15 @@ import { error, warn } from "../../helpers/console.mjs";
 import { isNumeric } from "../../helpers/number.mjs";
 import { isDefined, isUndefined } from "../../helpers/mixed.mjs";
 import { setupEngine, setupSheet, unregisterEngine, getRegisteredHotInstances } from "./engine/register.mjs";
-import { isEscapedFormulaExpression, unescapeFormulaExpression } from "./utils.mjs";
-import { getEngineSettingsWithOverrides } from "./engine/settings.mjs";
+import { isEscapedFormulaExpression, unescapeFormulaExpression, isDate, isDateValid, getDateInHfFormat, getDateFromExcelDate, getDateInHotFormat, isFormula } from "./utils.mjs";
+import { getEngineSettingsWithOverrides, haveEngineSettingsChanged } from "./engine/settings.mjs";
 import { isArrayOfArrays } from "../../helpers/data.mjs";
 import { toUpperCaseFirst } from "../../helpers/string.mjs";
 import Hooks from "../../pluginHooks.mjs";
+import IndexSyncer from "./indexSyncer/index.mjs";
 export var PLUGIN_KEY = 'formulas';
+export var SETTING_KEYS = ['maxRows', 'maxColumns', 'language'];
 export var PLUGIN_PRIORITY = 260;
-var ROW_MOVE_UNDO_REDO_NAME = 'row_move';
 Hooks.getSingleton().register('afterNamedExpressionAdded');
 Hooks.getSingleton().register('afterNamedExpressionRemoved');
 Hooks.getSingleton().register('afterSheetAdded');
@@ -116,14 +113,31 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
       _args[_key] = arguments[_key];
     }
     _this = _super.call.apply(_super, [this].concat(_args));
+    /**
+     * Flag used to bypass hooks in internal operations.
+     *
+     * @private
+     * @type {boolean}
+     */
     _classPrivateFieldInitSpec(_assertThisInitialized(_this), _internalOperationPending, {
       writable: true,
       value: false
     });
+    /**
+     * Flag needed to mark if Handsontable was initialized with no data.
+     * (Required to work around the fact, that Handsontable auto-generates sample data, when no data is provided).
+     *
+     * @type {boolean}
+     */
     _classPrivateFieldInitSpec(_assertThisInitialized(_this), _hotWasInitializedWithEmptyData, {
       writable: true,
       value: false
     });
+    /**
+     * The list of the HyperFormula listeners.
+     *
+     * @type {Array}
+     */
     _classPrivateFieldInitSpec(_assertThisInitialized(_this), _engineListeners, {
       writable: true,
       value: [['valuesUpdated', function () {
@@ -146,9 +160,44 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
         return (_this7 = _this).onEngineSheetRemoved.apply(_this7, arguments);
       }]]
     });
+    /**
+     * Static register used to set up one global HyperFormula instance.
+     * TODO: currently used in tests, might be removed later.
+     *
+     * @private
+     * @type {object}
+     */
     _defineProperty(_assertThisInitialized(_this), "staticRegister", staticRegister('formulas'));
+    /**
+     * The engine instance that will be used for this instance of Handsontable.
+     *
+     * @type {HyperFormula|null}
+     */
     _defineProperty(_assertThisInitialized(_this), "engine", null);
+    /**
+     * HyperFormula's sheet name.
+     *
+     * @type {string|null}
+     */
     _defineProperty(_assertThisInitialized(_this), "sheetName", null);
+    /**
+     * Index synchronizer responsible for manipulating with some general options related to indexes synchronization.
+     *
+     * @type {IndexSyncer|null}
+     */
+    _defineProperty(_assertThisInitialized(_this), "indexSyncer", null);
+    /**
+     * Index synchronizer responsible for syncing the order of HOT and HF's data for the axis of the rows.
+     *
+     * @type {AxisSyncer|null}
+     */
+    _defineProperty(_assertThisInitialized(_this), "rowAxisSyncer", null);
+    /**
+     * Index synchronizer responsible for syncing the order of HOT and HF's data for the axis of the columns.
+     *
+     * @type {AxisSyncer|null}
+     */
+    _defineProperty(_assertThisInitialized(_this), "columnAxisSyncer", null);
     return _this;
   }
   _createClass(Formulas, [{
@@ -256,24 +305,66 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
       this.addHook('afterRemoveCol', function () {
         return _this8.onAfterRemoveCol.apply(_this8, arguments);
       });
+      this.indexSyncer = new IndexSyncer(this.hot.rowIndexMapper, this.hot.columnIndexMapper, function (postponedAction) {
+        _this8.hot.addHookOnce('init', function () {
+          // Engine is initialized after executing callback to `afterLoadData` hook. Thus, some actions on indexes should
+          // be postponed.
+          postponedAction();
+        });
+      });
+      this.rowAxisSyncer = this.indexSyncer.getForAxis('row');
+      this.columnAxisSyncer = this.indexSyncer.getForAxis('column');
+      this.hot.addHook('afterRowSequenceChange', this.rowAxisSyncer.getIndexesChangeSyncMethod());
+      this.hot.addHook('afterColumnSequenceChange', this.columnAxisSyncer.getIndexesChangeSyncMethod());
+      this.hot.addHook('beforeRowMove', function (movedRows, finalIndex, _, movePossible) {
+        _this8.rowAxisSyncer.storeMovesInformation(movedRows, finalIndex, movePossible);
+      });
+      this.hot.addHook('beforeColumnMove', function (movedColumns, finalIndex, _, movePossible) {
+        _this8.columnAxisSyncer.storeMovesInformation(movedColumns, finalIndex, movePossible);
+      });
+      this.hot.addHook('afterRowMove', function (movedRows, finalIndex, dropIndex, movePossible, orderChanged) {
+        _this8.rowAxisSyncer.calculateAndSyncMoves(movePossible, orderChanged);
+      });
+      this.hot.addHook('afterColumnMove', function (movedColumns, finalIndex, dropIndex, movePossible, orderChanged) {
+        _this8.columnAxisSyncer.calculateAndSyncMoves(movePossible, orderChanged);
+      });
+      this.hot.addHook('beforeColumnFreeze', function (column, freezePerformed) {
+        _this8.columnAxisSyncer.storeMovesInformation([column], _this8.hot.getSettings().fixedColumnsStart, freezePerformed);
+      });
+      this.hot.addHook('afterColumnFreeze', function (_, freezePerformed) {
+        _this8.columnAxisSyncer.calculateAndSyncMoves(freezePerformed, freezePerformed);
+      });
+      this.hot.addHook('beforeColumnUnfreeze', function (column, unfreezePerformed) {
+        _this8.columnAxisSyncer.storeMovesInformation([column], _this8.hot.getSettings().fixedColumnsStart - 1, unfreezePerformed);
+      });
+      this.hot.addHook('afterColumnUnfreeze', function (_, unfreezePerformed) {
+        _this8.columnAxisSyncer.calculateAndSyncMoves(unfreezePerformed, unfreezePerformed);
+      });
+
+      // TODO: Actions related to overwriting dates from HOT format to HF default format are done as callback to this
+      // hook, because some hooks, such as `afterLoadData` doesn't have information about composed cell properties.
+      // Another hooks are triggered to late for setting HF's engine data needed for some actions.
+      this.addHook('afterCellMetaReset', function () {
+        return _this8.onAfterCellMetaReset.apply(_this8, arguments);
+      });
 
       // Handling undo actions on data just using HyperFormula's UndoRedo mechanism
-      this.addHook('beforeUndo', function (action) {
-        // TODO: Move action isn't handled by HyperFormula.
-        if ((action === null || action === void 0 ? void 0 : action.actionType) === ROW_MOVE_UNDO_REDO_NAME) {
-          return;
-        }
+      this.addHook('beforeUndo', function () {
+        _this8.indexSyncer.setPerformUndo(true);
         _this8.engine.undo();
       });
 
       // Handling redo actions on data just using HyperFormula's UndoRedo mechanism
-      this.addHook('beforeRedo', function (action) {
-        // TODO: Move action isn't handled by HyperFormula.
-        if ((action === null || action === void 0 ? void 0 : action.actionType) === ROW_MOVE_UNDO_REDO_NAME) {
-          return;
-        }
+      this.addHook('beforeRedo', function () {
+        _this8.indexSyncer.setPerformRedo(true);
         _this8.engine.redo();
       });
+      this.addHook('afterUndo', function () {
+        _this8.indexSyncer.setPerformUndo(false);
+      });
+      this.addHook('afterUndo', function () {
+        _this8.indexSyncer.setPerformRedo(false);
+      });
       this.addHook('afterDetachChild', function () {
         return _this8.onAfterDetachChild.apply(_this8, arguments);
       });
@@ -316,7 +407,10 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
   }, {
     key: "updatePlugin",
     value: function updatePlugin(newSettings) {
-      this.engine.updateConfig(getEngineSettingsWithOverrides(this.hot.getSettings()));
+      var newEngineSettings = getEngineSettingsWithOverrides(this.hot.getSettings());
+      if (haveEngineSettingsChanged(this.engine.getConfig(), newEngineSettings)) {
+        this.engine.updateConfig(newEngineSettings);
+      }
       var pluginSettings = this.hot.getSettings()[PLUGIN_KEY];
       if (isDefined(pluginSettings) && isDefined(pluginSettings.sheetName) && pluginSettings.sheetName !== this.sheetName) {
         this.switchSheet(pluginSettings.sheetName);
@@ -355,63 +449,6 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
       _get(_getPrototypeOf(Formulas.prototype), "destroy", this).call(this);
     }
 
-    /**
-     * Helper function for `toPhysicalRowPosition` and `toPhysicalColumnPosition`.
-     *
-     * @private
-     * @param {number} visualIndex Visual entry index.
-     * @param {number} physicalIndex Physical entry index.
-     * @param {number} entriesCount Visual entries count.
-     * @param {number} sourceEntriesCount Source entries count.
-     * @param {boolean} contained `true` if it should return only indexes within boundaries of the table (basically
-     * `toPhysical` alias.
-     * @returns {*}
-     */
-  }, {
-    key: "getPhysicalIndexPosition",
-    value: function getPhysicalIndexPosition(visualIndex, physicalIndex, entriesCount, sourceEntriesCount, contained) {
-      if (!contained) {
-        if (visualIndex >= entriesCount) {
-          return sourceEntriesCount + (visualIndex - entriesCount);
-        }
-      }
-      return physicalIndex;
-    }
-
-    /**
-     * Returns the physical row index. The difference between this and Core's `toPhysical` is that it doesn't return
-     * `null` on rows with indexes higher than the number of rows.
-     *
-     * @private
-     * @param {number} row Visual row index.
-     * @param {boolean} [contained] `true` if it should return only indexes within boundaries of the table (basically
-     * `toPhysical` alias.
-     * @returns {number} The physical row index.
-     */
-  }, {
-    key: "toPhysicalRowPosition",
-    value: function toPhysicalRowPosition(row) {
-      var contained = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-      return this.getPhysicalIndexPosition(row, this.hot.toPhysicalRow(row), this.hot.countRows(), this.hot.countSourceRows(), contained);
-    }
-
-    /**
-     * Returns the physical column index. The difference between this and Core's `toPhysical` is that it doesn't return
-     * `null` on columns with indexes higher than the number of columns.
-     *
-     * @private
-     * @param {number} column Visual column index.
-     * @param {boolean} [contained] `true` if it should return only indexes within boundaries of the table (basically
-     * `toPhysical` alias.
-     * @returns {number} The physical column index.
-     */
-  }, {
-    key: "toPhysicalColumnPosition",
-    value: function toPhysicalColumnPosition(column) {
-      var contained = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-      return this.getPhysicalIndexPosition(column, this.hot.toPhysicalColumn(column), this.hot.countCols(), this.hot.countSourceCols(), contained);
-    }
-
     /**
      * Add a sheet to the shared HyperFormula instance.
      *
@@ -482,8 +519,8 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
       if (physicalRow !== null && physicalColumn !== null) {
         return this.engine.getCellType({
           sheet: sheet,
-          row: physicalRow,
-          col: physicalColumn
+          row: this.rowAxisSyncer.getHfIndexFromVisualIndex(row),
+          col: this.columnAxisSyncer.getHfIndexFromVisualIndex(column)
         });
       } else {
         // Should return `EMPTY` when out of bounds (according to the test cases).
@@ -503,15 +540,10 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
     key: "isFormulaCellType",
     value: function isFormulaCellType(row, column) {
       var sheet = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.sheetId;
-      var physicalRow = this.hot.toPhysicalRow(row);
-      var physicalColumn = this.hot.toPhysicalColumn(column);
-      if (physicalRow === null || physicalColumn === null) {
-        return false;
-      }
       return this.engine.doesCellHaveFormula({
         sheet: sheet,
-        row: physicalRow,
-        col: physicalColumn
+        row: this.rowAxisSyncer.getHfIndexFromVisualIndex(row),
+        col: this.columnAxisSyncer.getHfIndexFromVisualIndex(column)
       });
     }
 
@@ -576,11 +608,9 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
         var _ref8 = (_change$address3 = change.address) !== null && _change$address3 !== void 0 ? _change$address3 : {},
           row = _ref8.row,
           col = _ref8.col;
-        var visualRow = isDefined(row) ? _this12.hot.toVisualRow(row) : null;
-        var visualColumn = isDefined(col) ? _this12.hot.toVisualColumn(col) : null;
 
         // Don't try to validate cells outside of the visual part of the table.
-        if (visualRow === null || visualColumn === null) {
+        if (isDefined(row) === false || isDefined(col) === false || row >= _this12.hot.countRows() || col >= _this12.hot.countCols()) {
           return;
         }
 
@@ -599,7 +629,7 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
           }
 
           // It will just re-render certain cell when necessary.
-          boundHot.validateCell(boundHot.getDataAtCell(visualRow, visualColumn), boundHot.getCellMeta(visualRow, visualColumn), function () {});
+          boundHot.validateCell(boundHot.getDataAtCell(row, col), boundHot.getCellMeta(row, col), function () {});
         }
       });
     }
@@ -617,14 +647,24 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
     key: "syncChangeWithEngine",
     value: function syncChangeWithEngine(row, column, newValue) {
       var address = {
-        row: this.toPhysicalRowPosition(row),
-        col: this.toPhysicalColumnPosition(column),
+        row: this.rowAxisSyncer.getHfIndexFromVisualIndex(row),
+        col: this.columnAxisSyncer.getHfIndexFromVisualIndex(column),
         sheet: this.sheetId
       };
       if (!this.engine.isItPossibleToSetCellContents(address)) {
         warn("Not possible to set cell data at ".concat(JSON.stringify(address)));
         return;
       }
+      var cellMeta = this.hot.getCellMeta(row, column);
+      if (isDate(newValue, cellMeta.type)) {
+        if (isDateValid(newValue, cellMeta.dateFormat)) {
+          // Rewriting date in HOT format to HF format.
+          newValue = getDateInHfFormat(newValue, cellMeta.dateFormat);
+        } else if (isFormula(newValue) === false) {
+          // Escaping value from date parsing using "'" sign (HF feature).
+          newValue = "'".concat(newValue);
+        }
+      }
       return this.engine.setCellContents(address, newValue);
     }
 
@@ -644,11 +684,16 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
       var visualColumn = this.hot.propToCol(prop);
       if (this.isFormulaCellType(visualRow, visualColumn)) {
         var address = {
-          row: this.hot.toPhysicalRow(visualRow),
-          col: this.hot.toPhysicalColumn(visualColumn),
+          row: this.rowAxisSyncer.getHfIndexFromVisualIndex(visualRow),
+          col: this.columnAxisSyncer.getHfIndexFromVisualIndex(visualColumn),
           sheet: this.sheetId
         };
-        var cellValue = this.engine.getCellValue(address);
+        var cellMeta = this.hot.getCellMeta(visualRow, visualColumn);
+        var cellValue = this.engine.getCellValue(address); // Date as an integer (Excel-like date).
+
+        if (cellMeta.type === 'date' && isNumeric(cellValue)) {
+          cellValue = getDateFromExcelDate(cellValue, cellMeta.dateFormat);
+        }
 
         // If `cellValue` is an object it is expected to be an error
         return _typeof(cellValue) === 'object' && cellValue !== null ? cellValue.value : cellValue;
@@ -669,19 +714,41 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
   }, {
     key: "onBeforeAutofill",
     value: function onBeforeAutofill(fillData, sourceRange, targetRange) {
-      var _this13 = this;
-      var withSheetId = function withSheetId(range) {
-        return _objectSpread(_objectSpread({}, range), {}, {
-          sheet: _this13.sheetId
-        });
-      };
+      var _sourceRange$getTopSt = sourceRange.getTopStartCorner(),
+        sourceTopStartRow = _sourceRange$getTopSt.row,
+        sourceTopStartColumn = _sourceRange$getTopSt.col;
+      var _sourceRange$getBotto = sourceRange.getBottomEndCorner(),
+        sourceBottomEndRow = _sourceRange$getBotto.row,
+        sourceBottomEndColumn = _sourceRange$getBotto.col;
+      var _targetRange$getTopSt = targetRange.getTopStartCorner(),
+        targetTopStartRow = _targetRange$getTopSt.row,
+        targetTopStartColumn = _targetRange$getTopSt.col;
+      var _targetRange$getBotto = targetRange.getBottomEndCorner(),
+        targetBottomEndRow = _targetRange$getBotto.row,
+        targetBottomEndColumn = _targetRange$getBotto.col;
       var engineSourceRange = {
-        start: withSheetId(sourceRange.getTopStartCorner()),
-        end: withSheetId(sourceRange.getBottomEndCorner())
+        start: {
+          row: this.rowAxisSyncer.getHfIndexFromVisualIndex(sourceTopStartRow),
+          col: this.columnAxisSyncer.getHfIndexFromVisualIndex(sourceTopStartColumn),
+          sheet: this.sheetId
+        },
+        end: {
+          row: this.rowAxisSyncer.getHfIndexFromVisualIndex(sourceBottomEndRow),
+          col: this.columnAxisSyncer.getHfIndexFromVisualIndex(sourceBottomEndColumn),
+          sheet: this.sheetId
+        }
       };
       var engineTargetRange = {
-        start: withSheetId(targetRange.getTopStartCorner()),
-        end: withSheetId(targetRange.getBottomEndCorner())
+        start: {
+          row: this.rowAxisSyncer.getHfIndexFromVisualIndex(targetTopStartRow),
+          col: this.columnAxisSyncer.getHfIndexFromVisualIndex(targetTopStartColumn),
+          sheet: this.sheetId
+        },
+        end: {
+          row: this.rowAxisSyncer.getHfIndexFromVisualIndex(targetBottomEndRow),
+          col: this.columnAxisSyncer.getHfIndexFromVisualIndex(targetBottomEndColumn),
+          sheet: this.sheetId
+        }
       };
 
       // Blocks the autofill operation if HyperFormula says that at least one of
@@ -689,7 +756,33 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
       if (this.engine.isItPossibleToSetCellContents(engineTargetRange) === false) {
         return false;
       }
-      return this.engine.getFillRangeData(engineSourceRange, engineTargetRange);
+      var fillRangeData = this.engine.getFillRangeData(engineSourceRange, engineTargetRange);
+      var _engineSourceRange$st = engineSourceRange.start,
+        sourceStartRow = _engineSourceRange$st.row,
+        sourceStartColumn = _engineSourceRange$st.col;
+      var _engineSourceRange$en = engineSourceRange.end,
+        sourceEndRow = _engineSourceRange$en.row,
+        sourceEndColumn = _engineSourceRange$en.col;
+      var populationRowLength = sourceEndRow - sourceStartRow + 1;
+      var populationColumnLength = sourceEndColumn - sourceStartColumn + 1;
+      for (var populatedRowIndex = 0; populatedRowIndex < fillRangeData.length; populatedRowIndex += 1) {
+        for (var populatedColumnIndex = 0; populatedColumnIndex < fillRangeData[populatedRowIndex].length; populatedColumnIndex += 1) {
+          var populatedValue = fillRangeData[populatedRowIndex][populatedColumnIndex];
+          var sourceRow = populatedRowIndex % populationRowLength;
+          var sourceColumn = populatedColumnIndex % populationColumnLength;
+          var sourceCellMeta = this.hot.getCellMeta(sourceRow, sourceColumn);
+          if (isDate(populatedValue, sourceCellMeta.type)) {
+            if (populatedValue.startsWith('\'')) {
+              // Populating values on HOT side without apostrophe.
+              fillRangeData[populatedRowIndex][populatedColumnIndex] = populatedValue.slice(1);
+            } else if (this.isFormulaCellType(sourceRow, sourceColumn, this.sheetId) === false) {
+              // Populating date in proper format, coming from the source cell.
+              fillRangeData[populatedRowIndex][populatedColumnIndex] = getDateInHotFormat(populatedValue, sourceCellMeta.dateFormat);
+            }
+          }
+        }
+      }
+      return fillRangeData;
     }
 
     /**
@@ -713,6 +806,40 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
       _classPrivateFieldSet(this, _hotWasInitializedWithEmptyData, isUndefined(this.hot.getSettings().data));
     }
 
+    /**
+     * Callback to `afterCellMetaReset` hook which is triggered after setting cell meta.
+     *
+     * @private
+     */
+  }, {
+    key: "onAfterCellMetaReset",
+    value: function onAfterCellMetaReset() {
+      var _this13 = this;
+      var sourceDataArray = this.hot.getSourceDataArray();
+      var valueChanged = false;
+      sourceDataArray.forEach(function (rowData, rowIndex) {
+        rowData.forEach(function (cellValue, columnIndex) {
+          var cellMeta = _this13.hot.getCellMeta(rowIndex, columnIndex);
+          var dateFormat = cellMeta.dateFormat;
+          if (isDate(cellValue, cellMeta.type)) {
+            valueChanged = true;
+            if (isDateValid(cellValue, dateFormat)) {
+              // Rewriting date in HOT format to HF format.
+              sourceDataArray[rowIndex][columnIndex] = getDateInHfFormat(cellValue, dateFormat);
+            } else if (_this13.isFormulaCellType(rowIndex, columnIndex) === false) {
+              // Escaping value from date parsing using "'" sign (HF feature).
+              sourceDataArray[rowIndex][columnIndex] = "'".concat(cellValue);
+            }
+          }
+        });
+      });
+      if (valueChanged === true) {
+        _classPrivateFieldSet(this, _internalOperationPending, true);
+        this.engine.setSheetContent(this.sheetId, sourceDataArray);
+        _classPrivateFieldSet(this, _internalOperationPending, false);
+      }
+    }
+
     /**
      * `afterLoadData` hook callback.
      *
@@ -733,7 +860,8 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
         var sourceDataArray = this.hot.getSourceDataArray();
         if (this.engine.isItPossibleToReplaceSheetContent(this.sheetId, sourceDataArray)) {
           _classPrivateFieldSet(this, _internalOperationPending, true);
-          var dependentCells = this.engine.setSheetContent(this.sheetId, this.hot.getSourceDataArray());
+          var dependentCells = this.engine.setSheetContent(this.sheetId, sourceDataArray);
+          this.indexSyncer.setupSyncEndpoint(this.engine, this.sheetId);
           this.renderDependentSheets(dependentCells);
           _classPrivateFieldSet(this, _internalOperationPending, false);
         }
@@ -746,24 +874,27 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
      * `modifyData` hook callback.
      *
      * @private
-     * @param {number} row Physical row height.
-     * @param {number} column Physical column index.
+     * @param {number} physicalRow Physical row index.
+     * @param {number} visualColumn Visual column index.
      * @param {object} valueHolder Object which contains original value which can be modified by overwriting `.value`
      *   property.
      * @param {string} ioMode String which indicates for what operation hook is fired (`get` or `set`).
      */
   }, {
     key: "onModifyData",
-    value: function onModifyData(row, column, valueHolder, ioMode) {
+    value: function onModifyData(physicalRow, visualColumn, valueHolder, ioMode) {
       if (ioMode !== 'get' || _classPrivateFieldGet(this, _internalOperationPending) || this.sheetName === null || !this.engine.doesSheetExist(this.sheetName)) {
         return;
       }
-      var visualRow = this.hot.toVisualRow(row);
+      var visualRow = this.hot.toVisualRow(physicalRow);
+      if (visualRow === null || visualColumn === null) {
+        return;
+      }
 
       // `column` is here as visual index because of inconsistencies related to hook execution in `src/dataMap`.
-      var isFormulaCellType = this.isFormulaCellType(visualRow, column);
+      var isFormulaCellType = this.isFormulaCellType(visualRow, visualColumn);
       if (!isFormulaCellType) {
-        var cellType = this.getCellType(visualRow, column);
+        var cellType = this.getCellType(visualRow, visualColumn);
         if (cellType !== 'ARRAY') {
           if (isEscapedFormulaExpression(valueHolder.value)) {
             valueHolder.value = unescapeFormulaExpression(valueHolder.value);
@@ -771,14 +902,16 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
           return;
         }
       }
-
-      // `toPhysicalColumn` is here because of inconsistencies related to hook execution in `DataMap`.
       var address = {
-        row: row,
-        col: this.toPhysicalColumnPosition(column),
+        row: this.rowAxisSyncer.getHfIndexFromVisualIndex(visualRow),
+        col: this.columnAxisSyncer.getHfIndexFromVisualIndex(visualColumn),
         sheet: this.sheetId
       };
-      var cellValue = this.engine.getCellValue(address);
+      var cellValue = this.engine.getCellValue(address); // Date as an integer (Excel like date).
+      var cellMeta = this.hot.getCellMeta(visualRow, visualColumn);
+      if (cellMeta.type === 'date' && isNumeric(cellValue)) {
+        cellValue = getDateFromExcelDate(cellValue, cellMeta.dateFormat);
+      }
 
       // If `cellValue` is an object it is expected to be an error
       var value = _typeof(cellValue) === 'object' && cellValue !== null ? cellValue.value : cellValue;
@@ -803,6 +936,9 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
       }
       var visualRow = this.hot.toVisualRow(row);
       var visualColumn = this.hot.propToCol(columnOrProp);
+      if (visualRow === null || visualColumn === null) {
+        return;
+      }
 
       // `column` is here as visual index because of inconsistencies related to hook execution in `src/dataMap`.
       var isFormulaCellType = this.isFormulaCellType(visualRow, visualColumn);
@@ -822,9 +958,8 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
         return;
       }
       var address = {
-        row: row,
-        // Workaround for inconsistencies in `src/dataSource.js`
-        col: this.toPhysicalColumnPosition(visualColumn),
+        row: this.rowAxisSyncer.getHfIndexFromVisualIndex(visualRow),
+        col: this.columnAxisSyncer.getHfIndexFromVisualIndex(visualColumn),
         sheet: this.sheetId
       };
       valueHolder.value = this.engine.getCellSerialized(address);
@@ -850,21 +985,21 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
       var dependentCells = this.engine.batch(function () {
         changes.forEach(function (_ref9) {
           var _ref10 = _slicedToArray(_ref9, 4),
-            row = _ref10[0],
+            visualRow = _ref10[0],
             prop = _ref10[1],
             newValue = _ref10[3];
-          var column = _this14.hot.propToCol(prop);
-          var physicalRow = _this14.hot.toPhysicalRow(row);
-          var physicalColumn = _this14.hot.toPhysicalColumn(column);
+          var visualColumn = _this14.hot.propToCol(prop);
+          var physicalRow = _this14.hot.toPhysicalRow(visualRow);
+          var physicalColumn = _this14.hot.toPhysicalColumn(visualColumn);
           var address = {
-            row: physicalRow,
-            col: physicalColumn,
+            row: _this14.rowAxisSyncer.getHfIndexFromVisualIndex(visualRow),
+            col: _this14.columnAxisSyncer.getHfIndexFromVisualIndex(visualColumn),
             sheet: _this14.sheetId
           };
           if (physicalRow !== null && physicalColumn !== null) {
-            _this14.syncChangeWithEngine(row, column, newValue);
+            _this14.syncChangeWithEngine(visualRow, visualColumn, newValue);
           } else {
-            outOfBoundsChanges.push([row, column, newValue]);
+            outOfBoundsChanges.push([visualRow, visualColumn, newValue]);
           }
           changedCells.push({
             address: address
@@ -910,16 +1045,16 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
       var changedCells = [];
       changes.forEach(function (_ref13) {
         var _ref14 = _slicedToArray(_ref13, 4),
-          row = _ref14[0],
+          visualRow = _ref14[0],
           prop = _ref14[1],
           newValue = _ref14[3];
-        var column = _this15.hot.propToCol(prop);
-        if (!isNumeric(column)) {
+        var visualColumn = _this15.hot.propToCol(prop);
+        if (!isNumeric(visualColumn)) {
           return;
         }
         var address = {
-          row: row,
-          col: _this15.toPhysicalColumnPosition(column),
+          row: _this15.rowAxisSyncer.getHfIndexFromVisualIndex(visualRow),
+          col: _this15.columnAxisSyncer.getHfIndexFromVisualIndex(visualColumn),
           sheet: _this15.sheetId
         };
         if (!_this15.engine.isItPossibleToSetCellContents(address)) {
@@ -939,14 +1074,19 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
      * `beforeCreateRow` hook callback.
      *
      * @private
-     * @param {number} row Represents the visual index of first newly created row in the data source array.
+     * @param {number} visualRow Represents the visual index of first newly created row in the data source array.
      * @param {number} amount Number of newly created rows in the data source array.
      * @returns {*|boolean} If false is returned the action is canceled.
      */
   }, {
     key: "onBeforeCreateRow",
-    value: function onBeforeCreateRow(row, amount) {
-      if (this.sheetId === null || !this.engine.doesSheetExist(this.sheetName) || !this.engine.isItPossibleToAddRows(this.sheetId, [this.toPhysicalRowPosition(row), amount])) {
+    value: function onBeforeCreateRow(visualRow, amount) {
+      var hfRowIndex = this.rowAxisSyncer.getHfIndexFromVisualIndex(visualRow);
+      if (visualRow >= this.hot.countRows()) {
+        hfRowIndex = visualRow; // Row beyond the table boundaries.
+      }
+
+      if (this.sheetId === null || !this.engine.doesSheetExist(this.sheetName) || !this.engine.isItPossibleToAddRows(this.sheetId, [hfRowIndex, amount])) {
         return false;
       }
     }
@@ -955,14 +1095,19 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
      * `beforeCreateCol` hook callback.
      *
      * @private
-     * @param {number} col Represents the visual index of first newly created column in the data source.
+     * @param {number} visualColumn Represents the visual index of first newly created column in the data source.
      * @param {number} amount Number of newly created columns in the data source.
      * @returns {*|boolean} If false is returned the action is canceled.
      */
   }, {
     key: "onBeforeCreateCol",
-    value: function onBeforeCreateCol(col, amount) {
-      if (this.sheetId === null || !this.engine.doesSheetExist(this.sheetName) || !this.engine.isItPossibleToAddColumns(this.sheetId, [this.toPhysicalColumnPosition(col), amount])) {
+    value: function onBeforeCreateCol(visualColumn, amount) {
+      var hfColumnIndex = this.columnAxisSyncer.getHfIndexFromVisualIndex(visualColumn);
+      if (visualColumn >= this.hot.countCols()) {
+        hfColumnIndex = visualColumn; // Column beyond the table boundaries.
+      }
+
+      if (this.sheetId === null || !this.engine.doesSheetExist(this.sheetName) || !this.engine.isItPossibleToAddColumns(this.sheetId, [hfColumnIndex, amount])) {
         return false;
       }
     }
@@ -980,8 +1125,9 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
     key: "onBeforeRemoveRow",
     value: function onBeforeRemoveRow(row, amount, physicalRows) {
       var _this16 = this;
-      var possible = physicalRows.every(function (physicalRow) {
-        return _this16.engine.isItPossibleToRemoveRows(_this16.sheetId, [physicalRow, 1]);
+      var hfRows = this.rowAxisSyncer.setRemovedHfIndexes(physicalRows);
+      var possible = hfRows.every(function (hfRow) {
+        return _this16.engine.isItPossibleToRemoveRows(_this16.sheetId, [hfRow, 1]);
       });
       return possible === false ? false : void 0;
     }
@@ -999,8 +1145,9 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
     key: "onBeforeRemoveCol",
     value: function onBeforeRemoveCol(col, amount, physicalColumns) {
       var _this17 = this;
-      var possible = physicalColumns.every(function (physicalColumn) {
-        return _this17.engine.isItPossibleToRemoveColumns(_this17.sheetId, [physicalColumn, 1]);
+      var hfColumns = this.columnAxisSyncer.setRemovedHfIndexes(physicalColumns);
+      var possible = hfColumns.every(function (hfColumn) {
+        return _this17.engine.isItPossibleToRemoveColumns(_this17.sheetId, [hfColumn, 1]);
       });
       return possible === false ? false : void 0;
     }
@@ -1009,18 +1156,18 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
      * `afterCreateRow` hook callback.
      *
      * @private
-     * @param {number} row Represents the visual index of first newly created row in the data source array.
+     * @param {number} visualRow Represents the visual index of first newly created row in the data source array.
      * @param {number} amount Number of newly created rows in the data source array.
      * @param {string} [source] String that identifies source of hook call
      *                          ([list of all available sources]{@link https://handsontable.com/docs/javascript-data-grid/events-and-hooks/#handsontable-hooks}).
      */
   }, {
     key: "onAfterCreateRow",
-    value: function onAfterCreateRow(row, amount, source) {
+    value: function onAfterCreateRow(visualRow, amount, source) {
       if (isBlockedSource(source)) {
         return;
       }
-      var changes = this.engine.addRows(this.sheetId, [this.toPhysicalRowPosition(row), amount]);
+      var changes = this.engine.addRows(this.sheetId, [this.rowAxisSyncer.getHfIndexFromVisualIndex(visualRow), amount]);
       this.renderDependentSheets(changes);
     }
 
@@ -1028,18 +1175,18 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
      * `afterCreateCol` hook callback.
      *
      * @private
-     * @param {number} col Represents the visual index of first newly created column in the data source.
+     * @param {number} visualColumn Represents the visual index of first newly created column in the data source.
      * @param {number} amount Number of newly created columns in the data source.
      * @param {string} [source] String that identifies source of hook call
      *                          ([list of all available sources]{@link https://handsontable.com/docs/javascript-data-grid/events-and-hooks/#handsontable-hooks}).
      */
   }, {
     key: "onAfterCreateCol",
-    value: function onAfterCreateCol(col, amount, source) {
+    value: function onAfterCreateCol(visualColumn, amount, source) {
       if (isBlockedSource(source)) {
         return;
       }
-      var changes = this.engine.addColumns(this.sheetId, [this.toPhysicalColumnPosition(col), amount]);
+      var changes = this.engine.addColumns(this.sheetId, [this.columnAxisSyncer.getHfIndexFromVisualIndex(visualColumn), amount]);
       this.renderDependentSheets(changes);
     }
 
@@ -1060,10 +1207,10 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
       if (isBlockedSource(source)) {
         return;
       }
-      var descendingPhysicalRows = physicalRows.sort().reverse();
+      var descendingHfRows = this.rowAxisSyncer.getRemovedHfIndexes().sort().reverse();
       var changes = this.engine.batch(function () {
-        descendingPhysicalRows.forEach(function (physicalRow) {
-          _this18.engine.removeRows(_this18.sheetId, [physicalRow, 1]);
+        descendingHfRows.forEach(function (hfRow) {
+          _this18.engine.removeRows(_this18.sheetId, [hfRow, 1]);
         });
       });
       this.renderDependentSheets(changes);
@@ -1086,10 +1233,10 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
       if (isBlockedSource(source)) {
         return;
       }
-      var descendingPhysicalColumns = physicalColumns.sort().reverse();
+      var descendingHfColumns = this.columnAxisSyncer.getRemovedHfIndexes().sort().reverse();
       var changes = this.engine.batch(function () {
-        descendingPhysicalColumns.forEach(function (physicalColumn) {
-          _this19.engine.removeColumns(_this19.sheetId, [physicalColumn, 1]);
+        descendingHfColumns.forEach(function (hfColumn) {
+          _this19.engine.removeColumns(_this19.sheetId, [hfColumn, 1]);
         });
       });
       this.renderDependentSheets(changes);
@@ -1214,13 +1361,11 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
     get: function get() {
       return PLUGIN_PRIORITY;
     }
-
-    /**
-     * Flag used to bypass hooks in internal operations.
-     *
-     * @private
-     * @type {boolean}
-     */
+  }, {
+    key: "SETTING_KEYS",
+    get: function get() {
+      return [PLUGIN_KEY].concat(SETTING_KEYS);
+    }
   }]);
   return Formulas;
 }(BasePlugin);