handsontable 12.1.3 → 12.3.0-next-bb1a7c2-20221208

package/dataMap/dataMap.mjs

@@ -1,17 +1,10 @@
 function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-
 function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
 function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
-
 function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
 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); }
-
 import "core-js/modules/es.array.iterator.js";
 import "core-js/modules/es.map.js";
 import "core-js/modules/es.object.to-string.js";
@@ -22,30 +15,29 @@ import "core-js/modules/es.number.constructor.js";
 import "core-js/modules/es.array.splice.js";
 import "core-js/modules/es.array.sort.js";
 import "core-js/modules/es.array.slice.js";
-import "core-js/modules/es.array.concat.js";
 import "core-js/modules/web.dom-collections.for-each.js";
+import "core-js/modules/es.array.concat.js";
 import "core-js/modules/es.array.filter.js";
 import "core-js/modules/es.array.index-of.js";
+import "core-js/modules/es.symbol.to-primitive.js";
+import "core-js/modules/es.date.to-primitive.js";
 import "core-js/modules/es.symbol.js";
 import "core-js/modules/es.symbol.description.js";
 import "core-js/modules/es.symbol.iterator.js";
 import "core-js/modules/es.array.from.js";
 import "core-js/modules/es.function.name.js";
 import "core-js/modules/es.regexp.exec.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 _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
 function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
 import { stringify } from "../3rdparty/SheetClip/index.mjs";
-import { cellMethodLookupFactory, countFirstRowKeys as _countFirstRowKeys } from "../helpers/data.mjs";
+import { countFirstRowKeys as _countFirstRowKeys } from "../helpers/data.mjs";
 import { createObjectPropListener, deepClone, deepExtend, deepObjectSize, duckSchema, hasOwnProperty, isObject, objectEach } from "../helpers/object.mjs";
 import { extendArray, to2dArray } from "../helpers/array.mjs";
 import { rangeEach } from "../helpers/number.mjs";
 import { isDefined } from "../helpers/mixed.mjs";
-var copyableLookup = cellMethodLookupFactory('copyable', false);
 /*
 This class contains open-source contributions covered by the MIT license.
 
@@ -67,7 +59,6 @@ The above copyright notice and this permission notice shall be included in all c
 
 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.
  *
@@ -77,16 +68,14 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
  * @class DataMap
  * @private
  */
