handsontable 9.0.2 → 11.1.0

package/dataMap/metaManager/mods/dynamicCellMeta.js

@@ -0,0 +1,136 @@
+"use strict";
+
+exports.__esModule = true;
+exports.DynamicCellMetaMod = void 0;
+
+require("core-js/modules/es.array.iterator.js");
+
+require("core-js/modules/es.map.js");
+
+require("core-js/modules/es.object.to-string.js");
+
+require("core-js/modules/es.string.iterator.js");
+
+require("core-js/modules/web.dom-collections.iterator.js");
+
+require("core-js/modules/es.set.js");
+
+var _pluginHooks = _interopRequireDefault(require("../../../pluginHooks"));
+
+var _object = require("../../../helpers/object");
+
+var _function = require("../../../helpers/function");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+/**
+ * @class DynamicCellMetaMod
+ *
+ * The `DynamicCellMetaMod` modifier allows for extending cell meta objects
+ * (returned by `getCellMeta()` from `MetaManager`)
+ * by user-specific properties.
+ *
+ * The user-specific properties can be added and changed dynamically,
+ * either by Handsontable's hooks (`beforeGetCellMeta` and`afterGetCellMeta`),
+ * or by Handsontable's `cells` option.
+ *
+ * The `getCellMeta()` method is used widely throughout the source code.
+ * To boost the method's execution time,
+ * the logic is triggered only once per one Handsontable slow render cycle.
+ */
+var DynamicCellMetaMod = /*#__PURE__*/function () {
+  function DynamicCellMetaMod(metaManager) {
+    var _this = this;
+
+    _classCallCheck(this, DynamicCellMetaMod);
+
+    /**
+     * @type {MetaManager}
+     */
+    this.metaManager = metaManager;
+    /**
+     * @type {Map}
+     */
+
+    this.metaSyncMemo = new Map();
+    metaManager.addLocalHook('afterGetCellMeta', function (cellMeta) {
+      return _this.extendCellMeta(cellMeta);
+    });
+
+    _pluginHooks.default.getSingleton().add('beforeRender', function (forceFullRender) {
+      if (forceFullRender) {
+        _this.metaSyncMemo.clear();
+      }
+    }, this.metaManager.hot);
+  }
+  /**
+   * Extends the cell meta object by user-specific properties.
+   *
+   * The cell meta object can be extended dynamically,
+   * either by Handsontable's hooks (`beforeGetCellMeta` and`afterGetCellMeta`),
+   * or by Handsontable's `cells` option.
+   *
+   * To boost performance, the extending process is triggered only once per one slow Handsontable render cycle.
+   *
+   * @param {object} cellMeta The cell meta object.
+   */
+
+
+  _createClass(DynamicCellMetaMod, [{
+    key: "extendCellMeta",
+    value: function extendCellMeta(cellMeta) {
+      var _this$metaSyncMemo$ge;
+
+      var physicalRow = cellMeta.row,
+          physicalColumn = cellMeta.col;
+
+      if ((_this$metaSyncMemo$ge = this.metaSyncMemo.get(physicalRow)) !== null && _this$metaSyncMemo$ge !== void 0 && _this$metaSyncMemo$ge.has(physicalColumn)) {
+        return;
+      }
+
+      var visualRow = cellMeta.visualRow,
+          visualCol = cellMeta.visualCol;
+      var hot = this.metaManager.hot;
+      var prop = hot.colToProp(visualCol);
+      cellMeta.prop = prop;
+      hot.runHooks('beforeGetCellMeta', visualRow, visualCol, cellMeta); // extend a `type` value, added or changed in the `beforeGetCellMeta` hook
+
+      var cellType = (0, _object.hasOwnProperty)(cellMeta, 'type') ? cellMeta.type : null;
+      var cellSettings = (0, _function.isFunction)(cellMeta.cells) ? cellMeta.cells(physicalRow, physicalColumn, prop) : null;
+
+      if (cellType) {
+        if (cellSettings) {
+          var _cellSettings$type;
+
+          cellSettings.type = (_cellSettings$type = cellSettings.type) !== null && _cellSettings$type !== void 0 ? _cellSettings$type : cellType;
+        } else {
+          cellSettings = {
+            type: cellType
+          };
+        }
+      }
+
+      if (cellSettings) {
+        this.metaManager.updateCellMeta(physicalRow, physicalColumn, cellSettings);
+      }
+
+      hot.runHooks('afterGetCellMeta', visualRow, visualCol, cellMeta);
+
+      if (!this.metaSyncMemo.has(physicalRow)) {
+        this.metaSyncMemo.set(physicalRow, new Set());
+      }
+
+      this.metaSyncMemo.get(physicalRow).add(physicalColumn);
+    }
+  }]);
+
+  return DynamicCellMetaMod;
+}();
+
+exports.DynamicCellMetaMod = DynamicCellMetaMod;

