handsontable 0.0.0-next-b66c79f-20230713 → 0.0.0-next-08765b9-20230714

package/translations/changesObservable/observable.mjs

@@ -1,3 +1,11 @@
+import "core-js/modules/es.error.cause.js";
+function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
+function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
+function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
+function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
+function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
 import { ChangesObserver } from "./observer.mjs";
 import { arrayDiff } from "./utils.mjs";
 /**
@@ -8,53 +16,73 @@ import { arrayDiff } from "./utils.mjs";
  * @private
  * @class ChangesObservable
  */
+var _observers = /*#__PURE__*/new WeakMap();
+var _indexMatrix = /*#__PURE__*/new WeakMap();
+var _currentIndexState = /*#__PURE__*/new WeakMap();
+var _isMatrixIndexesInitialized = /*#__PURE__*/new WeakMap();
+var _initialIndexValue = /*#__PURE__*/new WeakMap();
 export class ChangesObservable {
-  /**
-   * The list of registered ChangesObserver instances.
-   *
-   * @type {ChangesObserver[]}
-   */
-  #observers = new Set();
-  /**
-   * An array with default values that act as a base array that will be compared with
-   * the last saved index state. The changes are generated and immediately send through
-   * the newly created ChangesObserver object. Thanks to that, the observer initially has
-   * all information about what indexes are currently changed.
-   *
-   * @type {Array}
-   */
-  #indexMatrix = [];
-  /**
-   * An array that holds the indexes state that is currently valid. The value is changed on every
-   * index mapper cache update.
-   *
-   * @type {Array}
-   */
-  #currentIndexState = [];
-  /**
-   * The flag determines if the observable is initialized or not. Not initialized object creates
-   * index matrix once while emitting new changes.
-   *
-   * @type {boolean}
-   */
-  #isMatrixIndexesInitialized = false;
-  /**
-   * The initial index value allows control from what value the index matrix array will be created.
-   * Changing that value changes how the array diff generates the changes for the initial data
-   * sent to the subscribers. For example, the changes can be triggered by detecting the changes
-   * from `false` to `true` value or vice versa. Generally, it depends on which index map type
-   * the Observable will work with. For "hiding" or "trimming" index types, it will be boolean
-   * values. For various index maps, it can be anything, but I suspect that the most appropriate
-   * initial value will be "undefined" in that case.
-   *
-   * @type {boolean}
-   */
-  #initialIndexValue = false;
   constructor() {
     let {
       initialIndexValue
     } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    this.#initialIndexValue = initialIndexValue != null ? initialIndexValue : false;
+    /**
+     * The list of registered ChangesObserver instances.
+     *
+     * @type {ChangesObserver[]}
+     */
+    _classPrivateFieldInitSpec(this, _observers, {
+      writable: true,
+      value: new Set()
+    });
+    /**
+     * An array with default values that act as a base array that will be compared with
+     * the last saved index state. The changes are generated and immediately send through
+     * the newly created ChangesObserver object. Thanks to that, the observer initially has
+     * all information about what indexes are currently changed.
+     *
+     * @type {Array}
+     */
+    _classPrivateFieldInitSpec(this, _indexMatrix, {
+      writable: true,
+      value: []
+    });
+    /**
+     * An array that holds the indexes state that is currently valid. The value is changed on every
+     * index mapper cache update.
+     *
+     * @type {Array}
+     */
+    _classPrivateFieldInitSpec(this, _currentIndexState, {
+      writable: true,
+      value: []
+    });
+    /**
+     * The flag determines if the observable is initialized or not. Not initialized object creates
+     * index matrix once while emitting new changes.
+     *
+     * @type {boolean}
+     */
+    _classPrivateFieldInitSpec(this, _isMatrixIndexesInitialized, {
+      writable: true,
+      value: false
+    });
+    /**
+     * The initial index value allows control from what value the index matrix array will be created.
+     * Changing that value changes how the array diff generates the changes for the initial data
+     * sent to the subscribers. For example, the changes can be triggered by detecting the changes
+     * from `false` to `true` value or vice versa. Generally, it depends on which index map type
+     * the Observable will work with. For "hiding" or "trimming" index types, it will be boolean
+     * values. For various index maps, it can be anything, but I suspect that the most appropriate
+     * initial value will be "undefined" in that case.
+     *
+     * @type {boolean}
+     */
+    _classPrivateFieldInitSpec(this, _initialIndexValue, {
+      writable: true,
+      value: false
+    });
+    _classPrivateFieldSet(this, _initialIndexValue, initialIndexValue !== null && initialIndexValue !== void 0 ? initialIndexValue : false);
   }
 
   /* eslint-disable jsdoc/require-description-complete-sentence */
@@ -83,11 +111,11 @@ export class ChangesObservable {
   /* eslint-enable jsdoc/require-description-complete-sentence */
   createObserver() {
     const observer = new ChangesObserver();
-    this.#observers.add(observer);
+    _classPrivateFieldGet(this, _observers).add(observer);
     observer.addLocalHook('unsubscribe', () => {
-      this.#observers.delete(observer);
+      _classPrivateFieldGet(this, _observers).delete(observer);
     });
-    observer._writeInitialChanges(arrayDiff(this.#indexMatrix, this.#currentIndexState));
+    observer._writeInitialChanges(arrayDiff(_classPrivateFieldGet(this, _indexMatrix), _classPrivateFieldGet(this, _currentIndexState)));
     return observer;
   }
 
@@ -99,20 +127,20 @@ export class ChangesObservable {
    * @param {Array} indexesState An array with index map state.
    */
   emit(indexesState) {
-    let currentIndexState = this.#currentIndexState;
-    if (!this.#isMatrixIndexesInitialized || this.#indexMatrix.length !== indexesState.length) {
+    let currentIndexState = _classPrivateFieldGet(this, _currentIndexState);
+    if (!_classPrivateFieldGet(this, _isMatrixIndexesInitialized) || _classPrivateFieldGet(this, _indexMatrix).length !== indexesState.length) {
       if (indexesState.length === 0) {
-        indexesState = new Array(currentIndexState.length).fill(this.#initialIndexValue);
+        indexesState = new Array(currentIndexState.length).fill(_classPrivateFieldGet(this, _initialIndexValue));
       } else {
-        this.#indexMatrix = new Array(indexesState.length).fill(this.#initialIndexValue);
+        _classPrivateFieldSet(this, _indexMatrix, new Array(indexesState.length).fill(_classPrivateFieldGet(this, _initialIndexValue)));
       }
-      if (!this.#isMatrixIndexesInitialized) {
-        this.#isMatrixIndexesInitialized = true;
-        currentIndexState = this.#indexMatrix;
+      if (!_classPrivateFieldGet(this, _isMatrixIndexesInitialized)) {
+        _classPrivateFieldSet(this, _isMatrixIndexesInitialized, true);
+        currentIndexState = _classPrivateFieldGet(this, _indexMatrix);
       }
     }
     const changes = arrayDiff(currentIndexState, indexesState);
-    this.#observers.forEach(observer => observer._write(changes));
-    this.#currentIndexState = indexesState;
+    _classPrivateFieldGet(this, _observers).forEach(observer => observer._write(changes));
+    _classPrivateFieldSet(this, _currentIndexState, indexesState);
   }
 }

package/translations/changesObservable/observer.js

@@ -1,25 +1,38 @@
 "use strict";
 
+require("core-js/modules/es.error.cause.js");
 exports.__esModule = true;
 var _object = require("../../helpers/object");
 var _localHooks = _interopRequireDefault(require("../../mixins/localHooks"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
+function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
+function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
+function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
+function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
 /**
  * The ChangesObserver module is an object that represents a disposable resource
  * provided by the ChangesObservable module.
  *
  * @class ChangesObserver
  */
+var _currentInitialChanges = /*#__PURE__*/new WeakMap();
 class ChangesObserver {
-  /**
-   * The field holds initial changes that will be used to notify the callbacks added using
-   * subscribe method. Regardless of the moment of listening for changes, the subscriber
-   * will be notified once with all changes made before subscribing.
-   *
-   * @type {Array}
-   */
-  #currentInitialChanges = [];
-
+  constructor() {
+    /**
+     * The field holds initial changes that will be used to notify the callbacks added using
+     * subscribe method. Regardless of the moment of listening for changes, the subscriber
+     * will be notified once with all changes made before subscribing.
+     *
+     * @type {Array}
+     */
+    _classPrivateFieldInitSpec(this, _currentInitialChanges, {
+      writable: true,
+      value: []
+    });
+  }
   /**
    * Subscribes to the observer.
    *
@@ -28,7 +41,7 @@ class ChangesObserver {
    */
   subscribe(callback) {
     this.addLocalHook('change', callback);
-    this._write(this.#currentInitialChanges);
+    this._write(_classPrivateFieldGet(this, _currentInitialChanges));
     return this;
   }
 
@@ -67,7 +80,7 @@ class ChangesObserver {
    * @param {object} initialChanges The chunk of changes produced by the ChangesObservable module.
    */
   _writeInitialChanges(initialChanges) {
-    this.#currentInitialChanges = initialChanges;
+    _classPrivateFieldSet(this, _currentInitialChanges, initialChanges);
   }
 }
 exports.ChangesObserver = ChangesObserver;

package/translations/changesObservable/observer.mjs

@@ -1,3 +1,11 @@
+import "core-js/modules/es.error.cause.js";
+function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
+function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
+function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
+function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
+function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
 import { mixin } from "../../helpers/object.mjs";
 import localHooks from "../../mixins/localHooks.mjs";
 /**
@@ -6,16 +14,21 @@ import localHooks from "../../mixins/localHooks.mjs";
  *
  * @class ChangesObserver
  */
+var _currentInitialChanges = /*#__PURE__*/new WeakMap();
 export class ChangesObserver {
-  /**
-   * The field holds initial changes that will be used to notify the callbacks added using
-   * subscribe method. Regardless of the moment of listening for changes, the subscriber
-   * will be notified once with all changes made before subscribing.
-   *
-   * @type {Array}
-   */
-  #currentInitialChanges = [];
-
+  constructor() {
+    /**
+     * The field holds initial changes that will be used to notify the callbacks added using
+     * subscribe method. Regardless of the moment of listening for changes, the subscriber
+     * will be notified once with all changes made before subscribing.
+     *
+     * @type {Array}
+     */
+    _classPrivateFieldInitSpec(this, _currentInitialChanges, {
+      writable: true,
+      value: []
+    });
+  }
   /**
    * Subscribes to the observer.
    *
@@ -24,7 +37,7 @@ export class ChangesObserver {
    */
   subscribe(callback) {
     this.addLocalHook('change', callback);
-    this._write(this.#currentInitialChanges);
+    this._write(_classPrivateFieldGet(this, _currentInitialChanges));
     return this;
   }
 
@@ -63,7 +76,7 @@ export class ChangesObserver {
    * @param {object} initialChanges The chunk of changes produced by the ChangesObservable module.
    */
   _writeInitialChanges(initialChanges) {
-    this.#currentInitialChanges = initialChanges;
+    _classPrivateFieldSet(this, _currentInitialChanges, initialChanges);
   }
 }
 mixin(ChangesObserver, localHooks);

package/translations/maps/linkedPhysicalIndexToValueMap.js

@@ -1,11 +1,15 @@
 "use strict";
 
 exports.__esModule = true;
+require("core-js/modules/es.error.cause.js");
 var _indexMap = require("./indexMap");
 var _physicallyIndexed = require("./utils/physicallyIndexed");
 var _indexesSequence = require("./utils/indexesSequence");
 var _actionsOnIndexes = require("./utils/actionsOnIndexes");
 var _function = require("../../helpers/function");
+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); }
 /**
  * Map for storing mappings from an physical index to a value. Those entries are linked and stored in a certain order.
  *
@@ -15,14 +19,16 @@ var _function = require("../../helpers/function");
  * @class LinkedPhysicalIndexToValueMap
  */
 class LinkedPhysicalIndexToValueMap extends _indexMap.IndexMap {
-  /**
-   * Indexes and values corresponding to them (entries) are stored in a certain order.
-   *
-   * @private
-   * @type {Array<number>}
-   */
-  orderOfIndexes = [];
-
+  constructor() {
+    super(...arguments);
+    /**
+     * Indexes and values corresponding to them (entries) are stored in a certain order.
+     *
+     * @private
+     * @type {Array<number>}
+     */
+    _defineProperty(this, "orderOfIndexes", []);
+  }
   /**
    * Get full list of ordered values for particular indexes.
    *

package/translations/maps/linkedPhysicalIndexToValueMap.mjs

@@ -1,3 +1,7 @@
+import "core-js/modules/es.error.cause.js";
+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); }
 import { IndexMap } from "./indexMap.mjs";
 import { getListWithRemovedItems, getListWithInsertedItems } from "./utils/physicallyIndexed.mjs";
 import { getListWithRemovedItems as getListWithoutIndexes } from "./utils/indexesSequence.mjs";
@@ -12,14 +16,16 @@ import { isFunction } from "../../helpers/function.mjs";
  * @class LinkedPhysicalIndexToValueMap
  */
 export class LinkedPhysicalIndexToValueMap extends IndexMap {
-  /**
-   * Indexes and values corresponding to them (entries) are stored in a certain order.
-   *
-   * @private
-   * @type {Array<number>}
-   */
-  orderOfIndexes = [];
-
+  constructor() {
+    super(...arguments);
+    /**
+     * Indexes and values corresponding to them (entries) are stored in a certain order.
+     *
+     * @private
+     * @type {Array<number>}
+     */
+    _defineProperty(this, "orderOfIndexes", []);
+  }
   /**
    * Get full list of ordered values for particular indexes.
    *

package/utils/dataStructures/tree.js

@@ -4,6 +4,9 @@ exports.__esModule = true;
 exports.depthFirstPreOrder = depthFirstPreOrder;
 require("core-js/modules/es.array.push.js");
 require("core-js/modules/es.error.cause.js");
+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); }
 /**
  * Depth-first pre-order strategy (https://en.wikipedia.org/wiki/Tree_traversal#Pre-order_(NLR)).
  *
@@ -96,25 +99,25 @@ const TRAVERSAL_STRATEGIES = new Map([[TRAVERSAL_DF_PRE, depthFirstPreOrder], [T
  *
  */
 class TreeNode {
-  /**
-   * A tree data.
-   *
-   * @type {object}
-   */
-  data = {};
-  /**
-   * A parent node.
-   *
-   * @type {TreeNode}
-   */
-  parent = null;
-  /**
-   * A tree leaves.
-   *
-   * @type {TreeNode[]}
-   */
-  childs = [];
   constructor(data) {
+    /**
+     * A tree data.
+     *
+     * @type {object}
+     */
+    _defineProperty(this, "data", {});
+    /**
+     * A parent node.
+     *
+     * @type {TreeNode}
+     */
+    _defineProperty(this, "parent", null);
+    /**
+     * A tree leaves.
+     *
+     * @type {TreeNode[]}
+     */
+    _defineProperty(this, "childs", []);
     this.data = data;
   }
 

package/utils/dataStructures/tree.mjs

@@ -1,3 +1,6 @@
+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); }
 import "core-js/modules/es.array.push.js";
 import "core-js/modules/es.error.cause.js";
 /**
@@ -89,25 +92,25 @@ const TRAVERSAL_STRATEGIES = new Map([[TRAVERSAL_DF_PRE, depthFirstPreOrder], [T
  *
  */
 export default class TreeNode {
-  /**
-   * A tree data.
-   *
-   * @type {object}
-   */
-  data = {};
-  /**
-   * A parent node.
-   *
-   * @type {TreeNode}
-   */
-  parent = null;
-  /**
-   * A tree leaves.
-   *
-   * @type {TreeNode[]}
-   */
-  childs = [];
   constructor(data) {
+    /**
+     * A tree data.
+     *
+     * @type {object}
+     */
+    _defineProperty(this, "data", {});
+    /**
+     * A parent node.
+     *
+     * @type {TreeNode}
+     */
+    _defineProperty(this, "parent", null);
+    /**
+     * A tree leaves.
+     *
+     * @type {TreeNode[]}
+     */
+    _defineProperty(this, "childs", []);
     this.data = data;
   }