-
 var DataMap = /*#__PURE__*/function () {
   /**
    * @param {object} instance Instance of Handsontable.
    * @param {Array} data Array of arrays or array of objects containing data.
-   * @param {TableMeta} tableMeta The table meta instance.
+   * @param {MetaManager} metaManager The meta manager instance.
    */
-  function DataMap(instance, data, tableMeta) {
+  function DataMap(instance, data, metaManager) {
     _classCallCheck(this, DataMap);
-
     /**
      * Instance of {@link Handsontable}.
      *
@@ -94,68 +83,65 @@ var DataMap = /*#__PURE__*/function () {
      * @type {Handsontable}
      */
     this.instance = instance;
+    /**
+     * Instance of {@link MetaManager}.
+     *
+     * @private
+     * @type {MetaManager}
+     */
+    this.metaManager = metaManager;
     /**
      * Instance of {@link TableMeta}.
      *
      * @private
      * @type {TableMeta}
      */
-
-    this.tableMeta = tableMeta;
+    this.tableMeta = metaManager.getTableMeta();
     /**
      * Reference to the original dataset.
      *
      * @type {*}
      */
-
     this.dataSource = data;
     /**
      * Generated schema based on the first row from the source data.
      *
      * @type {object}
      */
-
-    this.duckSchema = this.dataSource && this.dataSource[0] ? duckSchema(this.dataSource[0]) : {};
+    this.duckSchema = this.createDuckSchema();
     /**
      * Cached array of properties to columns.
      *
      * @type {Array}
      */
-
     this.colToPropCache = void 0;
     /**
      * Cached map of properties to columns.
      *
      * @type {Map}
      */
-
     this.propToColCache = void 0;
     this.createMap();
   }
+
   /**
    * Generates cache for property to and from column addressation.
    */
-
-
   _createClass(DataMap, [{
     key: "createMap",
     value: function createMap() {
       var schema = this.getSchema();
-
       if (typeof schema === 'undefined') {
         throw new Error('trying to create `columns` definition but you didn\'t provide `schema` nor `data`');
       }
-
       var columns = this.tableMeta.columns;
       var i;
       this.colToPropCache = [];
       this.propToColCache = new Map();
-
       if (columns) {
         var columnsLen = 0;
         var filteredIndex = 0;
         var columnsAsFunc = false;
-
         if (typeof columns === 'function') {
           var schemaLen = deepObjectSize(schema);
           columnsLen = schemaLen > 0 ? schemaLen : this.countFirstRowKeys();
@@ -164,17 +150,14 @@ var DataMap = /*#__PURE__*/function () {
           var maxCols = this.tableMeta.maxCols;
           columnsLen = Math.min(maxCols, columns.length);
         }
-
         for (i = 0; i < columnsLen; i++) {
           var column = columnsAsFunc ? columns(i) : columns[i];
-
           if (isObject(column)) {
             if (typeof column.data !== 'undefined') {
               var index = columnsAsFunc ? filteredIndex : i;
               this.colToPropCache[index] = column.data;
               this.propToColCache.set(column.data, index);
             }
-
             filteredIndex += 1;
           }
         }
@@ -182,17 +165,18 @@ var DataMap = /*#__PURE__*/function () {
         this.recursiveDuckColumns(schema);
       }
     }
+
     /**
      * Get the amount of physical columns in the first data row.
      *
      * @returns {number} Amount of physical columns in the first data row.
      */
-
   }, {
     key: "countFirstRowKeys",
     value: function countFirstRowKeys() {
       return _countFirstRowKeys(this.dataSource);
     }
+
     /**
      * Generates columns' translation cache.
      *
@@ -201,46 +185,38 @@ var DataMap = /*#__PURE__*/function () {
      * @param {number} parent The property cache for recursive calls.
      * @returns {number}
      */
-
   }, {
     key: "recursiveDuckColumns",
     value: function recursiveDuckColumns(schema, lastCol, parent) {
       var _this = this;
-
       var lastColumn = lastCol;
       var propertyParent = parent;
       var prop;
-
       if (typeof lastColumn === 'undefined') {
         lastColumn = 0;
         propertyParent = '';
       }
-
       if (_typeof(schema) === 'object' && !Array.isArray(schema)) {
         objectEach(schema, function (value, key) {
           if (value === null) {
             prop = propertyParent + key;
-
             _this.colToPropCache.push(prop);
-
             _this.propToColCache.set(prop, lastColumn);
-
             lastColumn += 1;
           } else {
             lastColumn = _this.recursiveDuckColumns(value, lastColumn, "".concat(key, "."));
           }
         });
       }
-
       return lastColumn;
     }
+
     /**
      * Returns property name that corresponds with the given column index.
      *
      * @param {string|number} column Visual column index or another passed argument.
      * @returns {string|number} Column property, physical column index or passed argument.
      */
-
   }, {
     key: "colToProp",
     value: function colToProp(column) {
@@ -249,109 +225,121 @@ var DataMap = /*#__PURE__*/function () {
       if (Number.isInteger(column) === false) {
         return column;
       }
+      var physicalColumn = this.instance.toPhysicalColumn(column);
 
-      var physicalColumn = this.instance.toPhysicalColumn(column); // Out of range, not visible column index.
-
+      // Out of range, not visible column index.
       if (physicalColumn === null) {
         return column;
-      } // Cached property.
-
+      }
 
+      // Cached property.
       if (this.colToPropCache && isDefined(this.colToPropCache[physicalColumn])) {
         return this.colToPropCache[physicalColumn];
       }
-
       return physicalColumn;
     }
+
     /**
      * Translates property into visual column index.
      *
      * @param {string|number} prop Column property which may be also a physical column index.
      * @returns {string|number} Visual column index or passed argument.
      */
-
   }, {
     key: "propToCol",
     value: function propToCol(prop) {
       var cachedPhysicalIndex = this.propToColCache.get(prop);
-
       if (isDefined(cachedPhysicalIndex)) {
         return this.instance.toVisualColumn(cachedPhysicalIndex);
-      } // Property may be a physical column index.
-
+      }
 
+      // Property may be a physical column index.
       var visualColumn = this.instance.toVisualColumn(prop);
-
       if (visualColumn === null) {
         return prop;
       }
-
       return visualColumn;
     }
+
     /**
      * Returns data's schema.
      *
      * @returns {object}
      */
-
   }, {
     key: "getSchema",
     value: function getSchema() {
       var schema = this.tableMeta.dataSchema;
-
       if (schema) {
         if (typeof schema === 'function') {
           return schema();
         }
-
         return schema;
       }
-
       return this.duckSchema;
     }
+
+    /**
+     * Creates the duck schema based on the current dataset.
+     *
+     * @returns {Array|object}
+     */
+  }, {
+    key: "createDuckSchema",
+    value: function createDuckSchema() {
+      return this.dataSource && this.dataSource[0] ? duckSchema(this.dataSource[0]) : {};
+    }
+
+    /**
+     * Refresh the data schema.
+     */
+  }, {
+    key: "refreshDuckSchema",
+    value: function refreshDuckSchema() {
+      this.duckSchema = this.createDuckSchema();
+    }
+
     /**
      * Creates row at the bottom of the data array.
      *
      * @param {number} [index] Physical index of the row before which the new row will be inserted.
      * @param {number} [amount=1] An amount of rows to add.
-     * @param {string} [source] Source of method call.
+     * @param {object} [options] Additional options for created rows.
+     * @param {string} [options.source] Source of method call.
+     * @param {'above'|'below'} [options.mode] Sets where the row is inserted: above or below the passed index.
      * @fires Hooks#afterCreateRow
      * @returns {number} Returns number of created rows.
      */
-
   }, {
     key: "createRow",
     value: function createRow(index) {
       var _this2 = this;
-
       var amount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
-      var source = arguments.length > 2 ? arguments[2] : undefined;
+      var _ref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
+        source = _ref.source,
+        _ref$mode = _ref.mode,
+        mode = _ref$mode === void 0 ? 'above' : _ref$mode;
       var sourceRowsCount = this.instance.countSourceRows();
       var physicalRowIndex = sourceRowsCount;
       var numberOfCreatedRows = 0;
       var rowIndex = index;
-
       if (typeof rowIndex !== 'number' || rowIndex >= sourceRowsCount) {
         rowIndex = sourceRowsCount;
       }
-
       if (rowIndex < this.instance.countRows()) {
         physicalRowIndex = this.instance.toPhysicalRow(rowIndex);
       }
-
       var continueProcess = this.instance.runHooks('beforeCreateRow', rowIndex, amount, source);
-
       if (continueProcess === false || physicalRowIndex === null) {
-        return 0;
+        return {
+          delta: 0
+        };
       }
-
       var maxRows = this.tableMeta.maxRows;
-      var columnCount = this.instance.countCols();
+      var columnCount = this.getSchema().length;
       var rowsToAdd = [];
-
       var _loop = function _loop() {
         var row = null;
-
         if (_this2.instance.dataType === 'array') {
           if (_this2.tableMeta.dataSchema) {
             // Clone template array
@@ -359,7 +347,6 @@ var DataMap = /*#__PURE__*/function () {
           } else {
             row = [];
             /* eslint-disable no-loop-func */
-
             rangeEach(columnCount - 1, function () {
               return row.push(null);
             });
@@ -370,67 +357,90 @@ var DataMap = /*#__PURE__*/function () {
           row = {};
           deepExtend(row, _this2.getSchema());
         }
-
         rowsToAdd.push(row);
         numberOfCreatedRows += 1;
       };
-
       while (numberOfCreatedRows < amount && sourceRowsCount + numberOfCreatedRows < maxRows) {
         _loop();
       }
-
       this.instance.rowIndexMapper.insertIndexes(rowIndex, numberOfCreatedRows);
+      if (mode === 'below') {
+        physicalRowIndex = Math.min(physicalRowIndex + 1, sourceRowsCount);
+      }
       this.spliceData(physicalRowIndex, 0, rowsToAdd);
-      this.instance.runHooks('afterCreateRow', rowIndex, numberOfCreatedRows, source);
+      var newVisualRowIndex = this.instance.toVisualRow(physicalRowIndex);
+
+      // In case the created rows are the only ones in the table, the column index mappers need to be rebuilt based on
+      // the number of columns created in the row or the schema.
+      if (this.instance.countSourceRows() === rowsToAdd.length) {
+        this.instance.columnIndexMapper.initToLength(this.instance.getInitialColumnCount());
+      }
+      if (numberOfCreatedRows > 0) {
+        if (index === void 0 || index === null) {
+          // Creates the meta rows at the end of the rows collection without shifting the cells
+          // that were defined out of the range of the dataset.
+          this.metaManager.createRow(null, numberOfCreatedRows);
+        } else if (source !== 'auto') {
+          this.metaManager.createRow(physicalRowIndex, amount);
+        }
+      }
+      this.instance.runHooks('afterCreateRow', newVisualRowIndex, numberOfCreatedRows, source);
       this.instance.forceFullRender = true; // used when data was changed
 
-      return numberOfCreatedRows;
+      return {
+        delta: numberOfCreatedRows,
+        startPhysicalIndex: physicalRowIndex
+      };
     }
+
     /**
      * Creates column at the right of the data array.
      *
      * @param {number} [index] Visual index of the column before which the new column will be inserted.
      * @param {number} [amount=1] An amount of columns to add.
-     * @param {string} [source] Source of method call.
+     * @param {object} [options] Additional options for created columns.
+     * @param {string} [options.source] Source of method call.
+     * @param {'start'|'end'} [options.mode] Sets where the column is inserted: at the start (left in [LTR](@/api/options.md#layoutdirection), right in [RTL](@/api/options.md#layoutdirection)) or at the end (right in LTR, left in LTR)
+     * the passed index.
      * @fires Hooks#afterCreateCol
      * @returns {number} Returns number of created columns.
      */
-
   }, {
     key: "createCol",
     value: function createCol(index) {
       var amount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
-      var source = arguments.length > 2 ? arguments[2] : undefined;
-
+      var _ref2 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
+        source = _ref2.source,
+        _ref2$mode = _ref2.mode,
+        mode = _ref2$mode === void 0 ? 'start' : _ref2$mode;
       if (!this.instance.isColumnModificationAllowed()) {
         throw new Error('Cannot create new column. When data source in an object, ' + 'you can only have as much columns as defined in first data row, data schema or in the \'columns\' setting.' + 'If you want to be able to add new columns, you have to use array datasource.');
       }
-
       var dataSource = this.dataSource;
       var maxCols = this.tableMeta.maxCols;
+      var countSourceCols = this.instance.countSourceCols();
       var columnIndex = index;
-
-      if (typeof columnIndex !== 'number' || columnIndex >= this.instance.countSourceCols()) {
-        columnIndex = this.instance.countSourceCols();
+      if (typeof columnIndex !== 'number' || columnIndex >= countSourceCols) {
+        columnIndex = countSourceCols;
       }
-
       var continueProcess = this.instance.runHooks('beforeCreateCol', columnIndex, amount, source);
-
       if (continueProcess === false) {
-        return 0;
+        return {
+          delta: 0
+        };
       }
-
-      var physicalColumnIndex = this.instance.countSourceCols();
-
+      var physicalColumnIndex = countSourceCols;
       if (columnIndex < this.instance.countCols()) {
         physicalColumnIndex = this.instance.toPhysicalColumn(columnIndex);
       }
-
       var numberOfSourceRows = this.instance.countSourceRows();
       var nrOfColumns = this.instance.countCols();
       var numberOfCreatedCols = 0;
       var currentIndex = physicalColumnIndex;
-
+      if (mode === 'end') {
+        currentIndex = Math.min(currentIndex + 1, countSourceCols);
+      }
+      var startPhysicalIndex = currentIndex;
       while (numberOfCreatedCols < amount && nrOfColumns < maxCols) {
         if (typeof columnIndex !== 'number' || columnIndex >= nrOfColumns) {
           if (numberOfSourceRows > 0) {
@@ -438,7 +448,6 @@ var DataMap = /*#__PURE__*/function () {
               if (typeof dataSource[row] === 'undefined') {
                 dataSource[row] = [];
               }
-
               dataSource[row].push(null);
             }
           } else {
@@ -449,18 +458,31 @@ var DataMap = /*#__PURE__*/function () {
             dataSource[_row].splice(currentIndex, 0, null);
           }
         }
-
         numberOfCreatedCols += 1;
         currentIndex += 1;
         nrOfColumns += 1;
       }
-
       this.instance.columnIndexMapper.insertIndexes(columnIndex, numberOfCreatedCols);
-      this.instance.runHooks('afterCreateCol', columnIndex, numberOfCreatedCols, source);
+      if (numberOfCreatedCols > 0) {
+        if (index === void 0 || index === null) {
+          // Creates the meta columns at the end of the columns collection without shifting the cells
+          // that were defined out of the range of the dataset.
+          this.metaManager.createColumn(null, numberOfCreatedCols);
+        } else if (source !== 'auto') {
+          this.metaManager.createColumn(startPhysicalIndex, amount);
+        }
+      }
+      var newVisualColumnIndex = this.instance.toVisualColumn(startPhysicalIndex);
+      this.instance.runHooks('afterCreateCol', newVisualColumnIndex, numberOfCreatedCols, source);
       this.instance.forceFullRender = true; // used when data was changed
 
-      return numberOfCreatedCols;
+      this.refreshDuckSchema();
+      return {
+        delta: numberOfCreatedCols,
+        startPhysicalIndex: startPhysicalIndex
+      };
     }
+
     /**
      * Removes row from the data array.
      *
@@ -471,42 +493,49 @@ var DataMap = /*#__PURE__*/function () {
      * @param {string} [source] Source of method call.
      * @returns {boolean} Returns `false` when action was cancelled, otherwise `true`.
      */
-
   }, {
     key: "removeRow",
     value: function removeRow(index) {
+      var _this3 = this;
       var amount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
       var source = arguments.length > 2 ? arguments[2] : undefined;
       var rowIndex = Number.isInteger(index) ? index : -amount; // -amount = taking indexes from the end.
-
       var removedPhysicalIndexes = this.visualRowsToPhysical(rowIndex, amount);
       var sourceRowsLength = this.instance.countSourceRows();
-      rowIndex = (sourceRowsLength + rowIndex) % sourceRowsLength; // It handle also callback from the `NestedRows` plugin. Removing parent node has effect in removing children nodes.
+      rowIndex = (sourceRowsLength + rowIndex) % sourceRowsLength;
 
+      // It handle also callback from the `NestedRows` plugin. Removing parent node has effect in removing children nodes.
       var actionWasNotCancelled = this.instance.runHooks('beforeRemoveRow', rowIndex, removedPhysicalIndexes.length, removedPhysicalIndexes, source);
-
       if (actionWasNotCancelled === false) {
         return false;
-      } // List of removed indexes might be changed in the `beforeRemoveRow` hook. There may be new values.
-
+      }
 
+      // List of removed indexes might be changed in the `beforeRemoveRow` hook. There may be new values.
       var numberOfRemovedIndexes = removedPhysicalIndexes.length;
-      this.filterData(rowIndex, numberOfRemovedIndexes, removedPhysicalIndexes); // 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);
-        var customDefinedColumns = isDefined(this.tableMeta.columns) || isDefined(this.tableMeta.dataSchema); // All rows have been removed. There shouldn't be any columns.
+        var customDefinedColumns = isDefined(this.tableMeta.columns) || isDefined(this.tableMeta.dataSchema);
 
+        // All rows have been removed. There shouldn't be any columns.
         if (this.instance.rowIndexMapper.getNotTrimmedIndexesLength() === 0 && customDefinedColumns === false) {
           this.instance.columnIndexMapper.setIndexesSequence([]);
         }
       }
-
+      var descendingPhysicalRows = removedPhysicalIndexes.slice(0).sort(function (a, b) {
+        return b - a;
+      });
+      descendingPhysicalRows.forEach(function (rowPhysicalIndex) {
+        _this3.metaManager.removeRow(rowPhysicalIndex, 1);
+      });
       this.instance.runHooks('afterRemoveRow', rowIndex, numberOfRemovedIndexes, removedPhysicalIndexes, source);
       this.instance.forceFullRender = true; // used when data was changed
 
       return true;
     }
+
     /**
      * Removes column from the data array.
      *
@@ -517,65 +546,65 @@ var DataMap = /*#__PURE__*/function () {
      * @param {string} [source] Source of method call.
      * @returns {boolean} Returns `false` when action was cancelled, otherwise `true`.
      */
-
   }, {
     key: "removeCol",
     value: function removeCol(index) {
       var amount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
       var source = arguments.length > 2 ? arguments[2] : undefined;
-
       if (this.instance.dataType === 'object' || this.tableMeta.columns) {
         throw new Error('cannot remove column with object data source or columns option specified');
       }
-
       var columnIndex = typeof index !== 'number' ? -amount : index;
       columnIndex = (this.instance.countCols() + columnIndex) % this.instance.countCols();
-      var logicColumns = this.visualColumnsToPhysical(columnIndex, amount);
-      var descendingLogicColumns = logicColumns.slice(0).sort(function (a, b) {
+      var removedPhysicalIndexes = this.visualColumnsToPhysical(columnIndex, amount);
+      var descendingPhysicalColumns = removedPhysicalIndexes.slice(0).sort(function (a, b) {
         return b - a;
       });
-      var actionWasNotCancelled = this.instance.runHooks('beforeRemoveCol', columnIndex, amount, logicColumns, source);
-
+      var actionWasNotCancelled = this.instance.runHooks('beforeRemoveCol', columnIndex, amount, removedPhysicalIndexes, source);
       if (actionWasNotCancelled === false) {
         return false;
       }
-
       var isTableUniform = true;
-      var removedColumnsCount = descendingLogicColumns.length;
+      var removedColumnsCount = descendingPhysicalColumns.length;
       var data = this.dataSource;
-
       for (var c = 0; c < removedColumnsCount; c++) {
-        if (isTableUniform && logicColumns[0] !== logicColumns[c] - c) {
+        if (isTableUniform && removedPhysicalIndexes[0] !== removedPhysicalIndexes[c] - c) {
           isTableUniform = false;
         }
       }
-
       if (isTableUniform) {
         for (var r = 0, rlen = this.instance.countSourceRows(); r < rlen; r++) {
-          data[r].splice(logicColumns[0], amount);
+          data[r].splice(removedPhysicalIndexes[0], amount);
+          if (r === 0) {
+            this.metaManager.removeColumn(removedPhysicalIndexes[0], amount);
+          }
         }
       } else {
         for (var _r = 0, _rlen = this.instance.countSourceRows(); _r < _rlen; _r++) {
           for (var _c = 0; _c < removedColumnsCount; _c++) {
-            data[_r].splice(descendingLogicColumns[_c], 1);
+            data[_r].splice(descendingPhysicalColumns[_c], 1);
+            if (_r === 0) {
+              this.metaManager.removeColumn(descendingPhysicalColumns[_c], 1);
+            }
           }
         }
-      } // TODO: Function `removeCol` should validate fully, probably above.
-
+      }
 
+      // TODO: Function `removeCol` should validate fully, probably above.
       if (columnIndex < this.instance.countCols()) {
-        this.instance.columnIndexMapper.removeIndexes(logicColumns); // All columns have been removed. There shouldn't be any rows.
+        this.instance.columnIndexMapper.removeIndexes(removedPhysicalIndexes);
 
+        // All columns have been removed. There shouldn't be any rows.
         if (this.instance.columnIndexMapper.getNotTrimmedIndexesLength() === 0) {
           this.instance.rowIndexMapper.setIndexesSequence([]);
         }
       }
-
-      this.instance.runHooks('afterRemoveCol', columnIndex, amount, logicColumns, source);
+      this.instance.runHooks('afterRemoveCol', columnIndex, amount, removedPhysicalIndexes, source);
       this.instance.forceFullRender = true; // used when data was changed
-
+      this.refreshDuckSchema();
       return true;
     }
+
     /**
      * Add/Removes data from the column.
      *
@@ -585,31 +614,26 @@ var DataMap = /*#__PURE__*/function () {
      * @param {Array} [elements] The new columns to add.
      * @returns {Array} Returns removed portion of columns.
      */
-
   }, {
     key: "spliceCol",
     value: function spliceCol(col, index, amount) {
       var colData = this.instance.getDataAtCol(col);
       var removed = colData.slice(index, index + amount);
       var after = colData.slice(index + amount);
-
       for (var _len = arguments.length, elements = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
         elements[_key - 3] = arguments[_key];
       }
-
       extendArray(elements, after);
       var i = 0;
-
       while (i < amount) {
         elements.push(null); // add null in place of removed elements
-
         i += 1;
       }
-
       to2dArray(elements);
       this.instance.populateFromArray(index, col, elements, null, null, 'spliceCol');
       return removed;
     }
+
     /**
      * Add/Removes data from the row.
      *
@@ -619,30 +643,25 @@ var DataMap = /*#__PURE__*/function () {
      * @param {Array} [elements] The new rows to add.
      * @returns {Array} Returns removed portion of rows.
      */
-
   }, {
     key: "spliceRow",
     value: function spliceRow(row, index, amount) {
       var rowData = this.instance.getSourceDataAtRow(row);
       var removed = rowData.slice(index, index + amount);
       var after = rowData.slice(index + amount);
-
       for (var _len2 = arguments.length, elements = new Array(_len2 > 3 ? _len2 - 3 : 0), _key2 = 3; _key2 < _len2; _key2++) {
         elements[_key2 - 3] = arguments[_key2];
       }
-
       extendArray(elements, after);
       var i = 0;
-
       while (i < amount) {
         elements.push(null); // add null in place of removed elements
-
         i += 1;
       }
-
       this.instance.populateFromArray(row, index, [elements], null, null, 'spliceRow');
       return removed;
     }
+
     /**
      * Add/remove row(s) to/from the data source.
      *
@@ -650,25 +669,25 @@ var DataMap = /*#__PURE__*/function () {
      * @param {number} deleteCount Number of rows to remove.
      * @param {Array<object>} elements Row elements to be added.
      */
-
   }, {
     key: "spliceData",
     value: function spliceData(index, deleteCount, elements) {
-      var _this3 = this;
-
+      var _this4 = this;
       var continueSplicing = this.instance.runHooks('beforeDataSplice', index, deleteCount, elements);
-
       if (continueSplicing !== false) {
-        var newData = [].concat(_toConsumableArray(this.dataSource.slice(0, index)), _toConsumableArray(elements), _toConsumableArray(this.dataSource.slice(index))); // We try not to change the reference.
+        var newData = [].concat(_toConsumableArray(this.dataSource.slice(0, index)), _toConsumableArray(elements), _toConsumableArray(this.dataSource.slice(index)));
 
-        this.dataSource.length = 0; // Pushing to array instead of using `splice`, because Babel changes the code to one that uses the `apply` method.
-        // The used method was cause of the problem described within #7840.
+        // We try not to change the reference.
+        this.dataSource.length = 0;
 
+        // Pushing to array instead of using `splice`, because Babel changes the code to one that uses the `apply` method.
+        // The used method was cause of the problem described within #7840.
         newData.forEach(function (row) {
-          return _this3.dataSource.push(row);
+          return _this4.dataSource.push(row);
         });
       }
     }
+
     /**
      * Filter unwanted data elements from the data source.
      *
@@ -676,22 +695,22 @@ var DataMap = /*#__PURE__*/function () {
      * @param {number} amount Number of rows to add/remove.
      * @param {number} physicalRows Physical row indexes.
      */
-
   }, {
     key: "filterData",
     value: function filterData(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).
+      var data = this.instance.runHooks('filterData', index, amount, physicalRows);
 
+      // Hooks by default returns first argument (when there is no callback changing execution result).
       if (Array.isArray(data) === false) {
         data = this.dataSource.filter(function (row, rowIndex) {
           return physicalRows.indexOf(rowIndex) === -1;
         });
       }
-
       this.dataSource.length = 0;
       Array.prototype.push.apply(this.dataSource, data);
     }
+
     /**
      * Returns single value from the data array.
      *
@@ -699,52 +718,47 @@ var DataMap = /*#__PURE__*/function () {
      * @param {number} prop The column property.
      * @returns {*}
      */
-
   }, {
     key: "get",
     value: function get(row, prop) {
       var physicalRow = this.instance.toPhysicalRow(row);
-      var dataRow = this.dataSource[physicalRow]; // TODO: To remove, use 'modifyData' hook instead (see below)
-
+      var dataRow = this.dataSource[physicalRow];
+      // TODO: To remove, use 'modifyData' hook instead (see below)
       var modifiedRowData = this.instance.runHooks('modifyRowData', physicalRow);
-      dataRow = isNaN(modifiedRowData) ? modifiedRowData : dataRow; //
+      dataRow = isNaN(modifiedRowData) ? modifiedRowData : dataRow;
+      //
 
-      var value = null; // try to get value under property `prop` (includes dot)
+      var value = null;
 
+      // try to get value under property `prop` (includes dot)
       if (dataRow && dataRow.hasOwnProperty && hasOwnProperty(dataRow, prop)) {
         value = dataRow[prop];
       } else if (typeof prop === 'string' && prop.indexOf('.') > -1) {
         var sliced = prop.split('.');
         var out = dataRow;
-
         if (!out) {
           return null;
         }
-
         for (var i = 0, ilen = sliced.length; i < ilen; i++) {
           out = out[sliced[i]];
-
           if (typeof out === 'undefined') {
             return null;
           }
         }
-
         value = out;
       } else if (typeof prop === 'function') {
         value = prop(this.dataSource.slice(physicalRow, physicalRow + 1)[0]);
       }
-
       if (this.instance.hasHook('modifyData')) {
         var valueHolder = createObjectPropListener(value);
         this.instance.runHooks('modifyData', physicalRow, this.propToCol(prop), valueHolder, 'get');
-
         if (valueHolder.isTouched()) {
           value = valueHolder.value;
         }
       }
-
       return value;
     }
+
     /**
      * Returns single value from the data array (intended for clipboard copy to an external application).
      *
@@ -752,16 +766,15 @@ var DataMap = /*#__PURE__*/function () {
      * @param {number} prop The column property.
      * @returns {string}
      */
-
   }, {
     key: "getCopyable",
     value: function getCopyable(row, prop) {
-      if (copyableLookup.call(this.instance, row, this.propToCol(prop))) {
+      if (this.instance.getCellMeta(row, this.propToCol(prop)).copyable) {
         return this.get(row, prop);
       }
-
       return '';
     }
+
     /**
      * Saves single value to the data array.
      *
@@ -769,27 +782,26 @@ var DataMap = /*#__PURE__*/function () {
      * @param {number} prop The column property.
      * @param {string} value The value to set.
      */
-
   }, {
     key: "set",
     value: function set(row, prop, value) {
       var physicalRow = this.instance.toPhysicalRow(row);
       var newValue = value;
-      var dataRow = this.dataSource[physicalRow]; // TODO: To remove, use 'modifyData' hook instead (see below)
-
+      var dataRow = this.dataSource[physicalRow];
+      // TODO: To remove, use 'modifyData' hook instead (see below)
       var modifiedRowData = this.instance.runHooks('modifyRowData', physicalRow);
-      dataRow = isNaN(modifiedRowData) ? modifiedRowData : dataRow; //
+      dataRow = isNaN(modifiedRowData) ? modifiedRowData : dataRow;
+      //
 
       if (this.instance.hasHook('modifyData')) {
         var valueHolder = createObjectPropListener(newValue);
         this.instance.runHooks('modifyData', physicalRow, this.propToCol(prop), valueHolder, 'set');
-
         if (valueHolder.isTouched()) {
           newValue = valueHolder.value;
         }
-      } // try to set value under property `prop` (includes dot)
-
+      }
 
+      // try to set value under property `prop` (includes dot)
       if (dataRow && dataRow.hasOwnProperty && hasOwnProperty(dataRow, prop)) {
         dataRow[prop] = newValue;
       } else if (typeof prop === 'string' && prop.indexOf('.') > -1) {
@@ -797,15 +809,12 @@ var DataMap = /*#__PURE__*/function () {
         var out = dataRow;
         var i = 0;
         var ilen;
-
         for (i = 0, ilen = sliced.length - 1; i < ilen; i++) {
           if (typeof out[sliced[i]] === 'undefined') {
             out[sliced[i]] = {};
           }
-
           out = out[sliced[i]];
         }
-
         out[sliced[i]] = newValue;
       } else if (typeof prop === 'function') {
         prop(this.dataSource.slice(physicalRow, physicalRow + 1)[0], newValue);
@@ -813,6 +822,7 @@ var DataMap = /*#__PURE__*/function () {
         dataRow[prop] = newValue;
       }
     }
+
     /**
      * This ridiculous piece of code maps rows Id that are present in table data to those displayed for user.
      * The trick is, the physical row id (stored in settings.data) is not necessary the same
@@ -822,7 +832,6 @@ var DataMap = /*#__PURE__*/function () {
      * @param {number} amount An amount of rows to translate.
      * @returns {number}
      */
-
   }, {
     key: "visualRowsToPhysical",
     value: function visualRowsToPhysical(index, amount) {
@@ -831,23 +840,21 @@ var DataMap = /*#__PURE__*/function () {
       var physicRow = (totalRows + index) % totalRows;
       var rowsToRemove = amount;
       var row;
-
       while (physicRow < totalRows && rowsToRemove) {
         row = this.instance.toPhysicalRow(physicRow);
         logicRows.push(row);
         rowsToRemove -= 1;
         physicRow += 1;
       }
-
       return logicRows;
     }
+
     /**
      *
      * @param {number} index Visual column index.
      * @param {number} amount An amount of rows to translate.
      * @returns {Array}
      */
-
   }, {
     key: "visualColumnsToPhysical",
     value: function visualColumnsToPhysical(index, amount) {
@@ -855,20 +862,18 @@ var DataMap = /*#__PURE__*/function () {
       var visualCols = [];
       var physicalCol = (totalCols + index) % totalCols;
       var colsToRemove = amount;
-
       while (physicalCol < totalCols && colsToRemove) {
         var col = this.instance.toPhysicalColumn(physicalCol);
         visualCols.push(col);
         colsToRemove -= 1;
         physicalCol += 1;
       }
-
       return visualCols;
     }
+
     /**
      * Clears the data array.
      */
-
   }, {
     key: "clear",
     value: function clear() {
@@ -878,33 +883,31 @@ var DataMap = /*#__PURE__*/function () {
         }
       }
     }
+
     /**
      * Get data length.
      *
      * @returns {number}
      */
-
   }, {
     key: "getLength",
     value: function getLength() {
       var maxRowsFromSettings = this.tableMeta.maxRows;
       var maxRows;
-
       if (maxRowsFromSettings < 0 || maxRowsFromSettings === 0) {
         maxRows = 0;
       } else {
         maxRows = maxRowsFromSettings || Infinity;
       }
-
       var length = this.instance.rowIndexMapper.getNotTrimmedIndexesLength();
       return Math.min(length, maxRows);
     }
+
     /**
      * Returns the data array.
      *
      * @returns {Array}
      */
-
   }, {
     key: "getAll",
     value: function getAll() {
@@ -916,24 +919,23 @@ var DataMap = /*#__PURE__*/function () {
         row: Math.max(this.instance.countRows() - 1, 0),
         col: Math.max(this.instance.countCols() - 1, 0)
       };
-
       if (start.row - end.row === 0 && !this.instance.countSourceRows()) {
         return [];
       }
-
       return this.getRange(start, end, DataMap.DESTINATION_RENDERER);
     }
+
     /**
      * Count the number of columns cached in the `colToProp` cache.
      *
      * @returns {number} Amount of cached columns.
      */
-
   }, {
     key: "countCachedColumns",
     value: function countCachedColumns() {
       return this.colToPropCache.length;
     }
+
     /**
      * Returns data range as array.
      *
@@ -942,7 +944,6 @@ var DataMap = /*#__PURE__*/function () {
      * @param {number} destination Destination of datamap.get.
      * @returns {Array}
      */
-
   }, {
     key: "getRange",
     value: function getRange(start, end, destination) {
@@ -952,35 +953,29 @@ var DataMap = /*#__PURE__*/function () {
       var row;
       var maxRows = this.tableMeta.maxRows;
       var maxCols = this.tableMeta.maxCols;
-
       if (maxRows === 0 || maxCols === 0) {
         return [];
       }
-
       var getFn = destination === DataMap.DESTINATION_CLIPBOARD_GENERATOR ? this.getCopyable : this.get;
       var rlen = Math.min(Math.max(maxRows - 1, 0), Math.max(start.row, end.row));
       var clen = Math.min(Math.max(maxCols - 1, 0), Math.max(start.col, end.col));
-
       for (r = Math.min(start.row, end.row); r <= rlen; r++) {
-        row = []; // We just store indexes for rows without headers.
-
+        row = [];
+        // We just store indexes for rows without headers.
         var physicalRow = r >= 0 ? this.instance.toPhysicalRow(r) : r;
-
         for (c = Math.min(start.col, end.col); c <= clen; c++) {
           if (physicalRow === null) {
             break;
           }
-
           row.push(getFn.call(this, r, this.colToProp(c)));
         }
-
         if (physicalRow !== null) {
           output.push(row);
         }
       }
-
       return output;
     }
+
     /**
      * Return data as text (tab separated columns).
      *
@@ -988,12 +983,12 @@ var DataMap = /*#__PURE__*/function () {
      * @param {object} [end] End selection position. Visual indexes.
      * @returns {string}
      */
-
   }, {
     key: "getText",
     value: function getText(start, end) {
       return stringify(this.getRange(start, end, DataMap.DESTINATION_RENDERER));
     }
+
     /**
      * Return data as copyable text (tab separated columns intended for clipboard copy to an external application).
      *
@@ -1001,21 +996,20 @@ var DataMap = /*#__PURE__*/function () {
      * @param {object} [end] End selection position. Visual indexes.
      * @returns {string}
      */
-
   }, {
     key: "getCopyableText",
     value: function getCopyableText(start, end) {
       return stringify(this.getRange(start, end, DataMap.DESTINATION_CLIPBOARD_GENERATOR));
     }
+
     /**
      * Destroy instance.
      */
-
   }, {
     key: "destroy",
     value: function destroy() {
       this.instance = null;
-      this.tableMeta = null;
+      this.metaManager = null;
       this.dataSource = null;
       this.duckSchema = null;
       this.colToPropCache.length = 0;
@@ -1031,18 +1025,16 @@ var DataMap = /*#__PURE__*/function () {
     function get() {
       return 1;
     }
+
     /**
      * @type {number}
      */
-
   }, {
     key: "DESTINATION_CLIPBOARD_GENERATOR",
     get: function get() {
       return 2;
     }
   }]);
-
   return DataMap;
 }();
-
 export default DataMap;