package/dataMap/metaManager/mods/dynamicCellMeta.mjs

@@ -0,0 +1,119 @@
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.map.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.string.iterator.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+import "core-js/modules/es.set.js";
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+import Hooks from "../../../pluginHooks.mjs";
+import { hasOwnProperty } from "../../../helpers/object.mjs";
+import { isFunction } from "../../../helpers/function.mjs";
+/**
+ * @class DynamicCellMetaMod
+ *
+ * The `DynamicCellMetaMod` modifier allows for extending cell meta objects
+ * (returned by `getCellMeta()` from `MetaManager`)
+ * by user-specific properties.
+ *
+ * The user-specific properties can be added and changed dynamically,
+ * either by Handsontable's hooks (`beforeGetCellMeta` and`afterGetCellMeta`),
+ * or by Handsontable's `cells` option.
+ *
+ * The `getCellMeta()` method is used widely throughout the source code.
+ * To boost the method's execution time,
+ * the logic is triggered only once per one Handsontable slow render cycle.
+ */
+
+export var DynamicCellMetaMod = /*#__PURE__*/function () {
+  function DynamicCellMetaMod(metaManager) {
+    var _this = this;
+
+    _classCallCheck(this, DynamicCellMetaMod);
+
+    /**
+     * @type {MetaManager}
+     */
+    this.metaManager = metaManager;
+    /**
+     * @type {Map}
+     */
+
+    this.metaSyncMemo = new Map();
+    metaManager.addLocalHook('afterGetCellMeta', function (cellMeta) {
+      return _this.extendCellMeta(cellMeta);
+    });
+    Hooks.getSingleton().add('beforeRender', function (forceFullRender) {
+      if (forceFullRender) {
+        _this.metaSyncMemo.clear();
+      }
+    }, this.metaManager.hot);
+  }
+  /**
+   * Extends the cell meta object by user-specific properties.
+   *
+   * The cell meta object can be extended dynamically,
+   * either by Handsontable's hooks (`beforeGetCellMeta` and`afterGetCellMeta`),
+   * or by Handsontable's `cells` option.
+   *
+   * To boost performance, the extending process is triggered only once per one slow Handsontable render cycle.
+   *
+   * @param {object} cellMeta The cell meta object.
+   */
+
+
+  _createClass(DynamicCellMetaMod, [{
+    key: "extendCellMeta",
+    value: function extendCellMeta(cellMeta) {
+      var _this$metaSyncMemo$ge;
+
+      var physicalRow = cellMeta.row,
+          physicalColumn = cellMeta.col;
+
+      if ((_this$metaSyncMemo$ge = this.metaSyncMemo.get(physicalRow)) !== null && _this$metaSyncMemo$ge !== void 0 && _this$metaSyncMemo$ge.has(physicalColumn)) {
+        return;
+      }
+
+      var visualRow = cellMeta.visualRow,
+          visualCol = cellMeta.visualCol;
+      var hot = this.metaManager.hot;
+      var prop = hot.colToProp(visualCol);
+      cellMeta.prop = prop;
+      hot.runHooks('beforeGetCellMeta', visualRow, visualCol, cellMeta); // extend a `type` value, added or changed in the `beforeGetCellMeta` hook
+
+      var cellType = hasOwnProperty(cellMeta, 'type') ? cellMeta.type : null;
+      var cellSettings = isFunction(cellMeta.cells) ? cellMeta.cells(physicalRow, physicalColumn, prop) : null;
+
+      if (cellType) {
+        if (cellSettings) {
+          var _cellSettings$type;
+
+          cellSettings.type = (_cellSettings$type = cellSettings.type) !== null && _cellSettings$type !== void 0 ? _cellSettings$type : cellType;
+        } else {
+          cellSettings = {
+            type: cellType
+          };
+        }
+      }
+
+      if (cellSettings) {
+        this.metaManager.updateCellMeta(physicalRow, physicalColumn, cellSettings);
+      }
+
+      hot.runHooks('afterGetCellMeta', visualRow, visualCol, cellMeta);
+
+      if (!this.metaSyncMemo.has(physicalRow)) {
+        this.metaSyncMemo.set(physicalRow, new Set());
+      }
+
+      this.metaSyncMemo.get(physicalRow).add(physicalColumn);
+    }
+  }]);
+
+  return DynamicCellMetaMod;
+}();

