handsontable 14.0.0-next-c080457-20231107 → 14.0.0-next-bfad250-20231108

package/dataMap/dataMap.js

@@ -9,6 +9,9 @@ var _object = require("../helpers/object");
 var _array = require("../helpers/array");
 var _number = require("../helpers/number");
 var _mixed = require("../helpers/mixed");
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+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); }
 /*
 This class contains open-source contributions covered by the MIT license.
 
@@ -55,56 +58,62 @@ class DataMap {
   }
 
   /**
-   * @param {object} instance Instance of Handsontable.
+   * Instance of {@link Handsontable}.
+   *
+   * @private
+   * @type {Handsontable}
+   */
+
+  /**
+   * @param {object} hotInstance Instance of Handsontable.
    * @param {Array} data Array of arrays or array of objects containing data.
    * @param {MetaManager} metaManager The meta manager instance.
    */
-  constructor(instance, data, metaManager) {
-    /**
-     * Instance of {@link Handsontable}.
-     *
-     * @private
-     * @type {Handsontable}
-     */
-    this.instance = instance;
+  constructor(hotInstance, data, metaManager) {
+    _defineProperty(this, "hot", void 0);
     /**
      * Instance of {@link MetaManager}.
      *
      * @private
      * @type {MetaManager}
      */
-    this.metaManager = metaManager;
+    _defineProperty(this, "metaManager", void 0);
     /**
      * Instance of {@link TableMeta}.
      *
      * @private
      * @type {TableMeta}
      */
-    this.tableMeta = metaManager.getTableMeta();
+    _defineProperty(this, "tableMeta", void 0);
     /**
      * Reference to the original dataset.
      *
      * @type {*}
      */
-    this.dataSource = data;
+    _defineProperty(this, "dataSource", void 0);
     /**
      * Generated schema based on the first row from the source data.
      *
      * @type {object}
      */
-    this.duckSchema = this.createDuckSchema();
+    _defineProperty(this, "duckSchema", void 0);
     /**
      * Cached array of properties to columns.
      *
      * @type {Array}
      */
-    this.colToPropCache = void 0;
+    _defineProperty(this, "colToPropCache", void 0);
     /**
      * Cached map of properties to columns.
      *
      * @type {Map}
      */
-    this.propToColCache = void 0;
+    _defineProperty(this, "propToColCache", void 0);
+    this.hot = hotInstance;
+    this.metaManager = metaManager;
+    this.tableMeta = metaManager.getTableMeta();
+    this.dataSource = data;
+    this.duckSchema = this.createDuckSchema();
     this.createMap();
   }
 
@@ -200,7 +209,7 @@ class DataMap {
     if (Number.isInteger(column) === false) {
       return column;
     }
-    const physicalColumn = this.instance.toPhysicalColumn(column);
+    const physicalColumn = this.hot.toPhysicalColumn(column);
 
     // Out of range, not visible column index.
     if (physicalColumn === null) {
@@ -223,11 +232,11 @@ class DataMap {
   propToCol(prop) {
     const cachedPhysicalIndex = this.propToColCache.get(prop);
     if ((0, _mixed.isDefined)(cachedPhysicalIndex)) {
-      return this.instance.toVisualColumn(cachedPhysicalIndex);
+      return this.hot.toVisualColumn(cachedPhysicalIndex);
     }
 
     // Property may be a physical column index.
-    const visualColumn = this.instance.toVisualColumn(prop);
+    const visualColumn = this.hot.toVisualColumn(prop);
     if (visualColumn === null) {
       return prop;
     }
@@ -283,17 +292,17 @@ class DataMap {
       source,
       mode = 'above'
     } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-    const sourceRowsCount = this.instance.countSourceRows();
+    const sourceRowsCount = this.hot.countSourceRows();
     let physicalRowIndex = sourceRowsCount;
     let numberOfCreatedRows = 0;
     let rowIndex = index;
     if (typeof rowIndex !== 'number' || rowIndex >= sourceRowsCount) {
       rowIndex = sourceRowsCount;
     }
-    if (rowIndex < this.instance.countRows()) {
-      physicalRowIndex = this.instance.toPhysicalRow(rowIndex);
+    if (rowIndex < this.hot.countRows()) {
+      physicalRowIndex = this.hot.toPhysicalRow(rowIndex);
     }
-    const continueProcess = this.instance.runHooks('beforeCreateRow', rowIndex, amount, source);
+    const continueProcess = this.hot.runHooks('beforeCreateRow', rowIndex, amount, source);
     if (continueProcess === false || physicalRowIndex === null) {
       return {
         delta: 0
@@ -304,7 +313,7 @@ class DataMap {
     const rowsToAdd = [];
     while (numberOfCreatedRows < amount && sourceRowsCount + numberOfCreatedRows < maxRows) {
       let row = null;
-      if (this.instance.dataType === 'array') {
+      if (this.hot.dataType === 'array') {
         if (this.tableMeta.dataSchema) {
           // Clone template array
           row = (0, _object.deepClone)(this.getSchema());
@@ -313,7 +322,7 @@ class DataMap {
           /* eslint-disable no-loop-func */
           (0, _number.rangeEach)(columnCount - 1, () => row.push(null));
         }
-      } else if (this.instance.dataType === 'function') {
+      } else if (this.hot.dataType === 'function') {
         row = this.tableMeta.dataSchema(rowIndex + numberOfCreatedRows);
       } else {
         row = {};
@@ -322,20 +331,20 @@ class DataMap {
       rowsToAdd.push(row);
       numberOfCreatedRows += 1;
     }
-    this.instance.rowIndexMapper.insertIndexes(rowIndex, numberOfCreatedRows);
+    this.hot.rowIndexMapper.insertIndexes(rowIndex, numberOfCreatedRows);
     if (mode === 'below') {
       physicalRowIndex = Math.min(physicalRowIndex + 1, sourceRowsCount);
     }
     this.spliceData(physicalRowIndex, 0, rowsToAdd);
-    const newVisualRowIndex = this.instance.toVisualRow(physicalRowIndex);
+    const newVisualRowIndex = this.hot.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 (this.hot.countSourceRows() === rowsToAdd.length) {
+      this.hot.columnIndexMapper.initToLength(this.hot.getInitialColumnCount());
     }
     if (numberOfCreatedRows > 0) {
-      if (index === void 0 || index === null) {
+      if (index === undefined || 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);
@@ -343,8 +352,8 @@ class DataMap {
         this.metaManager.createRow(physicalRowIndex, amount);
       }
     }
-    this.instance.runHooks('afterCreateRow', newVisualRowIndex, numberOfCreatedRows, source);
-    this.instance.forceFullRender = true; // used when data was changed
+    this.hot.runHooks('afterCreateRow', newVisualRowIndex, numberOfCreatedRows, source);
+    this.hot.forceFullRender = true; // used when data was changed
 
     return {
       delta: numberOfCreatedRows,
@@ -370,28 +379,28 @@ class DataMap {
       source,
       mode = 'start'
     } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-    if (!this.instance.isColumnModificationAllowed()) {
+    if (!this.hot.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.');
     }
     const dataSource = this.dataSource;
     const maxCols = this.tableMeta.maxCols;
-    const countSourceCols = this.instance.countSourceCols();
+    const countSourceCols = this.hot.countSourceCols();
     let columnIndex = index;
     if (typeof columnIndex !== 'number' || columnIndex >= countSourceCols) {
       columnIndex = countSourceCols;
     }
-    const continueProcess = this.instance.runHooks('beforeCreateCol', columnIndex, amount, source);
+    const continueProcess = this.hot.runHooks('beforeCreateCol', columnIndex, amount, source);
     if (continueProcess === false) {
       return {
         delta: 0
       };
     }
     let physicalColumnIndex = countSourceCols;
-    if (columnIndex < this.instance.countCols()) {
-      physicalColumnIndex = this.instance.toPhysicalColumn(columnIndex);
+    if (columnIndex < this.hot.countCols()) {
+      physicalColumnIndex = this.hot.toPhysicalColumn(columnIndex);
     }
-    const numberOfSourceRows = this.instance.countSourceRows();
-    let nrOfColumns = this.instance.countCols();
+    const numberOfSourceRows = this.hot.countSourceRows();
+    let nrOfColumns = this.hot.countCols();
     let numberOfCreatedCols = 0;
     let currentIndex = physicalColumnIndex;
     if (mode === 'end') {
@@ -419,9 +428,9 @@ class DataMap {
       currentIndex += 1;
       nrOfColumns += 1;
     }
-    this.instance.columnIndexMapper.insertIndexes(columnIndex, numberOfCreatedCols);
+    this.hot.columnIndexMapper.insertIndexes(columnIndex, numberOfCreatedCols);
     if (numberOfCreatedCols > 0) {
-      if (index === void 0 || index === null) {
+      if (index === undefined || 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);
@@ -429,9 +438,9 @@ class DataMap {
         this.metaManager.createColumn(startPhysicalIndex, amount);
       }
     }
-    const newVisualColumnIndex = this.instance.toVisualColumn(startPhysicalIndex);
-    this.instance.runHooks('afterCreateCol', newVisualColumnIndex, numberOfCreatedCols, source);
-    this.instance.forceFullRender = true; // used when data was changed
+    const newVisualColumnIndex = this.hot.toVisualColumn(startPhysicalIndex);
+    this.hot.runHooks('afterCreateCol', newVisualColumnIndex, numberOfCreatedCols, source);
+    this.hot.forceFullRender = true; // used when data was changed
 
     this.refreshDuckSchema();
     return {
@@ -455,11 +464,11 @@ class DataMap {
     let source = arguments.length > 2 ? arguments[2] : undefined;
     let rowIndex = Number.isInteger(index) ? index : -amount; // -amount = taking indexes from the end.
     const removedPhysicalIndexes = this.visualRowsToPhysical(rowIndex, amount);
-    const sourceRowsLength = this.instance.countSourceRows();
+    const sourceRowsLength = this.hot.countSourceRows();
     rowIndex = (sourceRowsLength + rowIndex) % sourceRowsLength;
 
     // It handle also callback from the `NestedRows` plugin. Removing parent node has effect in removing children nodes.
-    const actionWasNotCancelled = this.instance.runHooks('beforeRemoveRow', rowIndex, removedPhysicalIndexes.length, removedPhysicalIndexes, source);
+    const actionWasNotCancelled = this.hot.runHooks('beforeRemoveRow', rowIndex, removedPhysicalIndexes.length, removedPhysicalIndexes, source);
     if (actionWasNotCancelled === false) {
       return false;
     }
@@ -469,21 +478,21 @@ class DataMap {
     this.filterData(rowIndex, numberOfRemovedIndexes, removedPhysicalIndexes);
 
     // TODO: Function `removeRow` should validate fully, probably above.
-    if (rowIndex < this.instance.countRows()) {
-      this.instance.rowIndexMapper.removeIndexes(removedPhysicalIndexes);
+    if (rowIndex < this.hot.countRows()) {
+      this.hot.rowIndexMapper.removeIndexes(removedPhysicalIndexes);
       const customDefinedColumns = (0, _mixed.isDefined)(this.tableMeta.columns) || (0, _mixed.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([]);
+      if (this.hot.rowIndexMapper.getNotTrimmedIndexesLength() === 0 && customDefinedColumns === false) {
+        this.hot.columnIndexMapper.setIndexesSequence([]);
       }
     }
     const descendingPhysicalRows = removedPhysicalIndexes.slice(0).sort((a, b) => b - a);
     descendingPhysicalRows.forEach(rowPhysicalIndex => {
       this.metaManager.removeRow(rowPhysicalIndex, 1);
     });
-    this.instance.runHooks('afterRemoveRow', rowIndex, numberOfRemovedIndexes, removedPhysicalIndexes, source);
-    this.instance.forceFullRender = true; // used when data was changed
+    this.hot.runHooks('afterRemoveRow', rowIndex, numberOfRemovedIndexes, removedPhysicalIndexes, source);
+    this.hot.forceFullRender = true; // used when data was changed
 
     return true;
   }
@@ -501,14 +510,14 @@ class DataMap {
   removeCol(index) {
     let amount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
     let source = arguments.length > 2 ? arguments[2] : undefined;
-    if (this.instance.dataType === 'object' || this.tableMeta.columns) {
+    if (this.hot.dataType === 'object' || this.tableMeta.columns) {
       throw new Error('cannot remove column with object data source or columns option specified');
     }
     let columnIndex = typeof index !== 'number' ? -amount : index;
-    columnIndex = (this.instance.countCols() + columnIndex) % this.instance.countCols();
+    columnIndex = (this.hot.countCols() + columnIndex) % this.hot.countCols();
     const removedPhysicalIndexes = this.visualColumnsToPhysical(columnIndex, amount);
     const descendingPhysicalColumns = removedPhysicalIndexes.slice(0).sort((a, b) => b - a);
-    const actionWasNotCancelled = this.instance.runHooks('beforeRemoveCol', columnIndex, amount, removedPhysicalIndexes, source);
+    const actionWasNotCancelled = this.hot.runHooks('beforeRemoveCol', columnIndex, amount, removedPhysicalIndexes, source);
     if (actionWasNotCancelled === false) {
       return false;
     }
@@ -521,14 +530,14 @@ class DataMap {
       }
     }
     if (isTableUniform) {
-      for (let r = 0, rlen = this.instance.countSourceRows(); r < rlen; r++) {
+      for (let r = 0, rlen = this.hot.countSourceRows(); r < rlen; r++) {
         data[r].splice(removedPhysicalIndexes[0], amount);
         if (r === 0) {
           this.metaManager.removeColumn(removedPhysicalIndexes[0], amount);
         }
       }
     } else {
-      for (let r = 0, rlen = this.instance.countSourceRows(); r < rlen; r++) {
+      for (let r = 0, rlen = this.hot.countSourceRows(); r < rlen; r++) {
         for (let c = 0; c < removedColumnsCount; c++) {
           data[r].splice(descendingPhysicalColumns[c], 1);
           if (r === 0) {
@@ -539,16 +548,16 @@ class DataMap {
     }
 
     // TODO: Function `removeCol` should validate fully, probably above.
-    if (columnIndex < this.instance.countCols()) {
-      this.instance.columnIndexMapper.removeIndexes(removedPhysicalIndexes);
+    if (columnIndex < this.hot.countCols()) {
+      this.hot.columnIndexMapper.removeIndexes(removedPhysicalIndexes);
 
       // All columns have been removed. There shouldn't be any rows.
-      if (this.instance.columnIndexMapper.getNotTrimmedIndexesLength() === 0) {
-        this.instance.rowIndexMapper.setIndexesSequence([]);
+      if (this.hot.columnIndexMapper.getNotTrimmedIndexesLength() === 0) {
+        this.hot.rowIndexMapper.setIndexesSequence([]);
       }
     }
-    this.instance.runHooks('afterRemoveCol', columnIndex, amount, removedPhysicalIndexes, source);
-    this.instance.forceFullRender = true; // used when data was changed
+    this.hot.runHooks('afterRemoveCol', columnIndex, amount, removedPhysicalIndexes, source);
+    this.hot.forceFullRender = true; // used when data was changed
     this.refreshDuckSchema();
     return true;
   }
@@ -563,7 +572,7 @@ class DataMap {
    * @returns {Array} Returns removed portion of columns.
    */
   spliceCol(col, index, amount) {
-    const colData = this.instance.getDataAtCol(col);
+    const colData = this.hot.getDataAtCol(col);
     const removed = colData.slice(index, index + amount);
     const after = colData.slice(index + amount);
     for (var _len = arguments.length, elements = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
@@ -576,7 +585,7 @@ class DataMap {
       i += 1;
     }
     (0, _array.to2dArray)(elements);
-    this.instance.populateFromArray(index, col, elements, null, null, 'spliceCol');
+    this.hot.populateFromArray(index, col, elements, null, null, 'spliceCol');
     return removed;
   }
 
@@ -590,7 +599,7 @@ class DataMap {
    * @returns {Array} Returns removed portion of rows.
    */
   spliceRow(row, index, amount) {
-    const rowData = this.instance.getSourceDataAtRow(row);
+    const rowData = this.hot.getSourceDataAtRow(row);
     const removed = rowData.slice(index, index + amount);
     const after = rowData.slice(index + amount);
     for (var _len2 = arguments.length, elements = new Array(_len2 > 3 ? _len2 - 3 : 0), _key2 = 3; _key2 < _len2; _key2++) {
@@ -602,7 +611,7 @@ class DataMap {
       elements.push(null); // add null in place of removed elements
       i += 1;
     }
-    this.instance.populateFromArray(row, index, [elements], null, null, 'spliceRow');
+    this.hot.populateFromArray(row, index, [elements], null, null, 'spliceRow');
     return removed;
   }
 
@@ -614,7 +623,7 @@ class DataMap {
    * @param {Array<object>} elements Row elements to be added.
    */
   spliceData(index, deleteCount, elements) {
-    const continueSplicing = this.instance.runHooks('beforeDataSplice', index, deleteCount, elements);
+    const continueSplicing = this.hot.runHooks('beforeDataSplice', index, deleteCount, elements);
     if (continueSplicing !== false) {
       const newData = [...this.dataSource.slice(0, index), ...elements, ...this.dataSource.slice(index)];
 
@@ -636,7 +645,7 @@ class DataMap {
    */
   filterData(index, amount, physicalRows) {
     // Custom data filtering (run as a consequence of calling the below hook) provide an array containing new data.
-    let data = this.instance.runHooks('filterData', index, amount, physicalRows);
+    let data = this.hot.runHooks('filterData', index, amount, physicalRows);
 
     // Hooks by default returns first argument (when there is no callback changing execution result).
     if (Array.isArray(data) === false) {
@@ -654,10 +663,10 @@ class DataMap {
    * @returns {*}
    */
   get(row, prop) {
-    const physicalRow = this.instance.toPhysicalRow(row);
+    const physicalRow = this.hot.toPhysicalRow(row);
     let dataRow = this.dataSource[physicalRow];
     // TODO: To remove, use 'modifyData' hook instead (see below)
-    const modifiedRowData = this.instance.runHooks('modifyRowData', physicalRow);
+    const modifiedRowData = this.hot.runHooks('modifyRowData', physicalRow);
     dataRow = isNaN(modifiedRowData) ? modifiedRowData : dataRow;
     //
 
@@ -682,9 +691,9 @@ class DataMap {
     } else if (typeof prop === 'function') {
       value = prop(this.dataSource.slice(physicalRow, physicalRow + 1)[0]);
     }
-    if (this.instance.hasHook('modifyData')) {
+    if (this.hot.hasHook('modifyData')) {
       const valueHolder = (0, _object.createObjectPropListener)(value);
-      this.instance.runHooks('modifyData', physicalRow, this.propToCol(prop), valueHolder, 'get');
+      this.hot.runHooks('modifyData', physicalRow, this.propToCol(prop), valueHolder, 'get');
       if (valueHolder.isTouched()) {
         value = valueHolder.value;
       }
@@ -700,7 +709,7 @@ class DataMap {
    * @returns {string}
    */
   getCopyable(row, prop) {
-    if (this.instance.getCellMeta(row, this.propToCol(prop)).copyable) {
+    if (this.hot.getCellMeta(row, this.propToCol(prop)).copyable) {
       return this.get(row, prop);
     }
     return '';
@@ -714,17 +723,17 @@ class DataMap {
    * @param {string} value The value to set.
    */
   set(row, prop, value) {
-    const physicalRow = this.instance.toPhysicalRow(row);
+    const physicalRow = this.hot.toPhysicalRow(row);
     let newValue = value;
     let dataRow = this.dataSource[physicalRow];
     // TODO: To remove, use 'modifyData' hook instead (see below)
-    const modifiedRowData = this.instance.runHooks('modifyRowData', physicalRow);
+    const modifiedRowData = this.hot.runHooks('modifyRowData', physicalRow);
     dataRow = isNaN(modifiedRowData) ? modifiedRowData : dataRow;
     //
 
-    if (this.instance.hasHook('modifyData')) {
+    if (this.hot.hasHook('modifyData')) {
       const valueHolder = (0, _object.createObjectPropListener)(newValue);
-      this.instance.runHooks('modifyData', physicalRow, this.propToCol(prop), valueHolder, 'set');
+      this.hot.runHooks('modifyData', physicalRow, this.propToCol(prop), valueHolder, 'set');
       if (valueHolder.isTouched()) {
         newValue = valueHolder.value;
       }
@@ -762,13 +771,13 @@ class DataMap {
    * @returns {number}
    */
   visualRowsToPhysical(index, amount) {
-    const totalRows = this.instance.countSourceRows();
+    const totalRows = this.hot.countSourceRows();
     const logicRows = [];
     let physicRow = (totalRows + index) % totalRows;
     let rowsToRemove = amount;
     let row;
     while (physicRow < totalRows && rowsToRemove) {
-      row = this.instance.toPhysicalRow(physicRow);
+      row = this.hot.toPhysicalRow(physicRow);
       logicRows.push(row);
       rowsToRemove -= 1;
       physicRow += 1;
@@ -783,12 +792,12 @@ class DataMap {
    * @returns {Array}
    */
   visualColumnsToPhysical(index, amount) {
-    const totalCols = this.instance.countCols();
+    const totalCols = this.hot.countCols();
     const visualCols = [];
     let physicalCol = (totalCols + index) % totalCols;
     let colsToRemove = amount;
     while (physicalCol < totalCols && colsToRemove) {
-      const col = this.instance.toPhysicalColumn(physicalCol);
+      const col = this.hot.toPhysicalColumn(physicalCol);
       visualCols.push(col);
       colsToRemove -= 1;
       physicalCol += 1;
@@ -800,8 +809,8 @@ class DataMap {
    * Clears the data array.
    */
   clear() {
-    for (let r = 0; r < this.instance.countSourceRows(); r++) {
-      for (let c = 0; c < this.instance.countCols(); c++) {
+    for (let r = 0; r < this.hot.countSourceRows(); r++) {
+      for (let c = 0; c < this.hot.countCols(); c++) {
         this.set(r, this.colToProp(c), '');
       }
     }
@@ -820,7 +829,7 @@ class DataMap {
     } else {
       maxRows = maxRowsFromSettings || Infinity;
     }
-    const length = this.instance.rowIndexMapper.getNotTrimmedIndexesLength();
+    const length = this.hot.rowIndexMapper.getNotTrimmedIndexesLength();
     return Math.min(length, maxRows);
   }
 
@@ -835,10 +844,10 @@ class DataMap {
       col: 0
     };
     const end = {
-      row: Math.max(this.instance.countRows() - 1, 0),
-      col: Math.max(this.instance.countCols() - 1, 0)
+      row: Math.max(this.hot.countRows() - 1, 0),
+      col: Math.max(this.hot.countCols() - 1, 0)
     };
-    if (start.row - end.row === 0 && !this.instance.countSourceRows()) {
+    if (start.row - end.row === 0 && !this.hot.countSourceRows()) {
       return [];
     }
     return this.getRange(start, end, DataMap.DESTINATION_RENDERER);
@@ -877,7 +886,7 @@ class DataMap {
     for (r = Math.min(start.row, end.row); r <= rlen; r++) {
       row = [];
       // We just store indexes for rows without headers.
-      const physicalRow = r >= 0 ? this.instance.toPhysicalRow(r) : r;
+      const physicalRow = r >= 0 ? this.hot.toPhysicalRow(r) : r;
       for (c = Math.min(start.col, end.col); c <= clen; c++) {
         if (physicalRow === null) {
           break;
@@ -917,13 +926,13 @@ class DataMap {
    * Destroy instance.
    */
   destroy() {
-    this.instance = null;
+    this.hot = null;
     this.metaManager = null;
     this.dataSource = null;
     this.duckSchema = null;
     this.colToPropCache.length = 0;
     this.propToColCache.clear();
-    this.propToColCache = void 0;
+    this.propToColCache = undefined;
   }
 }
 var _default = exports.default = DataMap;