handsontable 11.0.0 → 12.0.0

package/dataMap/metaManager/mods/dynamicCellMeta.js

@@ -27,7 +27,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 DynamicCellMetaMod

package/dataMap/metaManager/mods/dynamicCellMeta.mjs

@@ -9,7 +9,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; }
 
 import Hooks from "../../../pluginHooks.mjs";
 import { hasOwnProperty } from "../../../helpers/object.mjs";

package/dataMap/metaManager/mods/extendMetaProperties.js

@@ -0,0 +1,126 @@
+"use strict";
+
+exports.__esModule = true;
+exports.ExtendMetaPropertiesMod = void 0;
+
+require("core-js/modules/es.array.iterator.js");
+
+require("core-js/modules/es.object.to-string.js");
+
+require("core-js/modules/es.set.js");
+
+require("core-js/modules/es.string.iterator.js");
+
+require("core-js/modules/web.dom-collections.iterator.js");
+
+require("core-js/modules/es.map.js");
+
+require("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); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+/**
+ * @class ExtendMetaPropertiesMod
+ */
+var ExtendMetaPropertiesMod = /*#__PURE__*/function () {
+  function ExtendMetaPropertiesMod(metaManager) {
+    _classCallCheck(this, ExtendMetaPropertiesMod);
+
+    /**
+     * @type {MetaManager}
+     */
+    this.metaManager = metaManager;
+    /**
+     * @type {Set}
+     */
+
+    this.usageTracker = new Set();
+    /**
+     * @type {Map}
+     */
+
+    this.propDescriptors = new Map([['fixedColumnsLeft', {
+      target: 'fixedColumnsStart',
+      onChange: function onChange(propName) {
+        var isRtl = this.metaManager.hot.isRtl();
+
+        if (isRtl && propName === 'fixedColumnsLeft') {
+          throw new Error('The `fixedColumnsLeft` is not supported for RTL. Please use option `fixedColumnsStart`.');
+        }
+
+        if (this.usageTracker.has('fixedColumnsLeft') && this.usageTracker.has('fixedColumnsStart')) {
+          throw new Error('The `fixedColumnsLeft` and `fixedColumnsStart` should not be used together. ' + 'Please use only the option `fixedColumnsStart`.');
+        }
+      }
+    }], ['layoutDirection', {
+      onChange: function onChange(propName, value, isInitialChange) {
+        if (!isInitialChange) {
+          throw new Error("The `".concat(propName, "` option can not be updated after the Handsontable is initialized."));
+        }
+      }
+    }]]);
+    this.extendMetaProps();
+  }
+  /**
+   * Extends the meta options based on the object descriptors from the `propDescriptors` list.
+   */
+
+
+  _createClass(ExtendMetaPropertiesMod, [{
+    key: "extendMetaProps",
+    value: function extendMetaProps() {
+      var _this = this;
+
+      this.propDescriptors.forEach(function (descriptor, alias) {
+        var target = descriptor.target,
+            _descriptor$onChange = descriptor.onChange,
+            onChange = _descriptor$onChange === void 0 ? function () {} : _descriptor$onChange;
+        var hasTarget = typeof target === 'string';
+        var targetProp = hasTarget ? target : alias;
+        var origProp = "_".concat(targetProp);
+        _this.metaManager.globalMeta.meta[origProp] = _this.metaManager.globalMeta.meta[targetProp];
+
+        _this.installPropWatcher(alias, origProp, onChange);
+
+        if (hasTarget) {
+          _this.installPropWatcher(target, origProp, onChange);
+        }
+      });
+    }
+    /**
+     * Installs the property watcher to the `propName` option and forwards getter and setter to
+     * the new one.
+     *
+     * @param {string} propName The property to watch.
+     * @param {string} origProp The property from/to the value is forwarded.
+     * @param {Function} onChange The callback.
+     */
+
+  }, {
+    key: "installPropWatcher",
+    value: function installPropWatcher(propName, origProp, onChange) {
+      var self = this;
+      Object.defineProperty(this.metaManager.globalMeta.meta, propName, {
+        get: function get() {
+          return this[origProp];
+        },
+        set: function set(value) {
+          var isInitialChange = !self.usageTracker.has(propName);
+          self.usageTracker.add(propName);
+          onChange.call(self, propName, value, isInitialChange);
+          this[origProp] = value;
+        },
+        enumerable: true,
+        configurable: true
+      });
+    }
+  }]);
+
+  return ExtendMetaPropertiesMod;
+}();
+
+exports.ExtendMetaPropertiesMod = ExtendMetaPropertiesMod;

package/dataMap/metaManager/mods/extendMetaProperties.mjs

@@ -0,0 +1,113 @@
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.set.js";
+import "core-js/modules/es.string.iterator.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+import "core-js/modules/es.map.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); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+/**
+ * @class ExtendMetaPropertiesMod
+ */
+export var ExtendMetaPropertiesMod = /*#__PURE__*/function () {
+  function ExtendMetaPropertiesMod(metaManager) {
+    _classCallCheck(this, ExtendMetaPropertiesMod);
+
+    /**
+     * @type {MetaManager}
+     */
+    this.metaManager = metaManager;
+    /**
+     * @type {Set}
+     */
+
+    this.usageTracker = new Set();
+    /**
+     * @type {Map}
+     */
+
+    this.propDescriptors = new Map([['fixedColumnsLeft', {
+      target: 'fixedColumnsStart',
+      onChange: function onChange(propName) {
+        var isRtl = this.metaManager.hot.isRtl();
+
+        if (isRtl && propName === 'fixedColumnsLeft') {
+          throw new Error('The `fixedColumnsLeft` is not supported for RTL. Please use option `fixedColumnsStart`.');
+        }
+
+        if (this.usageTracker.has('fixedColumnsLeft') && this.usageTracker.has('fixedColumnsStart')) {
+          throw new Error('The `fixedColumnsLeft` and `fixedColumnsStart` should not be used together. ' + 'Please use only the option `fixedColumnsStart`.');
+        }
+      }
+    }], ['layoutDirection', {
+      onChange: function onChange(propName, value, isInitialChange) {
+        if (!isInitialChange) {
+          throw new Error("The `".concat(propName, "` option can not be updated after the Handsontable is initialized."));
+        }
+      }
+    }]]);
+    this.extendMetaProps();
+  }
+  /**
+   * Extends the meta options based on the object descriptors from the `propDescriptors` list.
+   */
+
+
+  _createClass(ExtendMetaPropertiesMod, [{
+    key: "extendMetaProps",
+    value: function extendMetaProps() {
+      var _this = this;
+
+      this.propDescriptors.forEach(function (descriptor, alias) {
+        var target = descriptor.target,
+            _descriptor$onChange = descriptor.onChange,
+            onChange = _descriptor$onChange === void 0 ? function () {} : _descriptor$onChange;
+        var hasTarget = typeof target === 'string';
+        var targetProp = hasTarget ? target : alias;
+        var origProp = "_".concat(targetProp);
+        _this.metaManager.globalMeta.meta[origProp] = _this.metaManager.globalMeta.meta[targetProp];
+
+        _this.installPropWatcher(alias, origProp, onChange);
+
+        if (hasTarget) {
+          _this.installPropWatcher(target, origProp, onChange);
+        }
+      });
+    }
+    /**
+     * Installs the property watcher to the `propName` option and forwards getter and setter to
+     * the new one.
+     *
+     * @param {string} propName The property to watch.
+     * @param {string} origProp The property from/to the value is forwarded.
+     * @param {Function} onChange The callback.
+     */
+
+  }, {
+    key: "installPropWatcher",
+    value: function installPropWatcher(propName, origProp, onChange) {
+      var self = this;
+      Object.defineProperty(this.metaManager.globalMeta.meta, propName, {
+        get: function get() {
+          return this[origProp];
+        },
+        set: function set(value) {
+          var isInitialChange = !self.usageTracker.has(propName);
+          self.usageTracker.add(propName);
+          onChange.call(self, propName, value, isInitialChange);
+          this[origProp] = value;
+        },
+        enumerable: true,
+        configurable: true
+      });
+    }
+  }]);
+
+  return ExtendMetaPropertiesMod;
+}();

package/dataMap/replaceData.js

@@ -0,0 +1,140 @@
+"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);
+  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: rethink the way the `afterChange` hook is being run here in the core `init` method.
+
+  if (!firstRun) {
+    hotInstance.runHooks('afterChange', null, internalSource);
+    hotInstance.render();
+  }
+}

package/dataMap/replaceData.mjs

@@ -0,0 +1,124 @@
+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);
+  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: rethink the way the `afterChange` hook is being run here in the core `init` method.
+
+  if (!firstRun) {
+    hotInstance.runHooks('afterChange', null, internalSource);
+    hotInstance.render();
+  }
+}
+
+export { replaceData };

package/dataSource.js

@@ -25,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

@@ -7,7 +7,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; }
 
 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.