handsontable 9.0.1 → 11.0.1

package/core.mjs

@@ -4,7 +4,7 @@ function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArra
 
 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."); }
 
-function _iterableToArrayLimit(arr, i) { var _i = arr && (typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]); if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
 
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 
@@ -12,23 +12,25 @@ import "core-js/modules/es.array.sort.js";
 import "core-js/modules/es.array.splice.js";
 import "core-js/modules/es.number.is-integer.js";
 import "core-js/modules/es.number.constructor.js";
+import "core-js/modules/es.array.slice.js";
+import "core-js/modules/es.array.concat.js";
+import "core-js/modules/es.array.fill.js";
+import "core-js/modules/es.array.map.js";
 import "core-js/modules/es.regexp.exec.js";
 import "core-js/modules/es.string.replace.js";
-import "core-js/modules/es.array.concat.js";
 import "core-js/modules/es.array.from.js";
 import "core-js/modules/es.string.iterator.js";
 import "core-js/modules/es.array.index-of.js";
 import "core-js/modules/es.array.reverse.js";
+import "core-js/modules/es.object.to-string.js";
 import "core-js/modules/web.dom-collections.for-each.js";
 import "core-js/modules/web.timers.js";
 import "core-js/modules/web.immediate.js";
 import "core-js/modules/es.symbol.js";
 import "core-js/modules/es.symbol.description.js";
-import "core-js/modules/es.object.to-string.js";
 import "core-js/modules/es.symbol.iterator.js";
 import "core-js/modules/es.array.iterator.js";
 import "core-js/modules/web.dom-collections.iterator.js";
-import "core-js/modules/es.array.slice.js";
 import "core-js/modules/es.function.name.js";
 
 function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
@@ -49,17 +51,17 @@ import { isDefined, isUndefined, isRegExp, _injectProductInfo, isEmpty } from ".
 import { isMobileBrowser, isIpadOS } from "./helpers/browser.mjs";
 import EditorManager from "./editorManager.mjs";
 import EventManager from "./eventManager.mjs";
-import { deepClone, duckSchema, isObjectEqual, deepObjectSize, hasOwnProperty, createObjectPropListener, objectEach } from "./helpers/object.mjs";
-import { arrayMap, arrayEach, arrayReduce, getDifferenceOfArrays, stringToArray } from "./helpers/array.mjs";
+import { deepClone, duckSchema, isObjectEqual, isObject, deepObjectSize, hasOwnProperty, createObjectPropListener, objectEach } from "./helpers/object.mjs";
+import { arrayMap, arrayEach, arrayReduce, getDifferenceOfArrays, stringToArray, pivot } from "./helpers/array.mjs";
 import { instanceToHTML } from "./utils/parseTable.mjs";
 import { getPlugin, getPluginsNames } from "./plugins/registry.mjs";
 import { getRenderer } from "./renderers/registry.mjs";
 import { getValidator } from "./validators/registry.mjs";
 import { randomString, toUpperCaseFirst } from "./helpers/string.mjs";
-import { rangeEach, rangeEachReverse } from "./helpers/number.mjs";
+import { rangeEach, rangeEachReverse, isNumericLike } from "./helpers/number.mjs";
 import TableView from "./tableView.mjs";
 import DataSource from "./dataSource.mjs";
-import { translateRowsToColumns, cellMethodLookupFactory, spreadsheetColumnLabel } from "./helpers/data.mjs";
+import { cellMethodLookupFactory, spreadsheetColumnLabel } from "./helpers/data.mjs";
 import { IndexMapper } from "./translations/index.mjs";
 import { registerAsRootInstance, hasValidParameter, isRootInstance } from "./utils/rootInstance.mjs";
 import { CellCoords, ViewportColumnsCalculator } from "./3rdparty/walkontable/src/index.mjs";