package/dataMap/metaManager/utils.js

@@ -1,11 +1,11 @@
 "use strict";
 
 exports.__esModule = true;
-exports.expandMetaType = expandMetaType;
-exports.columnFactory = columnFactory;
-exports.isUnsignedNumber = isUnsignedNumber;
 exports.assert = assert;
+exports.columnFactory = columnFactory;
+exports.expandMetaType = expandMetaType;
 exports.isNullish = isNullish;
+exports.isUnsignedNumber = isUnsignedNumber;
 
 require("core-js/modules/es.number.is-integer.js");
 

package/dataMap/replaceData.js

@@ -0,0 +1,154 @@
+"use strict";
+
+exports.__esModule = true;
+exports.replaceData = replaceData;
+
+require("core-js/modules/es.array.splice.js");
+
+require("core-js/modules/es.array.concat.js");
+
+require("core-js/modules/es.symbol.js");
+
+require("core-js/modules/es.symbol.description.js");
+
+require("core-js/modules/es.object.to-string.js");
+
+require("core-js/modules/es.symbol.iterator.js");
+
+require("core-js/modules/es.array.iterator.js");
+
+require("core-js/modules/es.string.iterator.js");
+
+require("core-js/modules/web.dom-collections.iterator.js");
+
+var _string = require("../helpers/string");
+
+var _function = require("../helpers/function");
+
+var _dataMap = _interopRequireDefault(require("./dataMap"));
+
+var _object = require("../helpers/object");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: 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); }
+
+/**
+ * Loads new data to Handsontable.
+ *
+ * @private
+ * @param {Array} data Array of arrays or array of objects containing data.
+ * @param {Function} setDataMapFunction Function that updates the datamap instance.
+ * @param {Function} callbackFunction Function that takes care of updating Handsontable to the new dataset. Called
+ * right before the `after-` hooks.
+ * @param {object} config The configuration object containing all the needed dependency references and information.
+ * @param {Handsontable.Core} config.hotInstance The Handsontable instance.
+ * @param {DataMap} config.dataMap The current `dataMap` instance.
+ * @param {DataSource} config.dataSource The current `dataSource` instance.
+ * @param {string} config.internalSource The immediate internal source of the `replaceData` call.
+ * @param {string} config.source The source of the call.
+ * @param {boolean} config.firstRun `true` if it's a first call in the Handsontable lifecycle, `false` otherwise.
+ * @fires Hooks#beforeLoadData
+ * @fires Hooks#beforeUpdateData
+ * @fires Hooks#afterLoadData
+ * @fires Hooks#afterUpdateData
+ * @fires Hooks#afterChange
+ */
+function replaceData(data, setDataMapFunction, callbackFunction, config) {
+  var hotInstance = config.hotInstance,
+      dataMap = config.dataMap,
+      dataSource = config.dataSource,
+      internalSource = config.internalSource,
+      source = config.source,
+      firstRun = config.firstRun;
+  var capitalizedInternalSource = (0, _string.toUpperCaseFirst)(internalSource);
+  var tableMeta = hotInstance.getSettings();
+
+  if (Array.isArray(tableMeta.dataSchema)) {
+    hotInstance.dataType = 'array';
+  } else if ((0, _function.isFunction)(tableMeta.dataSchema)) {
+    hotInstance.dataType = 'function';
+  } else {
+    hotInstance.dataType = 'object';
+  }
+
+  if (dataMap) {
+    dataMap.destroy();
+  }
+
+  data = hotInstance.runHooks("before".concat(capitalizedInternalSource), data, firstRun, source); // TODO: deprecated, will be eventually removed, leaving only the `beforeUpdateData` hook.
+  //  Triggers an additional `afterLoadData` hook for the `updateSettings` calls for backward compatibility.
+
+  if (internalSource !== 'loadData' && source === 'updateSettings') {
+    data = hotInstance.runHooks('beforeLoadData', data, firstRun, source);
+  }
+
+  var newDataMap = new _dataMap.default(hotInstance, data, tableMeta); // We need to apply the new dataMap immediately, because of some asynchronous logic in the
+  // `autoRowSize`/`autoColumnSize` plugins.
+
+  setDataMapFunction(newDataMap);
+
+  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 = newDataMap.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 ((hotInstance.dataType === 'object' || hotInstance.dataType === 'function') && tableMeta.dataSchema) {
+        row = (0, _object.deepClone)(dataSchema);
+        data.push(row);
+      } else if (hotInstance.dataType === 'array') {
+        row = (0, _object.deepClone)(dataSchema[0]);
+        data.push(row);
+      } else {
+        row = [];
+
+        for (var c = 0, clen = tableMeta.startCols; c < clen; c++) {
+          row.push(null);
+        }
+
+        data.push(row);
+      }
+    }
+  } else {
+    throw new Error("".concat(internalSource, " only accepts array of objects or array of arrays (").concat(_typeof(data), " given)"));
+  }
+
+  if (Array.isArray(data[0])) {
+    hotInstance.dataType = 'array';
+  }
+
+  tableMeta.data = data;
+  newDataMap.dataSource = data;
+  dataSource.data = data;
+  dataSource.dataType = hotInstance.dataType;
+  dataSource.colToProp = newDataMap.colToProp.bind(newDataMap);
+  dataSource.propToCol = newDataMap.propToCol.bind(newDataMap);
+  dataSource.countCachedColumns = newDataMap.countCachedColumns.bind(newDataMap); // Run the logic for reassuring that the table structure fits the new dataset.
+
+  callbackFunction(newDataMap);
+  hotInstance.runHooks("after".concat(capitalizedInternalSource), data, firstRun, source); // TODO: deprecated, will be eventually removed, leaving only the `afterUpdateData` hook.
+  //  Triggers an additional `afterLoadData` hook for the `updateSettings` calls for backward compatibility.
+
+  if (internalSource !== 'loadData' && source === 'updateSettings') {
+    hotInstance.runHooks('afterLoadData', data, firstRun, source);
+  } // TODO: rethink the way the `afterChange` hook is being run here in the core `init` method.
+
+
+  if (!firstRun) {
+    // TODO: `afterChange` still needs to provide `loadData` as a `source` when called from `updateSettings` to keep
+    //  backward compatibility - to be changed after removing `loadData`.
+    hotInstance.runHooks('afterChange', null, source === 'updateSettings' ? 'loadData' : internalSource);
+    hotInstance.render();
+  }
+}

