handsontable 9.0.2 → 11.1.0

package/plugins/formulas/formulas.mjs

@@ -6,7 +6,11 @@ function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symb
 
 function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
 
-function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+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(); }
 
@@ -21,9 +25,9 @@ function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Sy
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 
 import "core-js/modules/es.array.concat.js";
+import "core-js/modules/es.object.to-string.js";
 import "core-js/modules/web.dom-collections.for-each.js";
 import "core-js/modules/es.array.iterator.js";
-import "core-js/modules/es.object.to-string.js";
 import "core-js/modules/es.set.js";
 import "core-js/modules/es.string.iterator.js";
 import "core-js/modules/web.dom-collections.iterator.js";
@@ -44,24 +48,28 @@ 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, descriptor.key, descriptor); } }
 
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
 
-function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
+function _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
 
 function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
 
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
 
 function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
 
-function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
 
 function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
 
@@ -71,6 +79,10 @@ function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.g
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
+function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
+
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+
 function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
 
 function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
@@ -82,9 +94,9 @@ function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!priva
 function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
 
 import { BasePlugin } from "../base/index.mjs";
-import { createAutofillHooks } from "./autofill.mjs";
 import staticRegister from "../../utils/staticRegister.mjs";
 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";
@@ -94,21 +106,32 @@ import { toUpperCaseFirst } from "../../helpers/string.mjs";
 import Hooks from "../../pluginHooks.mjs";
 export var PLUGIN_KEY = 'formulas';
 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');
 Hooks.getSingleton().register('afterSheetRemoved');
 Hooks.getSingleton().register('afterSheetRenamed');
-Hooks.getSingleton().register('afterFormulasValuesUpdate');
+Hooks.getSingleton().register('afterFormulasValuesUpdate'); // This function will be used for detecting changes coming from the `UndoRedo` plugin. This kind of change won't be
+// handled by whole body of listeners and therefore won't change undo/redo stack inside engine provided by HyperFormula.
+// HyperFormula's `undo` and `redo` methods will do it instead. Please keep in mind that undo/redo stacks inside
+// instances of Handsontable and HyperFormula should be synced (number of actions should be the same).
+
+var isBlockedSource = function isBlockedSource(source) {
+  return source === 'UndoRedo.undo' || source === 'UndoRedo.redo' || source === 'auto';
+};
 /**
  * This plugin allows you to perform Excel-like calculations in your business applications. It does it by an
  * integration with our other product, [HyperFormula](https://github.com/handsontable/hyperformula/), which is a
  * powerful calculation engine with an extensive number of features.
  *
+ * To test out HyperFormula, see [this guide](@/guides/formulas/formula-calculation.md#available-functions).
+ *
  * @plugin Formulas
  * @class Formulas
  */
 
+
 var _internalOperationPending = /*#__PURE__*/new WeakMap();
 
 var _hotWasInitializedWithEmptyData = /*#__PURE__*/new WeakMap();
@@ -131,17 +154,17 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
 
     _this = _super.call.apply(_super, [this].concat(_args));
 