@@ -68,7 +70,7 @@ import { hasLanguageDictionary, getValidLanguageCode, getTranslatedPhrase } from
 import { warnUserAboutLanguageRegistration, normalizeLanguageCode } from "./i18n/utils.mjs";
 import { startObserving as keyStateStartObserving, stopObserving as keyStateStopObserving } from "./utils/keyStateObserver.mjs";
 import { Selection } from "./selection/index.mjs";
-import { MetaManager, DataMap } from "./dataMap/index.mjs";
+import { MetaManager, DynamicCellMetaMod, DataMap } from "./dataMap/index.mjs";
 import { createUniqueMap } from "./utils/dataStructures/uniqueMap.mjs";
 var activeGuid = null;
 /* eslint-disable jsdoc/require-description-complete-sentence */
@@ -79,25 +81,19 @@ var activeGuid = null;
  * @core
  * @class Core
  * @description
- * After Handsontable is constructed, you can modify the grid behavior using the available public methods.
  *
- * ## How to call methods.
+ * The `Handsontable` class to which we refer as to `Core`, allows you to modify the grid's behavior by using one of the available public methods.
  *
- * These are 2 equal ways to call a Handsontable method:
+ * ## How to call a method
  *
  * ```js
- * // all following examples assume that you constructed Handsontable like this
- * const hot = new Handsontable(document.getElementById('example1'), options);
+ * // First, let's contruct Handsontable
+ * const hot = new Handsontable(document.getElementById('example'), options);
  *
- * // now, to use setDataAtCell method, you can either:
+ * // Then, let's use the setDataAtCell method
  * hot.setDataAtCell(0, 0, 'new value');
  * ```
  *