package/dataMap/replaceData.mjs

@@ -0,0 +1,138 @@
+import "core-js/modules/es.array.splice.js";
+import "core-js/modules/es.array.concat.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/es.string.iterator.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+
+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 { toUpperCaseFirst } from "../helpers/string.mjs";
+import { isFunction } from "../helpers/function.mjs";
+import DataMap from "./dataMap.mjs";
+import { deepClone } from "../helpers/object.mjs";
+/**
+ * Loads new data to Handsontable.
+ *
+ * @private
+ * @param {Array} data Array of arrays or array of objects containing data.
+ * @param {Function} setDataMapFunction Function that updates the datamap instance.
+ * @param {Function} callbackFunction Function that takes care of updating Handsontable to the new dataset. Called
+ * right before the `after-` hooks.
+ * @param {object} config The configuration object containing all the needed dependency references and information.
+ * @param {Handsontable.Core} config.hotInstance The Handsontable instance.
+ * @param {DataMap} config.dataMap The current `dataMap` instance.
+ * @param {DataSource} config.dataSource The current `dataSource` instance.
+ * @param {string} config.internalSource The immediate internal source of the `replaceData` call.
+ * @param {string} config.source The source of the call.
+ * @param {boolean} config.firstRun `true` if it's a first call in the Handsontable lifecycle, `false` otherwise.
+ * @fires Hooks#beforeLoadData
+ * @fires Hooks#beforeUpdateData
+ * @fires Hooks#afterLoadData
+ * @fires Hooks#afterUpdateData
+ * @fires Hooks#afterChange
+ */
+
+function replaceData(data, setDataMapFunction, callbackFunction, config) {
+  var hotInstance = config.hotInstance,
+      dataMap = config.dataMap,
+      dataSource = config.dataSource,
+      internalSource = config.internalSource,
+      source = config.source,
+      firstRun = config.firstRun;
+  var capitalizedInternalSource = toUpperCaseFirst(internalSource);
+  var tableMeta = hotInstance.getSettings();
+
+  if (Array.isArray(tableMeta.dataSchema)) {
+    hotInstance.dataType = 'array';
+  } else if (isFunction(tableMeta.dataSchema)) {
+    hotInstance.dataType = 'function';
+  } else {
+    hotInstance.dataType = 'object';
+  }
+
+  if (dataMap) {
+    dataMap.destroy();
+  }
+
+  data = hotInstance.runHooks("before".concat(capitalizedInternalSource), data, firstRun, source); // TODO: deprecated, will be eventually removed, leaving only the `beforeUpdateData` hook.
+  //  Triggers an additional `afterLoadData` hook for the `updateSettings` calls for backward compatibility.
+
+  if (internalSource !== 'loadData' && source === 'updateSettings') {
+    data = hotInstance.runHooks('beforeLoadData', data, firstRun, source);
+  }
+
+  var newDataMap = new DataMap(hotInstance, data, tableMeta); // We need to apply the new dataMap immediately, because of some asynchronous logic in the
+  // `autoRowSize`/`autoColumnSize` plugins.
+
+  setDataMapFunction(newDataMap);
+
+  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 = newDataMap.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 ((hotInstance.dataType === 'object' || hotInstance.dataType === 'function') && tableMeta.dataSchema) {
+        row = deepClone(dataSchema);
+        data.push(row);
+      } else if (hotInstance.dataType === 'array') {
+        row = deepClone(dataSchema[0]);
+        data.push(row);
+      } else {
+        row = [];
+
+        for (var c = 0, clen = tableMeta.startCols; c < clen; c++) {
+          row.push(null);
+        }
+
+        data.push(row);
+      }
+    }
+  } else {
+    throw new Error("".concat(internalSource, " only accepts array of objects or array of arrays (").concat(_typeof(data), " given)"));
+  }
+
+  if (Array.isArray(data[0])) {
+    hotInstance.dataType = 'array';
+  }
+
+  tableMeta.data = data;
+  newDataMap.dataSource = data;
+  dataSource.data = data;
+  dataSource.dataType = hotInstance.dataType;
+  dataSource.colToProp = newDataMap.colToProp.bind(newDataMap);
+  dataSource.propToCol = newDataMap.propToCol.bind(newDataMap);
+  dataSource.countCachedColumns = newDataMap.countCachedColumns.bind(newDataMap); // Run the logic for reassuring that the table structure fits the new dataset.
+
+  callbackFunction(newDataMap);
+  hotInstance.runHooks("after".concat(capitalizedInternalSource), data, firstRun, source); // TODO: deprecated, will be eventually removed, leaving only the `afterUpdateData` hook.
+  //  Triggers an additional `afterLoadData` hook for the `updateSettings` calls for backward compatibility.
+
+  if (internalSource !== 'loadData' && source === 'updateSettings') {
+    hotInstance.runHooks('afterLoadData', data, firstRun, source);
+  } // TODO: rethink the way the `afterChange` hook is being run here in the core `init` method.
+
+
+  if (!firstRun) {
+    // TODO: `afterChange` still needs to provide `loadData` as a `source` when called from `updateSettings` to keep
+    //  backward compatibility - to be changed after removing `loadData`.
+    hotInstance.runHooks('afterChange', null, source === 'updateSettings' ? 'loadData' : internalSource);
+    hotInstance.render();
+  }
+}
+
+export { replaceData };

