handsontable 9.0.2 → 11.1.0

package/core.mjs

@@ -1,4 +1,4 @@
-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 _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(); }
 
@@ -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, replaceData } from "./dataMap/index.mjs";
 import { createUniqueMap } from "./utils/dataStructures/uniqueMap.mjs";
 var activeGuid = null;
 /* eslint-disable jsdoc/require-description-complete-sentence */
@@ -110,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();
@@ -128,8 +130,6 @@ export default function Core(rootElement, userSettings) {
 
 
   this.rootElement = rootElement;
-  /* eslint-enable jsdoc/require-description-complete-sentence */
-
   /**
    * The nearest document over container.
    *
@@ -395,8 +395,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.
@@ -675,6 +673,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;
@@ -815,72 +815,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':
@@ -1182,10 +1201,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();
@@ -1206,7 +1221,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 */
@@ -1330,6 +1345,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.
@@ -1341,9 +1358,10 @@ 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.
-     * @private
      */
 
     function done(valid) {
@@ -1564,7 +1582,7 @@ export default function Core(rootElement, userSettings) {
    * Populate cells at position with 2D input array (e.g. `[[1, 2], [3, 4]]`). Use `endRow`, `endCol` when you
    * want to cut input when a certain row is reached.
    *
-   * Optional `method` argument has the same effect as pasteMode option (see {@link options#pastemode Options#pasteMode}).
+   * Optional `method` argument has the same effect as pasteMode option (see {@link Options#pasteMode}).
    *
    * @memberof Core#
    * @function populateFromArray
@@ -1753,7 +1771,7 @@ export default function Core(rootElement, userSettings) {
     }
   };
   /**
-   * Checks if the table rendering process was suspended. See explanation in {@link core#suspendrender Core#suspendRender}.
+   * Checks if the table rendering process was suspended. See explanation in {@link Core#suspendRender}.
    *
    * @memberof Core#
    * @function isRenderSuspended
@@ -1772,8 +1790,8 @@ export default function Core(rootElement, userSettings) {
    * When the table is in the suspend state, most operations will have no visual
    * effect until the rendering state is resumed. Resuming the state automatically
    * invokes the table rendering. To make sure that after executing all operations,
-   * the table will be rendered, it's highly recommended to use the {@link core#batchrender Core#batchRender}
-   * method or {@link core#batch Core#batch}, which additionally aggregates the logic execution
+   * the table will be rendered, it's highly recommended to use the {@link Core#batchRender}
+   * method or {@link Core#batch}, which additionally aggregates the logic execution
    * that happens behind the table.
    *
    * The method is intended to be used by advanced users. Suspending the rendering
@@ -1802,7 +1820,7 @@ export default function Core(rootElement, userSettings) {
     this.renderSuspendedCounter += 1;
   };
   /**
-   * Resumes the rendering process. In combination with the {@link core#suspendrender Core#suspendRender}
+   * Resumes the rendering process. In combination with the {@link Core#suspendRender}
    * method it allows aggregating the table render cycles triggered by API calls or UI
    * actions (or both) and calls the "render" once in the end. When the table is in
    * the suspend state, most operations will have no visual effect until the rendering
@@ -1904,7 +1922,7 @@ export default function Core(rootElement, userSettings) {
   };
   /**
    * Checks if the table indexes recalculation process was suspended. See explanation
-   * in {@link core#suspendexecution Core#suspendExecution}.
+   * in {@link Core#suspendExecution}.
    *
    * @memberof Core#
    * @function isExecutionSuspended
@@ -1946,7 +1964,7 @@ export default function Core(rootElement, userSettings) {
     this.rowIndexMapper.suspendOperations();
   };
   /**
-   * Resumes the execution process. In combination with the {@link core#suspendexecution Core#suspendExecution}
+   * Resumes the execution process. In combination with the {@link Core#suspendExecution}
    * method it allows aggregating the table logic changes after which the cache is
    * updated. Resuming the state automatically invokes the table cache updating process.
    *
@@ -1957,7 +1975,7 @@ export default function Core(rootElement, userSettings) {
    * @function resumeExecution
    * @param {boolean} [forceFlushChanges=false] If `true`, the table internal data cache
    * is recalculated after the execution of the batched operations. For nested
-   * {@link core#batchexecution Core#batchExecution} calls, it can be desire to recalculate the table
+   * {@link Core#batchExecution} calls, it can be desire to recalculate the table
    * after each batch.
    * @since 8.3.0
    * @example
@@ -2112,14 +2130,67 @@ export default function Core(rootElement, userSettings) {
     }, isSizeChanged);
   };
   /**
-   * Loads new data to Handsontable. Loading new data resets the cell meta.
-   * Since 8.0.0 loading new data also resets states corresponding to rows and columns
-   * (for example, row/column sequence, column width, row height, frozen columns etc.).
+   * The `updateData()` method replaces Handsontable's [`data`](@/api/options.md#data) with a new dataset.
+   *
+   * The `updateData()` method:
+   * - Keeps cells' states (e.g. cells' [formatting](@/guides/cell-features/formatting-cells.md) and cells' [`readOnly`](@/api/options.md#readonly) states)
+   * - Keeps rows' states (e.g. row order)
+   * - Keeps columns' states (e.g. column order)
+   *
+   * To replace Handsontable's [`data`](@/api/options.md#data) and reset states, use the [`loadData()`](#loaddata) method.
+   *
+   * Read more:
+   * - [Binding to data &#8594;](@/guides/getting-started/binding-to-data.md)
+   * - [Saving data &#8594;](@/guides/getting-started/saving-data.md)
+   *
+   * @memberof Core#
+   * @function updateData
+   * @since 11.1.0
+   * @param {Array} data An [array of arrays](@/guides/getting-started/binding-to-data.md#array-of-arrays), or an [array of objects](@/guides/getting-started/binding-to-data.md#array-of-objects), that contains Handsontable's data
+   * @param {string} [source] The source of the `updateData()` call
+   * @fires Hooks#beforeUpdateData
+   * @fires Hooks#afterUpdateData
+   * @fires Hooks#afterChange
+   */
+
+
+  this.updateData = function (data, source) {
+    var _this3 = this;
+
+    replaceData(data, function (newDataMap) {
+      datamap = newDataMap;
+    }, function (newDataMap) {
+      datamap = newDataMap;
+      instance.columnIndexMapper.fitToLength(_this3.getInitialColumnCount());
+      instance.rowIndexMapper.fitToLength(_this3.countSourceRows());
+      grid.adjustRowsAndCols();
+    }, {
+      hotInstance: instance,
+      dataMap: datamap,
+      dataSource: dataSource,
+      internalSource: 'updateData',
+      source: source,
+      firstRun: firstRun
+    });
+  };
+  /**
+   * The `loadData()` method replaces Handsontable's [`data`](@/api/options.md#data) with a new dataset.
+   *
+   * Additionally, the `loadData()` method:
+   * - Resets cells' states (e.g. cells' [formatting](@/guides/cell-features/formatting-cells.md) and cells' [`readOnly`](@/api/options.md#readonly) states)
+   * - Resets rows' states (e.g. row order)
+   * - Resets columns' states (e.g. column order)
+   *
+   * To replace Handsontable's [`data`](@/api/options.md#data) without resetting states, use the [`updateData()`](#updatedata) method.
+   *
+   * Read more:
+   * - [Binding to data &#8594;](@/guides/getting-started/binding-to-data.md)
+   * - [Saving data &#8594;](@/guides/getting-started/saving-data.md)
    *
    * @memberof Core#
    * @function loadData
-   * @param {Array} data Array of arrays or array of objects containing data.
-   * @param {string} [source] Source of the loadData call.
+   * @param {Array} data An [array of arrays](@/guides/getting-started/binding-to-data.md#array-of-arrays), or an [array of objects](@/guides/getting-started/binding-to-data.md#array-of-objects), that contains Handsontable's data
+   * @param {string} [source] The source of the `loadData()` call
    * @fires Hooks#beforeLoadData
    * @fires Hooks#afterLoadData
    * @fires Hooks#afterChange
@@ -2127,88 +2198,34 @@ export default function Core(rootElement, userSettings) {
 
 
   this.loadData = function (data, source) {
-    if (Array.isArray(tableMeta.dataSchema)) {
-      instance.dataType = 'array';
-    } else if (isFunction(tableMeta.dataSchema)) {
-      instance.dataType = 'function';
-    } else {
-      instance.dataType = 'object';
-    }
-
-    if (datamap) {
-      datamap.destroy();
-    }
-
-    data = instance.runHooks('beforeLoadData', data, firstRun, source);
-    datamap = new DataMap(instance, data, tableMeta);
-
-    if (_typeof(data) === 'object' && data !== null) {
-      if (!(data.push && data.splice)) {
-        // check if data is array. Must use duck-type check so Backbone Collections also pass it
-        // when data is not an array, attempt to make a single-row array of it
-        // eslint-disable-next-line no-param-reassign
-        data = [data];
-      }
-    } else if (data === null) {
-      var dataSchema = datamap.getSchema(); // eslint-disable-next-line no-param-reassign
-
-      data = [];
-      var row;
-      var r = 0;
-      var rlen = 0;
-
-      for (r = 0, rlen = tableMeta.startRows; r < rlen; r++) {
-        if ((instance.dataType === 'object' || instance.dataType === 'function') && tableMeta.dataSchema) {
-          row = deepClone(dataSchema);
-          data.push(row);
-        } else if (instance.dataType === 'array') {
-          row = deepClone(dataSchema[0]);
-          data.push(row);
-        } else {
-          row = [];
-
-          for (var c = 0, clen = tableMeta.startCols; c < clen; c++) {
-            row.push(null);
-          }
+    replaceData(data, function (newDataMap) {
+      datamap = newDataMap;
+    }, function () {
+      metaManager.clearCellsCache();
+      instance.initIndexMappers();
+      grid.adjustRowsAndCols();
 
-          data.push(row);
-        }
+      if (firstRun) {
+        firstRun = [null, 'loadData'];
       }
-    } else {
-      throw new Error("loadData only accepts array of objects or array of arrays (".concat(_typeof(data), " given)"));
-    }
-
-    if (Array.isArray(data[0])) {
-      instance.dataType = 'array';
-    }
-
-    tableMeta.data = data;
-    datamap.dataSource = data;
-    dataSource.data = data;
-    dataSource.dataType = instance.dataType;
-    dataSource.colToProp = datamap.colToProp.bind(datamap);
-    dataSource.propToCol = datamap.propToCol.bind(datamap);
-    dataSource.countCachedColumns = datamap.countCachedColumns.bind(datamap);
-    metaManager.clearCellsCache();
-    instance.initIndexMappers();
-    grid.adjustRowsAndCols();
-    instance.runHooks('afterLoadData', data, firstRun, source);
-
-    if (firstRun) {
-      firstRun = [null, 'loadData'];
-    } else {
-      instance.runHooks('afterChange', null, 'loadData');
-      instance.render();
-    }
+    }, {
+      hotInstance: instance,
+      dataMap: datamap,
+      dataSource: dataSource,
+      internalSource: 'loadData',
+      source: source,
+      firstRun: firstRun
+    });
   };
   /**
-   * Init index mapper which manage indexes assigned to the data.
+   * Gets the initial column count, calculated based on the `columns` setting.
    *
    * @private
+   * @returns {number} The calculated number of columns.
    */
 
 
-  this.initIndexMappers = function () {
+  this.getInitialColumnCount = function () {
     var columnsSettings = tableMeta.columns;
     var finalNrOfColumns = 0; // We will check number of columns when the `columns` property was defined as an array. Columns option may
     // narrow down or expand displayed dataset in that case.
@@ -2238,13 +2255,23 @@ export default function Core(rootElement, userSettings) {
       finalNrOfColumns = this.countSourceCols();
     }
 
-    this.columnIndexMapper.initToLength(finalNrOfColumns);
+    return finalNrOfColumns;
+  };
+  /**
+   * Init index mapper which manage indexes assigned to the data.
+   *
+   * @private
+   */
+
+
+  this.initIndexMappers = function () {
+    this.columnIndexMapper.initToLength(this.getInitialColumnCount());
     this.rowIndexMapper.initToLength(this.countSourceRows());
   };
   /**
    * Returns the current data object (the same one that was passed by `data` configuration option or `loadData` method,
    * unless some modifications have been applied (i.e. Sequence of rows/columns was changed, some row/column was skipped).
-   * If that's the case - use the {@link core#getsourcedata Core#getSourceData} method.).
+   * If that's the case - use the {@link Core#getSourceData} method.).
    *
    * Optionally you can provide cell range by defining `row`, `column`, `row2`, `column2` to get only a fragment of table data.
    *
@@ -2330,7 +2357,7 @@ export default function Core(rootElement, userSettings) {
    *
    * @memberof Core#
    * @function updateSettings
-   * @param {object} settings New settings object (see {@link options Options}).
+   * @param {object} settings New settings object (see {@link Options}).
    * @param {boolean} [init=false] Internally used for in initialization mode.
    * @example
    * ```js
@@ -2347,6 +2374,12 @@ export default function Core(rootElement, userSettings) {
 
   this.updateSettings = function (settings) {
     var init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    // TODO: uncomment the next line with the next major version update
+    // Do not forget to re-enable the pending tests that cover the change:
+    //  * https://github.com/handsontable/handsontable/blob/9f62c282a1c951b27cd8406aa27105bd32b05bb6/handsontable/test/e2e/core/toPhysicalColumn.spec.js#L70
+    //  * https://github.com/handsontable/handsontable/blob/9f62c282a1c951b27cd8406aa27105bd32b05bb6/handsontable/test/e2e/core/toVisualColumn.spec.js#L70
+    // const dataUpdateFunction = (firstRun ? instance.loadData : instance.updateData).bind(this);
+    var dataUpdateFunction = instance.loadData.bind(this);
     var columnsAsFunc = false;
     var i;
     var j;
@@ -2391,9 +2424,9 @@ export default function Core(rootElement, userSettings) {
 
 
     if (settings.data === void 0 && tableMeta.data === void 0) {
-      instance.loadData(null, 'updateSettings'); // data source created just now
+      dataUpdateFunction(null, 'updateSettings'); // data source created just now
     } else if (settings.data !== void 0) {
-      instance.loadData(settings.data, 'updateSettings'); // data source given as option
+      dataUpdateFunction(settings.data, 'updateSettings'); // data source given as option
     } else if (settings.columns !== void 0) {
       datamap.createMap(); // The `column` property has changed - dataset may be expanded or narrowed down. The `loadData` do the same.
 
@@ -2999,7 +3032,7 @@ export default function Core(rootElement, userSettings) {
   };
   /**
    * @description
-   * Returns a data type defined in the Handsontable settings under the `type` key ({@link options#type Options#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.
@@ -3015,7 +3048,7 @@ export default function Core(rootElement, userSettings) {
 
 
   this.getDataType = function (rowFrom, columnFrom, rowTo, columnTo) {
-    var _this3 = this;
+    var _this4 = this;
 
     var coords = rowFrom === void 0 ? [0, 0, this.countRows(), this.countCols()] : [rowFrom, columnFrom, rowTo, columnTo];
     var rowStart = coords[0],
@@ -3037,7 +3070,7 @@ export default function Core(rootElement, userSettings) {
     rangeEach(Math.max(Math.min(rowStart, rowEnd), 0), Math.max(rowStart, rowEnd), function (row) {
       var isTypeEqual = true;
       rangeEach(Math.max(Math.min(columnStart, columnEnd), 0), Math.max(columnStart, columnEnd), function (column) {
-        var cellType = _this3.getCellMeta(row, column);
+        var cellType = _this4.getCellMeta(row, column);
 
         currentType = cellType.type;
 
@@ -3071,7 +3104,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) {
@@ -3094,7 +3127,7 @@ export default function Core(rootElement, userSettings) {
 
 
   this.spliceCellsMeta = function (visualIndex) {
-    var _this4 = this;
+    var _this5 = this;
 
     var deleteAmount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
 
@@ -3112,12 +3145,14 @@ export default function Core(rootElement, userSettings) {
 
     if (cellMetaRows.length > 0) {
       arrayEach(cellMetaRows.reverse(), function (cellMetaRow) {
-        metaManager.createRow(_this4.toPhysicalRow(visualIndex));
+        metaManager.createRow(_this5.toPhysicalRow(visualIndex));
         arrayEach(cellMetaRow, function (cellMeta, columnIndex) {
-          return _this4.setCellMetaObject(visualIndex, columnIndex, cellMeta);
+          return _this5.setCellMetaObject(visualIndex, columnIndex, cellMeta);
         });
       });
     }
+
+    instance.render();
   };
   /**
    * Set cell meta data object defined by `prop` to the corresponding params `row` and `column`.
@@ -3131,11 +3166,11 @@ export default function Core(rootElement, userSettings) {
 
 
   this.setCellMetaObject = function (row, column, prop) {
-    var _this5 = this;
+    var _this6 = this;
 
     if (_typeof(prop) === 'object') {
       objectEach(prop, function (value, key) {
-        _this5.setCellMeta(row, column, key, value);
+        _this6.setCellMeta(row, column, key, value);
       });
     }
   };
@@ -3211,33 +3246,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.
@@ -3271,7 +3283,7 @@ export default function Core(rootElement, userSettings) {
    *
    * @memberof Core#
    * @function getCellRenderer
-   * @param {number|object} row Visual row index or cell meta object (see {@link core#getcellmeta Core#getCellMeta}).
+   * @param {number|object} row Visual row index or cell meta object (see {@link Core#getCellMeta}).
    * @param {number} column Visual column index.
    * @returns {Function} The renderer function.
    * @example
@@ -3291,7 +3303,7 @@ export default function Core(rootElement, userSettings) {
    *
    * @memberof Core#
    * @function getCellEditor
-   * @param {number} row Visual row index or cell meta object (see {@link core#getcellmeta Core#getCellMeta}).
+   * @param {number} row Visual row index or cell meta object (see {@link Core#getCellMeta}).
    * @param {number} column Visual column index.
    * @returns {Function} The editor class.
    * @example
@@ -3311,7 +3323,7 @@ export default function Core(rootElement, userSettings) {
    *
    * @memberof Core#
    * @function getCellValidator
-   * @param {number|object} row Visual row index or cell meta object (see {@link core#getcellmeta Core#getCellMeta}).
+   * @param {number|object} row Visual row index or cell meta object (see {@link Core#getCellMeta}).
    * @param {number} column Visual column index.
    * @returns {Function|RegExp|undefined} The validator function.
    * @example
@@ -3711,6 +3723,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.
@@ -4307,7 +4321,7 @@ export default function Core(rootElement, userSettings) {
    * @memberof Core#
    * @function addHook
    * @see Hooks#add
-   * @param {string} key Hook name (see {@link hooks Hooks}).
+   * @param {string} key Hook name (see {@link Hooks}).
    * @param {Function|Array} callback Function or array of functions.
    * @example
    * ```js
@@ -4321,7 +4335,7 @@ export default function Core(rootElement, userSettings) {
   };
   /**
    * Check if for a specified hook name there are added listeners (only for this Handsontable instance). All available
-   * hooks you will find {@link hooks Hooks}.
+   * hooks you will find {@link Hooks}.
    *
    * @memberof Core#
    * @function hasHook
@@ -4346,7 +4360,7 @@ export default function Core(rootElement, userSettings) {
    * @memberof Core#
    * @function addHookOnce
    * @see Hooks#once
-   * @param {string} key Hook name (see {@link hooks Hooks}).
+   * @param {string} key Hook name (see {@link Hooks}).
    * @param {Function|Array} callback Function or array of functions.
    * @example
    * ```js
@@ -4359,13 +4373,13 @@ export default function Core(rootElement, userSettings) {
     Hooks.getSingleton().once(key, callback, instance);
   };
   /**
-   * Removes the hook listener previously registered with {@link core#addhook Core#addHook}.
+   * Removes the hook listener previously registered with {@link Core#addHook}.
    *
    * @memberof Core#
    * @function removeHook
    * @see Hooks#remove
    * @param {string} key Hook name.
-   * @param {Function} callback Reference to the function which has been registered using {@link core#addhook Core#addHook}.
+   * @param {Function} callback Reference to the function which has been registered using {@link Core#addHook}.
    *
    * @example
    * ```js
@@ -4525,6 +4539,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);