-    _internalOperationPending.set(_assertThisInitialized(_this), {
+    _classPrivateFieldInitSpec(_assertThisInitialized(_this), _internalOperationPending, {
       writable: true,
       value: false
     });
 
-    _hotWasInitializedWithEmptyData.set(_assertThisInitialized(_this), {
+    _classPrivateFieldInitSpec(_assertThisInitialized(_this), _hotWasInitializedWithEmptyData, {
       writable: true,
       value: false
     });
 
-    _engineListeners.set(_assertThisInitialized(_this), {
+    _classPrivateFieldInitSpec(_assertThisInitialized(_this), _engineListeners, {
       writable: true,
       value: [['valuesUpdated', function () {
         var _this2;
@@ -226,7 +249,11 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
 
 
       if (this.sheetName !== null && !this.engine.doesSheetExist(this.sheetName)) {
-        this.sheetName = this.addSheet(this.sheetName, this.hot.getSourceDataArray());
+        var newSheetName = this.addSheet(this.sheetName, this.hot.getSourceDataArray());
+
+        if (newSheetName !== false) {
+          this.sheetName = newSheetName;
+        }
       }
 
       this.addHook('beforeLoadData', function () {
@@ -276,10 +303,31 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
       });
       this.addHook('afterRemoveCol', function () {
         return _this8.onAfterRemoveCol.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;
+        }
+
+        _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;
+        }
+
+        _this8.engine.redo();
+      });
+      this.addHook('afterDetachChild', function () {
+        return _this8.onAfterDetachChild.apply(_this8, arguments);
+      });
+      this.addHook('beforeAutofill', function () {
+        return _this8.onBeforeAutofill.apply(_this8, arguments);
       });
-      var autofillHooks = createAutofillHooks(this);
-      this.addHook('beforeAutofill', autofillHooks.beforeAutofill);
-      this.addHook('afterAutofill', autofillHooks.afterAutofill);
 
       _classPrivateFieldGet(this, _engineListeners).forEach(function (_ref) {
         var _ref2 = _slicedToArray(_ref, 2),
@@ -309,6 +357,7 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
       });
 
       unregisterEngine(this.engine, this.hot);
+      this.engine = null;
 
       _get(_getPrototypeOf(Formulas.prototype), "disablePlugin", this).call(this);
     }
@@ -365,6 +414,7 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
       _classPrivateFieldSet(this, _engineListeners, null);
 
       unregisterEngine(this.engine, this.hot);
+      this.engine = null;
 
       _get(_getPrototypeOf(Formulas.prototype), "destroy", this).call(this);
     }
@@ -454,7 +504,7 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
         var actualSheetName = this.engine.addSheet(sheetName !== null && sheetName !== void 0 ? sheetName : void 0);
 
         if (sheetData) {
-          this.engine.setSheetContent(actualSheetName, sheetData);
+          this.engine.setSheetContent(this.engine.getSheetId(actualSheetName), sheetData);
         }
 
         return actualSheetName;
@@ -491,18 +541,26 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
      * @param {number} row Visual row index.
      * @param {number} column Visual column index.
      * @param {number} [sheet] The target sheet id, defaults to the current sheet.
-     * @returns {string} Possible values: 'FORMULA' | 'VALUE' | 'MATRIX' | 'EMPTY'.
+     * @returns {string} Possible values: 'FORMULA' | 'VALUE' | 'ARRAYFORMULA' | 'EMPTY'.
      */
 
   }, {
     key: "getCellType",
     value: function getCellType(row, column) {
       var sheet = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.sheetId;
-      return this.engine.getCellType({
-        sheet: sheet,
-        row: this.hot.toPhysicalRow(row),
-        col: this.hot.toPhysicalColumn(column)
-      });
+      var physicalRow = this.hot.toPhysicalRow(row);
+      var physicalColumn = this.hot.toPhysicalColumn(column);
+
+      if (physicalRow !== null && physicalColumn !== null) {
+        return this.engine.getCellType({
+          sheet: sheet,
+          row: physicalRow,
+          col: physicalColumn
+        });
+      } else {
+        // Should return `EMPTY` when out of bounds (according to the test cases).
+        return 'EMPTY';
+      }
     }
     /**
      * Returns `true` if under specified visual coordinates is formula.
@@ -517,8 +575,18 @@ 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 cellType = this.getCellType(row, column, sheet);
-      return cellType === 'FORMULA' || cellType === 'MATRIX';
+      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
+      });
     }
     /**
      * Renders dependent sheets (handsontable instances) based on the changes - list of the
@@ -667,6 +735,44 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
 
       return value;
     }
+    /**
+     * `onBeforeAutofill` hook callback.
+     *
+     * @private
+     * @param {Array[]} fillData The data that was used to fill the `targetRange`. If `beforeAutofill` was used
+     * and returned `[[]]`, this will be the same object that was returned from `beforeAutofill`.
+     * @param {CellRange} sourceRange The range values will be filled from.
+     * @param {CellRange} targetRange The range new values will be filled into.
+     * @returns {boolean|*}
+     */
+
+  }, {
+    key: "onBeforeAutofill",
+    value: function onBeforeAutofill(fillData, sourceRange, targetRange) {
+      var _this13 = this;
+
+      var withSheetId = function withSheetId(range) {
+        return _objectSpread(_objectSpread({}, range), {}, {
+          sheet: _this13.sheetId
+        });
+      };
+
+      var engineSourceRange = {
+        start: withSheetId(sourceRange.getTopLeftCorner()),
+        end: withSheetId(sourceRange.getBottomRightCorner())
+      };
+      var engineTargetRange = {
+        start: withSheetId(targetRange.getTopLeftCorner()),
+        end: withSheetId(targetRange.getBottomRightCorner())
+      }; // Blocks the autofill operation if HyperFormula says that at least one of
+      // the underlying cell's contents cannot be set.
+
+      if (this.engine.isItPossibleToSetCellContents(engineTargetRange) === false) {
+        return false;
+      }
+
+      return this.engine.getFillRangeData(engineSourceRange, engineTargetRange);
+    }
     /**
      * `beforeLoadData` hook callback.
      *
@@ -712,10 +818,10 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
       if (!_classPrivateFieldGet(this, _hotWasInitializedWithEmptyData)) {
         var sourceDataArray = this.hot.getSourceDataArray();
 
-        if (this.engine.isItPossibleToReplaceSheetContent(this.sheetName, sourceDataArray)) {
+        if (this.engine.isItPossibleToReplaceSheetContent(this.sheetId, sourceDataArray)) {
           _classPrivateFieldSet(this, _internalOperationPending, true);
 
-          var dependentCells = this.engine.setSheetContent(this.sheetName, this.hot.getSourceDataArray());
+          var dependentCells = this.engine.setSheetContent(this.sheetId, this.hot.getSourceDataArray());
           this.renderDependentSheets(dependentCells);
 
           _classPrivateFieldSet(this, _internalOperationPending, false);
@@ -740,18 +846,23 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
     value: function onModifyData(row, column, valueHolder, ioMode) {
       if (ioMode !== 'get' || _classPrivateFieldGet(this, _internalOperationPending) || this.sheetName === null || !this.engine.doesSheetExist(this.sheetName)) {
         return;
-      } // `column` is here as visual index because of inconsistencies related to hook execution in `src/dataMap`.
+      }
 
+      var visualRow = this.hot.toVisualRow(row); // `column` is here as visual index because of inconsistencies related to hook execution in `src/dataMap`.
 
-      var isFormulaCellType = this.isFormulaCellType(this.hot.toVisualRow(row), column);
+      var isFormulaCellType = this.isFormulaCellType(visualRow, column);
 
       if (!isFormulaCellType) {
-        if (isEscapedFormulaExpression(valueHolder.value)) {
-          valueHolder.value = unescapeFormulaExpression(valueHolder.value);
-        }
+        var cellType = this.getCellType(visualRow, column);
 
-        return;
-      } // `toPhysicalColumn` is here because of inconsistencies related to hook execution in `src/dataMap`.
+        if (cellType !== 'ARRAY') {
+          if (isEscapedFormulaExpression(valueHolder.value)) {
+            valueHolder.value = unescapeFormulaExpression(valueHolder.value);
+          }
+
+          return;
+        }
+      } // `toPhysicalColumn` is here because of inconsistencies related to hook execution in `DataMap`.
 
 
       var address = {
@@ -782,12 +893,17 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
         return;
       }
 
+      var visualRow = this.hot.toVisualRow(row);
       var visualColumn = this.hot.propToCol(columnOrProp); // `column` is here as visual index because of inconsistencies related to hook execution in `src/dataMap`.
 
-      var isFormulaCellType = this.isFormulaCellType(this.hot.toVisualRow(row), visualColumn);
+      var isFormulaCellType = this.isFormulaCellType(visualRow, visualColumn);
 
       if (!isFormulaCellType) {
-        return;
+        var cellType = this.getCellType(visualRow, visualColumn);
+
+        if (cellType !== 'ARRAY') {
+          return;
+        }
       }
 
       var dimensions = this.engine.getSheetDimensions(this.engine.getSheetId(this.sheetName)); // Don't actually change the source data if HyperFormula is not
@@ -812,42 +928,49 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
      *
      * @private
      * @param {Array[]} changes An array of changes in format [[row, prop, oldValue, value], ...].
+     * @param {string} [source] String that identifies source of hook call
+     *                          ([list of all available sources]{@link http://docs.handsontable.com/tutorial-using-callbacks.html#page-source-definition}).
      */
 
   }, {
     key: "onAfterSetDataAtCell",
-    value: function onAfterSetDataAtCell(changes) {
-      var _this13 = this;
+    value: function onAfterSetDataAtCell(changes, source) {
+      var _this14 = this;
+
+      if (isBlockedSource(source)) {
+        return;
+      }
 
-      var dependentCells = [];
       var outOfBoundsChanges = [];
       var changedCells = [];
-      changes.forEach(function (_ref9) {
-        var _ref10 = _slicedToArray(_ref9, 4),
-            row = _ref10[0],
-            prop = _ref10[1],
-            newValue = _ref10[3];
+      var dependentCells = this.engine.batch(function () {
+        changes.forEach(function (_ref9) {
+          var _ref10 = _slicedToArray(_ref9, 4),
+              row = _ref10[0],
+              prop = _ref10[1],
+              newValue = _ref10[3];
 
-        var column = _this13.hot.propToCol(prop);
+          var column = _this14.hot.propToCol(prop);
 
-        var physicalRow = _this13.hot.toPhysicalRow(row);
+          var physicalRow = _this14.hot.toPhysicalRow(row);
 
-        var physicalColumn = _this13.hot.toPhysicalColumn(column);
+          var physicalColumn = _this14.hot.toPhysicalColumn(column);
 
-        var address = {
-          row: physicalRow,
-          col: physicalColumn,
-          sheet: _this13.sheetId
-        };
+          var address = {
+            row: physicalRow,
+            col: physicalColumn,
+            sheet: _this14.sheetId
+          };
 
-        if (physicalRow !== null && physicalColumn !== null) {
-          dependentCells.push.apply(dependentCells, _toConsumableArray(_this13.syncChangeWithEngine(row, column, newValue)));
-        } else {
-          outOfBoundsChanges.push([row, column, newValue]);
-        }
+          if (physicalRow !== null && physicalColumn !== null) {
+            _this14.syncChangeWithEngine(row, column, newValue);
+          } else {
+            outOfBoundsChanges.push([row, column, newValue]);
+          }
 
-        changedCells.push({
-          address: address
+          changedCells.push({
+            address: address
+          });
         });
       });
 
@@ -855,17 +978,18 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
         // Workaround for rows/columns being created two times (by HOT and the engine).
         // (unfortunately, this requires an extra re-render)
         this.hot.addHookOnce('afterChange', function () {
-          var outOfBoundsDependentCells = [];
-          outOfBoundsChanges.forEach(function (_ref11) {
-            var _ref12 = _slicedToArray(_ref11, 3),
-                row = _ref12[0],
-                column = _ref12[1],
-                newValue = _ref12[2];
-
-            outOfBoundsDependentCells.push.apply(outOfBoundsDependentCells, _toConsumableArray(_this13.syncChangeWithEngine(row, column, newValue)));
+          var outOfBoundsDependentCells = _this14.engine.batch(function () {
+            outOfBoundsChanges.forEach(function (_ref11) {
+              var _ref12 = _slicedToArray(_ref11, 3),
+                  row = _ref12[0],
+                  column = _ref12[1],
+                  newValue = _ref12[2];
+
+              _this14.syncChangeWithEngine(row, column, newValue);
+            });
           });
 
-          _this13.renderDependentSheets(outOfBoundsDependentCells, true);
+          _this14.renderDependentSheets(outOfBoundsDependentCells, true);
         });
       }
 
@@ -877,28 +1001,40 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
      *
      * @private
      * @param {Array[]} changes An array of changes in format [[row, column, oldValue, value], ...].
+     * @param {string} [source] String that identifies source of hook call
+     *                          ([list of all available sources]{@link http://docs.handsontable.com/tutorial-using-callbacks.html#page-source-definition}).
      */
 
   }, {
     key: "onAfterSetSourceDataAtCell",
-    value: function onAfterSetSourceDataAtCell(changes) {
-      var _this14 = this;
+    value: function onAfterSetSourceDataAtCell(changes, source) {
+      var _this15 = this;
+
+      if (isBlockedSource(source)) {
+        return;
+      }
 
       var dependentCells = [];
       var changedCells = [];
       changes.forEach(function (_ref13) {
         var _ref14 = _slicedToArray(_ref13, 4),
             row = _ref14[0],
-            column = _ref14[1],
+            prop = _ref14[1],
             newValue = _ref14[3];
 
+        var column = _this15.hot.propToCol(prop);
+
+        if (!isNumeric(column)) {
+          return;
+        }
+
         var address = {
           row: row,
-          col: _this14.toPhysicalColumnPosition(column),
-          sheet: _this14.sheetId
+          col: _this15.toPhysicalColumnPosition(column),
+          sheet: _this15.sheetId
         };
 
-        if (!_this14.engine.isItPossibleToSetCellContents(address)) {
+        if (!_this15.engine.isItPossibleToSetCellContents(address)) {
           warn("Not possible to set source cell data at ".concat(JSON.stringify(address)));
           return;
         }
@@ -906,7 +1042,7 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
         changedCells.push({
           address: address
         });
-        dependentCells.push.apply(dependentCells, _toConsumableArray(_this14.engine.setCellContents(address, newValue)));
+        dependentCells.push.apply(dependentCells, _toConsumableArray(_this15.engine.setCellContents(address, newValue)));
       });
       this.renderDependentSheets(dependentCells);
       this.validateDependentCells(dependentCells, changedCells);
@@ -923,7 +1059,7 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
   }, {
     key: "onBeforeCreateRow",
     value: function onBeforeCreateRow(row, amount) {
-      if (!this.engine.isItPossibleToAddRows(this.sheetId, [this.toPhysicalRowPosition(row), amount])) {
+      if (this.sheetId === null || !this.engine.doesSheetExist(this.sheetName) || !this.engine.isItPossibleToAddRows(this.sheetId, [this.toPhysicalRowPosition(row), amount])) {
         return false;
       }
     }
@@ -939,7 +1075,7 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
   }, {
     key: "onBeforeCreateCol",
     value: function onBeforeCreateCol(col, amount) {
-      if (!this.engine.isItPossibleToAddColumns(this.sheetId, [this.toPhysicalColumnPosition(col), amount])) {
+      if (this.sheetId === null || !this.engine.doesSheetExist(this.sheetName) || !this.engine.isItPossibleToAddColumns(this.sheetId, [this.toPhysicalColumnPosition(col), amount])) {
         return false;
       }
     }
@@ -956,10 +1092,10 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
   }, {
     key: "onBeforeRemoveRow",
     value: function onBeforeRemoveRow(row, amount, physicalRows) {
-      var _this15 = this;
+      var _this16 = this;
 
       var possible = physicalRows.every(function (physicalRow) {
-        return _this15.engine.isItPossibleToRemoveRows(_this15.sheetId, [physicalRow, 1]);
+        return _this16.engine.isItPossibleToRemoveRows(_this16.sheetId, [physicalRow, 1]);
       });
       return possible === false ? false : void 0;
     }
@@ -976,10 +1112,10 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
   }, {
     key: "onBeforeRemoveCol",
     value: function onBeforeRemoveCol(col, amount, physicalColumns) {
-      var _this16 = this;
+      var _this17 = this;
 
       var possible = physicalColumns.every(function (physicalColumn) {
-        return _this16.engine.isItPossibleToRemoveColumns(_this16.sheetId, [physicalColumn, 1]);
+        return _this17.engine.isItPossibleToRemoveColumns(_this17.sheetId, [physicalColumn, 1]);
       });
       return possible === false ? false : void 0;
     }
@@ -989,11 +1125,17 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
      * @private
      * @param {number} row 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 http://docs.handsontable.com/tutorial-using-callbacks.html#page-source-definition}).
      */
 
   }, {
     key: "onAfterCreateRow",
-    value: function onAfterCreateRow(row, amount) {
+    value: function onAfterCreateRow(row, amount, source) {
+      if (isBlockedSource(source)) {
+        return;
+      }
+
       var changes = this.engine.addRows(this.sheetId, [this.toPhysicalRowPosition(row), amount]);
       this.renderDependentSheets(changes);
     }
@@ -1003,11 +1145,17 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
      * @private
      * @param {number} col 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 http://docs.handsontable.com/tutorial-using-callbacks.html#page-source-definition}).
      */
 
   }, {
     key: "onAfterCreateCol",
-    value: function onAfterCreateCol(col, amount) {
+    value: function onAfterCreateCol(col, amount, source) {
+      if (isBlockedSource(source)) {
+        return;
+      }
+
       var changes = this.engine.addColumns(this.sheetId, [this.toPhysicalColumnPosition(col), amount]);
       this.renderDependentSheets(changes);
     }
@@ -1018,17 +1166,23 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
      * @param {number} row Visual index of starter row.
      * @param {number} amount An amount of removed rows.
      * @param {number[]} physicalRows An array of physical rows removed from the data source.
+     * @param {string} [source] String that identifies source of hook call
+     *                          ([list of all available sources]{@link http://docs.handsontable.com/tutorial-using-callbacks.html#page-source-definition}).
      */
 
   }, {
     key: "onAfterRemoveRow",
-    value: function onAfterRemoveRow(row, amount, physicalRows) {
-      var _this17 = this;
+    value: function onAfterRemoveRow(row, amount, physicalRows, source) {
+      var _this18 = this;
+
+      if (isBlockedSource(source)) {
+        return;
+      }
 
       var descendingPhysicalRows = physicalRows.sort().reverse();
       var changes = this.engine.batch(function () {
         descendingPhysicalRows.forEach(function (physicalRow) {
-          _this17.engine.removeRows(_this17.sheetId, [physicalRow, 1]);
+          _this18.engine.removeRows(_this18.sheetId, [physicalRow, 1]);
         });
       });
       this.renderDependentSheets(changes);
@@ -1040,21 +1194,59 @@ export var Formulas = /*#__PURE__*/function (_BasePlugin) {
      * @param {number} col Visual index of starter column.
      * @param {number} amount An amount of removed columns.
      * @param {number[]} physicalColumns An array of physical columns removed from the data source.
+     * @param {string} [source] String that identifies source of hook call
+     *                          ([list of all available sources]{@link http://docs.handsontable.com/tutorial-using-callbacks.html#page-source-definition}).
      */
 
   }, {
     key: "onAfterRemoveCol",
-    value: function onAfterRemoveCol(col, amount, physicalColumns) {
-      var _this18 = this;
+    value: function onAfterRemoveCol(col, amount, physicalColumns, source) {
+      var _this19 = this;
+
+      if (isBlockedSource(source)) {
+        return;
+      }
 
       var descendingPhysicalColumns = physicalColumns.sort().reverse();
       var changes = this.engine.batch(function () {
         descendingPhysicalColumns.forEach(function (physicalColumn) {
-          _this18.engine.removeColumns(_this18.sheetId, [physicalColumn, 1]);
+          _this19.engine.removeColumns(_this19.sheetId, [physicalColumn, 1]);
         });
       });
       this.renderDependentSheets(changes);
     }
+    /**
+     * `afterDetachChild` hook callback.
+     * Used to sync the data of the rows detached in the Nested Rows plugin with the engine's dataset.
+     *
+     * @private
+     * @param {object} parent An object representing the parent from which the element was detached.
+     * @param {object} element The detached element.
+     * @param {number} finalElementRowIndex The final row index of the detached element.
+     */
+
+  }, {
+    key: "onAfterDetachChild",
+    value: function onAfterDetachChild(parent, element, finalElementRowIndex) {
+      var _element$__children,
+          _this20 = this;
+
+      _classPrivateFieldSet(this, _internalOperationPending, true);
+
+      var rowsData = this.hot.getSourceDataArray(finalElementRowIndex, 0, finalElementRowIndex + (((_element$__children = element.__children) === null || _element$__children === void 0 ? void 0 : _element$__children.length) || 0), this.hot.countSourceCols());
+
+      _classPrivateFieldSet(this, _internalOperationPending, false);
+
+      rowsData.forEach(function (row, relativeRowIndex) {
+        row.forEach(function (value, colIndex) {
+          _this20.engine.setCellContents({
+            col: colIndex,
+            row: finalElementRowIndex + relativeRowIndex,
+            sheet: _this20.sheetId
+          }, [[value]]);
+        });
+      });
+    }
     /**
      * Called when a value is updated in the engine.
      *