package/dataSource.js

@@ -7,6 +7,8 @@ require("core-js/modules/es.number.is-integer.js");
 
 require("core-js/modules/es.number.constructor.js");
 
+require("core-js/modules/es.object.to-string.js");
+
 require("core-js/modules/web.dom-collections.for-each.js");
 
 var _object = require("./helpers/object");
@@ -23,7 +25,7 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
 
 function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
 
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
 
 /**
  * @class DataSource

package/dataSource.mjs

@@ -1,12 +1,13 @@
 import "core-js/modules/es.number.is-integer.js";
 import "core-js/modules/es.number.constructor.js";
+import "core-js/modules/es.object.to-string.js";
 import "core-js/modules/web.dom-collections.for-each.js";
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
 function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
 
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
 
 import { createObjectPropListener, getProperty, isObject, objectEach, setProperty } from "./helpers/object.mjs";
 import { countFirstRowKeys as _countFirstRowKeys } from "./helpers/data.mjs";

package/dist/README.md

@@ -39,7 +39,7 @@ If you are a "Bob the Builder" kind of hacker, you will need to load Handsontabl
 ## Internationalization
 It is possible to include files which will register languages dictionaries. They allow to translate parts of Handsontable UI. You can either use only particular languages files or include all of them at once as a single file.
 
-All the information about the API and additional options can be found at our [official documentation](https://handsontable.com/docs/tutorial-internationalization.html).
+All the information about the API and additional options can be found at our [official documentation](https://handsontable.com/docs/internationalization-i18n/).
 
 ```html
 <!-- Internationalization, Polish - Poland language-country file -->
@@ -51,4 +51,4 @@ All the information about the API and additional options can be found at our [of
 
 ## Custom distribution
 
-If you want to build your own custom Handsontable package distribution check out our [guide](https://docs.handsontable.com/tutorial-custom-build.html) covering all the details.
+If you want to build your own custom Handsontable package distribution check out our [guide](https://handsontable.com/docs/building/) covering all the details.