- * Alternatively, you can call the method using jQuery wrapper (__obsolete__, requires initialization using our jQuery guide
- * ```js
- * $('#example1').handsontable('setDataAtCell', 0, 0, 'new value');
- * ```
- *
  * @param {HTMLElement} rootElement The element to which the Handsontable instance is injected.
  * @param {object} userSettings The user defined options.
  * @param {boolean} [rootInstanceSymbol=false] Indicates if the instance is root of all later instances created.
@@ -116,7 +112,7 @@ export default function Core(rootElement, userSettings) {
   var editorManager;
   var firstRun = true;
   userSettings.language = getValidLanguageCode(userSettings.language);
-  var metaManager = new MetaManager(userSettings);
+  var metaManager = new MetaManager(instance, userSettings, [DynamicCellMetaMod]);
   var tableMeta = metaManager.getTableMeta();
   var globalMeta = metaManager.getGlobalMeta();
   var pluginsRegistry = createUniqueMap();
@@ -401,8 +397,6 @@ export default function Core(rootElement, userSettings) {
     /**
      * Inserts or removes rows and columns.
      *
-     * @memberof Core#
-     * @function alter
      * @private
      * @param {string} action Possible values: "insert_row", "insert_col", "remove_row", "remove_col".
      * @param {number|Array} index Row or column visual index which from the alter action will be triggered.
@@ -681,6 +675,8 @@ export default function Core(rootElement, userSettings) {
 
     /**
      * Makes sure there are empty rows at the bottom of the table.
+     *
+     * @private
      */
     adjustRowsAndCols: function adjustRowsAndCols() {
       var minRows = tableMeta.minRows;
@@ -821,72 +817,91 @@ export default function Core(rootElement, userSettings) {
       var clen;
       var setData = [];
       var current = {};
+      var newDataByColumns = [];
+      var startRow = start.row;
+      var startColumn = start.col;
       rlen = input.length;
 
       if (rlen === 0) {
         return false;
       }
 
-      var repeatCol;
-      var repeatRow;
-      var cmax;
-      var rmax;
-      /* eslint-disable no-case-declarations */
-      // insert data with specified pasteMode method
+      var columnsPopulationEnd = 0;
+      var rowsPopulationEnd = 0;
+
+      if (isObject(end)) {
+        columnsPopulationEnd = end.col - startColumn + 1;
+        rowsPopulationEnd = end.row - startRow + 1;
+      } // insert data with specified pasteMode method
+
 
       switch (method) {
         case 'shift_down':
-          repeatCol = end ? end.col - start.col + 1 : 0;
-          repeatRow = end ? end.row - start.row + 1 : 0; // eslint-disable-next-line no-param-reassign
+          // translate data from a list of rows to a list of columns
+          var populatedDataByColumns = pivot(input);
+          var numberOfDataColumns = populatedDataByColumns.length; // method's argument can extend the range of data population (data would be repeated)
 
-          input = translateRowsToColumns(input);
+          var numberOfColumnsToPopulate = Math.max(numberOfDataColumns, columnsPopulationEnd);
+          var pushedDownDataByRows = instance.getData().slice(startRow); // translate data from a list of rows to a list of columns
 
-          for (c = 0, clen = input.length, cmax = Math.max(clen, repeatCol); c < cmax; c++) {
-            if (c < clen) {
-              var _instance;
+          var pushedDownDataByColumns = pivot(pushedDownDataByRows).slice(startColumn, startColumn + numberOfColumnsToPopulate);
 
-              for (r = 0, rlen = input[c].length; r < repeatRow - rlen; r++) {
-                input[c].push(input[c][r % rlen]);
+          for (c = 0; c < numberOfColumnsToPopulate; c += 1) {
+            if (c < numberOfDataColumns) {
+              for (r = 0, rlen = populatedDataByColumns[c].length; r < rowsPopulationEnd - rlen; r += 1) {
+                // repeating data for rows
+                populatedDataByColumns[c].push(populatedDataByColumns[c][r % rlen]);
               }
 
-              input[c].unshift(start.col + c, start.row, 0);
-
-              (_instance = instance).spliceCol.apply(_instance, _toConsumableArray(input[c]));
+              if (c < pushedDownDataByColumns.length) {
+                newDataByColumns.push(populatedDataByColumns[c].concat(pushedDownDataByColumns[c]));
+              } else {
+                // if before data population, there was no data in the column
+                // we fill the required rows' newly-created cells with `null` values
+                newDataByColumns.push(populatedDataByColumns[c].concat(new Array(pushedDownDataByRows.length).fill(null)));
+              }
             } else {
-              var _instance2;
-
-              input[c % clen][0] = start.col + c;
-
-              (_instance2 = instance).spliceCol.apply(_instance2, _toConsumableArray(input[c % clen]));
+              // Repeating data for columns.
+              newDataByColumns.push(populatedDataByColumns[c % numberOfDataColumns].concat(pushedDownDataByColumns[c]));
             }
           }
 
+          instance.populateFromArray(startRow, startColumn, pivot(newDataByColumns));
           break;
 
         case 'shift_right':
-          repeatCol = end ? end.col - start.col + 1 : 0;
-          repeatRow = end ? end.row - start.row + 1 : 0;
+          var numberOfDataRows = input.length; // method's argument can extend the range of data population (data would be repeated)
 
-          for (r = 0, rlen = input.length, rmax = Math.max(rlen, repeatRow); r < rmax; r++) {
-            if (r < rlen) {
-              var _instance3;
+          var numberOfRowsToPopulate = Math.max(numberOfDataRows, rowsPopulationEnd);
+          var pushedRightDataByRows = instance.getData().slice(startRow).map(function (rowData) {
+            return rowData.slice(startColumn);
+          });
 
-              for (c = 0, clen = input[r].length; c < repeatCol - clen; c++) {
+          for (r = 0; r < numberOfRowsToPopulate; r += 1) {
+            if (r < numberOfDataRows) {
+              for (c = 0, clen = input[r].length; c < columnsPopulationEnd - clen; c += 1) {
+                // repeating data for rows
                 input[r].push(input[r][c % clen]);
               }
 
-              input[r].unshift(start.row + r, start.col, 0);
+              if (r < pushedRightDataByRows.length) {
+                for (var i = 0; i < pushedRightDataByRows[r].length; i += 1) {
+                  input[r].push(pushedRightDataByRows[r][i]);
+                }
+              } else {
+                var _input$r;
 
-              (_instance3 = instance).spliceRow.apply(_instance3, _toConsumableArray(input[r]));
+                // if before data population, there was no data in the row
+                // we fill the required columns' newly-created cells with `null` values
+                (_input$r = input[r]).push.apply(_input$r, _toConsumableArray(new Array(pushedRightDataByRows[0].length).fill(null)));
+              }
             } else {
-              var _instance4;
-
-              input[r % rlen][0] = start.row + r;
-
-              (_instance4 = instance).spliceRow.apply(_instance4, _toConsumableArray(input[r % rlen]));
+              // Repeating data for columns.
+              input.push(input[r % rlen].slice(0, numberOfRowsToPopulate).concat(pushedRightDataByRows[r]));
             }
           }
 
+          instance.populateFromArray(startRow, startColumn, input);
           break;
 
         case 'overwrite':
@@ -1188,10 +1203,6 @@ export default function Core(rootElement, userSettings) {
 
     var waitingForValidator = new ValidatorsQueue();
 
-    var isNumericData = function isNumericData(value) {
-      return value.length > 0 && /^\s*[+-.]?\s*(?:(?:\d+(?:(\.|,)\d+)?(?:e[+-]?\d+)?)|(?:0x[a-f\d]+))\s*$/.test(value);
-    };
-
     waitingForValidator.onQueueEmpty = function (isValid) {
       if (activeEditor && shouldBeCanceled) {
         activeEditor.cancelChanges();
@@ -1212,7 +1223,7 @@ export default function Core(rootElement, userSettings) {
         var col = datamap.propToCol(prop);
         var cellProperties = instance.getCellMeta(row, col);
 
-        if (cellProperties.type === 'numeric' && typeof newValue === 'string' && isNumericData(newValue)) {
+        if (cellProperties.type === 'numeric' && typeof newValue === 'string' && isNumericLike(newValue)) {
           changes[i][3] = getParsedNumber(newValue);
         }
         /* eslint-disable no-loop-func */
@@ -1336,6 +1347,8 @@ export default function Core(rootElement, userSettings) {
   /**
    * Validate a single cell.
    *
+   * @memberof Core#
+   * @function validateCell
    * @param {string|number} value The value to validate.
    * @param {object} cellProperties The cell meta which corresponds with the value.
    * @param {Function} callback The callback function.
@@ -1347,6 +1360,8 @@ export default function Core(rootElement, userSettings) {
     var validator = instance.getCellValidator(cellProperties); // the `canBeValidated = false` argument suggests, that the cell passes validation by default.
 
     /**
+     * @private
+     * @function done
      * @param {boolean} valid Indicates if the validation was successful.
      * @param {boolean} [canBeValidated=true] Flag which controls the validation process.
      */
@@ -1596,7 +1611,7 @@ export default function Core(rootElement, userSettings) {
     return grid.populateFromArray(new CellCoords(row, column), input, c, source, method, direction, deltas);
   };
   /**
-   * Adds/removes data from the column. This method works the same as Array.splice for arrays (see {@link DataMap#spliceCol}).
+   * Adds/removes data from the column. This method works the same as Array.splice for arrays.
    *
    * @memberof Core#
    * @function spliceCol
@@ -1618,7 +1633,7 @@ export default function Core(rootElement, userSettings) {
     return (_datamap = datamap).spliceCol.apply(_datamap, [column, index, amount].concat(elements));
   };
   /**
-   * Adds/removes data from the row. This method works the same as Array.splice for arrays (see {@link DataMap#spliceRow}).
+   * Adds/removes data from the row. This method works the same as Array.splice for arrays.
    *
    * @memberof Core#
    * @function spliceRow
@@ -2281,7 +2296,7 @@ export default function Core(rootElement, userSettings) {
   };
   /**
    * Returns a string value of the selected range. Each column is separated by tab, each row is separated by a new
-   * line character (see {@link DataMap#getCopyableText}).
+   * line character.
    *
    * @memberof Core#
    * @function getCopyableText
@@ -2297,7 +2312,7 @@ export default function Core(rootElement, userSettings) {
     return datamap.getCopyableText(new CellCoords(startRow, startCol), new CellCoords(endRow, endCol));
   };
   /**
-   * Returns the data's copyable value at specified `row` and `column` index (see {@link DataMap#getCopyable}).
+   * Returns the data's copyable value at specified `row` and `column` index.
    *
    * @memberof Core#
    * @function getCopyableData
@@ -2501,6 +2516,7 @@ export default function Core(rootElement, userSettings) {
 
       instance._refreshBorders(null);
 
+      instance.view.wt.wtOverlays.adjustElementsSize();
       editorManager.unlockEditor();
     }
 
@@ -2561,10 +2577,12 @@ export default function Core(rootElement, userSettings) {
    * @memberof Core#
    * @function alter
    * @param {string} action Possible alter operations:
-   *  * `'insert_row'`
-   *  * `'insert_col'`
-   *  * `'remove_row'`
-   *  * `'remove_col'`.
+   *  <ul>
+   *    <li> `'insert_row'` </li>
+   *    <li> `'insert_col'` </li>
+   *    <li> `'remove_row'` </li>
+   *    <li> `'remove_col'` </li>
+   * </ul>.
    * @param {number|number[]} index Visual index of the row/column before which the new row/column will be
    *                                inserted/removed or an array of arrays in format `[[index, amount],...]`.
    * @param {number} [amount=1] Amount of rows/columns to be inserted or removed.
@@ -2667,7 +2685,7 @@ export default function Core(rootElement, userSettings) {
     return new CellCoords(visualRow, visualColumn);
   };
   /**
-   * Returns the property name that corresponds with the given column index (see {@link DataMap#colToProp}).
+   * Returns the property name that corresponds with the given column index.
    * If the data source is an array of arrays, it returns the columns index.
    *
    * @memberof Core#
@@ -2681,7 +2699,7 @@ export default function Core(rootElement, userSettings) {
     return datamap.colToProp(column);
   };
   /**
-   * Returns column index that corresponds with the given property (see {@link DataMap#propToCol}).
+   * Returns column index that corresponds with the given property.
    *
    * @memberof Core#
    * @function propToCol
@@ -2775,7 +2793,7 @@ export default function Core(rootElement, userSettings) {
     return datamap.get(row, datamap.colToProp(column));
   };
   /**
-   * Returns value at visual `row` and `prop` indexes (see {@link DataMap#get}).
+   * Returns value at visual `row` and `prop` indexes.
    *
    * __Note__: If data is reordered, sorted or trimmed, the currently visible order will be used.
    *
@@ -3001,7 +3019,7 @@ export default function Core(rootElement, userSettings) {
   };
   /**
    * @description
-   * Returns a data type defined in the Handsontable settings under the `type` key ([Options#type](https://handsontable.com/docs/Options.html#type)).
+   * Returns a data type defined in the Handsontable settings under the `type` key ({@link Options#type}).
    * If there are cells with different types in the selected range, it returns `'mixed'`.
    *
    * __Note__: If data is reordered, sorted or trimmed, the currently visible order will be used.
@@ -3073,7 +3091,7 @@ export default function Core(rootElement, userSettings) {
     var _ref19 = [this.toPhysicalRow(row), this.toPhysicalColumn(column)],
         physicalRow = _ref19[0],
         physicalColumn = _ref19[1];
-    var cachedValue = metaManager.getCellMeta(physicalRow, physicalColumn, key);
+    var cachedValue = metaManager.getCellMetaKeyValue(physicalRow, physicalColumn, key);
     var hookResult = instance.runHooks('beforeRemoveCellMeta', row, column, key, cachedValue);
 
     if (hookResult !== false) {
@@ -3120,6 +3138,8 @@ export default function Core(rootElement, userSettings) {
         });
       });
     }
+
+    instance.render();
   };
   /**
    * Set cell meta data object defined by `prop` to the corresponding params `row` and `column`.
@@ -3213,33 +3233,10 @@ export default function Core(rootElement, userSettings) {
       physicalColumn = column;
     }
 
-    var prop = datamap.colToProp(column);
-    var cellProperties = metaManager.getCellMeta(physicalRow, physicalColumn); // TODO(perf): Add assigning this props and executing below code only once per table render cycle.
-
-    cellProperties.row = physicalRow;
-    cellProperties.col = physicalColumn;
-    cellProperties.visualRow = row;
-    cellProperties.visualCol = column;
-    cellProperties.prop = prop;
-    cellProperties.instance = instance;
-    instance.runHooks('beforeGetCellMeta', row, column, cellProperties); // for `type` added or changed in beforeGetCellMeta
-
-    if (instance.hasHook('beforeGetCellMeta') && hasOwnProperty(cellProperties, 'type')) {
-      metaManager.updateCellMeta(physicalRow, physicalColumn, {
-        type: cellProperties.type
-      });
-    }
-
-    if (cellProperties.cells) {
-      var settings = cellProperties.cells(physicalRow, physicalColumn, prop);
-
-      if (settings) {
-        metaManager.updateCellMeta(physicalRow, physicalColumn, settings);
-      }
-    }
-
-    instance.runHooks('afterGetCellMeta', row, column, cellProperties);
-    return cellProperties;
+    return metaManager.getCellMeta(physicalRow, physicalColumn, {
+      visualRow: row,
+      visualColumn: column
+    });
   };
   /**
    * Returns an array of cell meta objects for specified physical row index.
@@ -3713,6 +3710,8 @@ export default function Core(rootElement, userSettings) {
   /**
    * Returns the row height.
    *
+   * Mind that this method is different from the [AutoRowSize](@/api/autoRowSize.md) plugin's [`getRowHeight()`](@/api/autoRowSize.md#getrowheight) method.
+   *
    * @memberof Core#
    * @function getRowHeight
    * @param {number} row Visual row index.
@@ -4527,6 +4526,45 @@ export default function Core(rootElement, userSettings) {
       editorManager.prepareEditor();
     }
   };
+  /**
+   * Check if currently it is RTL direction.
+   *
+   * @private
+   * @memberof Core#
+   * @function isRtl
+   * @returns {boolean} True if RTL.
+   */
+
+
+  this.isRtl = function () {
+    return instance.rootWindow.getComputedStyle(instance.rootElement).direction === 'rtl';
+  };
+  /**
+   * Check if currently it is LTR direction.
+   *
+   * @private
+   * @memberof Core#
+   * @function isLtr
+   * @returns {boolean} True if LTR.
+   */
+
+
+  this.isLtr = function () {
+    return !instance.isRtl();
+  };
+  /**
+   * Returns 1 for LTR; -1 for RTL. Useful for calculations.
+   *
+   * @private
+   * @memberof Core#
+   * @function getDirectionFactor
+   * @returns {number} Returns 1 for LTR; -1 for RTL.
+   */
+
+
+  this.getDirectionFactor = function () {
+    return instance.isLtr() ? 1 : -1;
+  };
 
   getPluginsNames().forEach(function (pluginName) {
     var PluginClass = getPlugin(pluginName);

package/{dataMap.js → dataMap/dataMap.js}

@@ -39,17 +39,17 @@ require("core-js/modules/es.regexp.exec.js");
 
 require("core-js/modules/es.string.split.js");
 
-var _SheetClip = require("./3rdparty/SheetClip");
+var _SheetClip = require("../3rdparty/SheetClip");
 
-var _data = require("./helpers/data");
+var _data = require("../helpers/data");
 
-var _object = require("./helpers/object");
+var _object = require("../helpers/object");
 
-var _array = require("./helpers/array");
+var _array = require("../helpers/array");
 
-var _number = require("./helpers/number");
+var _number = require("../helpers/number");
 
-var _mixed = require("./helpers/mixed");
+var _mixed = require("../helpers/mixed");
 
 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); }
 
@@ -60,13 +60,34 @@ function _defineProperties(target, props) { for (var i = 0; i < props.length; i+
 function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
 
 var copyableLookup = (0, _data.cellMethodLookupFactory)('copyable', false);
+/*
+This class contains open-source contributions covered by the MIT license.
+
+1) In the `createRow` method: Row creation using functional `dataSchema` value
+2) In the `set` method: Data setting using functional `prop` value
+3) in the `get` method: Data getting using functional `prop` value
+
+The remaining part of this code comment contains the full license text of these contributions.
+
+======
+
+The MIT License
+
+Copyright 2013 Nicholas Bollweg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
 /**
  * Utility class that gets and saves data from/to the data source using mapping of columns numbers to object property names.
  *
  * @todo Refactor arguments of methods getRange, getText to be numbers (not objects).
  * @todo Remove priv, GridSettings from object constructor.
  *
- * @util
  * @class DataMap
  * @private
  */
@@ -480,18 +501,11 @@ var DataMap = /*#__PURE__*/function () {
 
       if (actionWasNotCancelled === false) {
         return false;
-      }
+      } // List of removed indexes might be changed in the `beforeRemoveRow` hook. There may be new values.
 
-      var data = this.dataSource; // List of removed indexes might be changed in the `beforeRemoveRow` hook. There may be new values.
 
       var numberOfRemovedIndexes = removedPhysicalIndexes.length;
-      var newData = this.filterData(rowIndex, numberOfRemovedIndexes, removedPhysicalIndexes);
-
-      if (newData) {
-        data.length = 0;
-        Array.prototype.push.apply(data, newData);
-      } // TODO: Function `removeRow` should validate fully, probably above.
-
+      this.filterData(rowIndex, numberOfRemovedIndexes, removedPhysicalIndexes); // TODO: Function `removeRow` should validate fully, probably above.
 
       if (rowIndex < this.instance.countRows()) {
         this.instance.rowIndexMapper.removeIndexes(removedPhysicalIndexes);
@@ -672,20 +686,22 @@ var DataMap = /*#__PURE__*/function () {
      * @param {number} index Visual index of the element to remove.
      * @param {number} amount Number of rows to add/remove.
      * @param {number} physicalRows Physical row indexes.
-     * @returns {Array}
      */
 
   }, {
     key: "filterData",
     value: function filterData(index, amount, physicalRows) {
-      var continueSplicing = this.instance.runHooks('beforeDataFilter', index, amount, physicalRows);
+      // Custom data filtering (run as a consequence of calling the below hook) provide an array containing new data.
+      var data = this.instance.runHooks('filterData', index, amount, physicalRows); // Hooks by default returns first argument (when there is no callback changing execution result).
 
-      if (continueSplicing !== false) {
-        var newData = this.dataSource.filter(function (row, rowIndex) {
+      if (Array.isArray(data) === false) {
+        data = this.dataSource.filter(function (row, rowIndex) {
           return physicalRows.indexOf(rowIndex) === -1;
         });
-        return newData;
       }
+
+      this.dataSource.length = 0;
+      Array.prototype.push.apply(this.dataSource, data);
     }
     /**
      * Returns single value from the data array.
@@ -726,19 +742,6 @@ var DataMap = /*#__PURE__*/function () {
 
         value = out;
       } else if (typeof prop === 'function') {
-        /**
-         *  Allows for interacting with complex structures, for example
-         *  d3/jQuery getter/setter properties:
-         *
-         *    {columns: [{
-         *      data: function(row, value){
-         *        if(arguments.length === 1){
-         *          return row.property();
-         *        }
-         *        row.property(value);
-         *      }
-         *    }]}.
-         */
         value = prop(this.dataSource.slice(physicalRow, physicalRow + 1)[0]);
       }
 
@@ -816,7 +819,6 @@ var DataMap = /*#__PURE__*/function () {
 
         out[sliced[i]] = newValue;
       } else if (typeof prop === 'function') {
-        /* see the `function` handler in `get` */
         prop(this.dataSource.slice(physicalRow, physicalRow + 1)[0], newValue);
       } else {
         dataRow[prop] = newValue;