@lowentry/utils 1.17.1 → 1.19.1

package/index.js

@@ -8,6 +8,12 @@ import _wrapAsyncGenerator from '@babel/runtime/helpers/wrapAsyncGenerator';
 import _regeneratorRuntime from '@babel/runtime/regenerator';
 import FastDeepEqual from 'fast-deep-equal';
 import CloneDeep from 'clone-deep';
+import _createClass from '@babel/runtime/helpers/createClass';
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _possibleConstructorReturn from '@babel/runtime/helpers/possibleConstructorReturn';
+import _getPrototypeOf from '@babel/runtime/helpers/getPrototypeOf';
+import _inherits from '@babel/runtime/helpers/inherits';
+import _wrapNativeSuper from '@babel/runtime/helpers/wrapNativeSuper';
 
 var REGEX_ALL_NON_FLOAT_CHARACTERS = /[^0-9.\-]/g;
 
@@ -689,7 +695,7 @@ var LeUtils = {
    *
    * @param {*} elements
    * @param {boolean} [optionalSkipHasOwnPropertyCheck]
-   * @returns {Generator<*, void, *>}
+   * @yields {[key:*, value:*]}
    */
   eachIterator: function eachIterator(elements) {
     var optionalSkipHasOwnPropertyCheck = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
@@ -3518,5 +3524,166 @@ var LeUtils = {
   }()
 };
 
-export { ARRAY, FLOAT, FLOAT_ANY, FLOAT_LAX, FLOAT_LAX_ANY, INT, INT_ANY, INT_LAX, INT_LAX_ANY, ISSET, IS_ARRAY, IS_OBJECT, LeUtils, OBJECT, STRING, STRING_ANY };
+function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
+function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
+function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
+function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
+var LinkedListNode = /*#__PURE__*/_createClass(
+/**
+ * @param {*} value
+ */
+function LinkedListNode(value) {
+  _classCallCheck(this, LinkedListNode);
+  /** @type {*} */
+  _defineProperty(this, "value", void 0);
+  /** @type {LinkedListNode|null} */
+  _defineProperty(this, "next", null);
+  /** @type {LinkedListNode|null} */
+  _defineProperty(this, "previous", null);
+  this.value = value;
+});
+var _head = /*#__PURE__*/new WeakMap();
+var _tail = /*#__PURE__*/new WeakMap();
+var _size = /*#__PURE__*/new WeakMap();
+var LinkedList = /*#__PURE__*/function () {
+  function LinkedList() {
+    _classCallCheck(this, LinkedList);
+    /** @type {LinkedListNode|null} */
+    _classPrivateFieldInitSpec(this, _head, null);
+    /** @type {LinkedListNode|null} */
+    _classPrivateFieldInitSpec(this, _tail, null);
+    /** @type {number} */
+    _classPrivateFieldInitSpec(this, _size, 0);
+  }
+
+  /**
+   * Returns the number of elements in the list.
+   *
+   * @returns {number}
+   */
+  return _createClass(LinkedList, [{
+    key: "size",
+    get: function get() {
+      return _classPrivateFieldGet(_size, this);
+    }
+
+    /**
+     * Adds a new value to the beginning of the list.
+     *
+     * @param {*} value
+     */
+  }, {
+    key: "unshift",
+    value: function unshift(value) {
+      var _this$size;
+      var newNode = new LinkedListNode(value);
+      if (_classPrivateFieldGet(_head, this) === null) {
+        _classPrivateFieldSet(_head, this, newNode);
+        _classPrivateFieldSet(_tail, this, newNode);
+      } else {
+        newNode.next = _classPrivateFieldGet(_head, this);
+        _classPrivateFieldGet(_head, this).previous = newNode;
+        _classPrivateFieldSet(_head, this, newNode);
+      }
+      _classPrivateFieldSet(_size, this, (_this$size = _classPrivateFieldGet(_size, this), _this$size++, _this$size));
+    }
+
+    /**
+     * Adds a new value to the end of the list.
+     *
+     * @param {*} value
+     */
+  }, {
+    key: "push",
+    value: function push(value) {
+      var _this$size3;
+      var newNode = new LinkedListNode(value);
+      if (_classPrivateFieldGet(_tail, this) === null) {
+        _classPrivateFieldSet(_head, this, newNode);
+        _classPrivateFieldSet(_tail, this, newNode);
+      } else {
+        newNode.previous = _classPrivateFieldGet(_tail, this);
+        _classPrivateFieldGet(_tail, this).next = newNode;
+        _classPrivateFieldSet(_tail, this, newNode);
+      }
+      _classPrivateFieldSet(_size, this, (_this$size3 = _classPrivateFieldGet(_size, this), _this$size3++, _this$size3));
+    }
+
+    /**
+     * Removes the first value from the list and returns it.
+     *
+     * @returns {*|undefined}
+     */
+  }, {
+    key: "shift",
+    value: function shift() {
+      var _this$size5;
+      if (_classPrivateFieldGet(_head, this) === null) {
+        return undefined;
+      }
+      var value = _classPrivateFieldGet(_head, this).value;
+      _classPrivateFieldSet(_head, this, _classPrivateFieldGet(_head, this).next);
+      if (_classPrivateFieldGet(_head, this) !== null) {
+        _classPrivateFieldGet(_head, this).previous = null;
+      } else {
+        _classPrivateFieldSet(_tail, this, null);
+      }
+      _classPrivateFieldSet(_size, this, (_this$size5 = _classPrivateFieldGet(_size, this), _this$size5--, _this$size5));
+      return value;
+    }
+
+    /**
+     * Removes the last value from the list and returns it.
+     *
+     * @returns {*|undefined}
+     */
+  }, {
+    key: "pop",
+    value: function pop() {
+      var _this$size7;
+      if (_classPrivateFieldGet(_tail, this) === null) {
+        return undefined;
+      }
+      var value = _classPrivateFieldGet(_tail, this).value;
+      _classPrivateFieldSet(_tail, this, _classPrivateFieldGet(_tail, this).previous);
+      if (_classPrivateFieldGet(_tail, this) !== null) {
+        _classPrivateFieldGet(_tail, this).next = null;
+      } else {
+        _classPrivateFieldSet(_head, this, null);
+      }
+      _classPrivateFieldSet(_size, this, (_this$size7 = _classPrivateFieldGet(_size, this), _this$size7--, _this$size7));
+      return value;
+    }
+  }]);
+}();
+
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+/**
+ * SerializableMap class extends the native Map to provide a JSON representation.
+ *
+ * This class can only have string keys, as JSON does not support non-string keys.
+ */
+var SerializableMap = /*#__PURE__*/function (_Map) {
+  function SerializableMap() {
+    _classCallCheck(this, SerializableMap);
+    return _callSuper(this, SerializableMap, arguments);
+  }
+  _inherits(SerializableMap, _Map);
+  return _createClass(SerializableMap, [{
+    key: "toJSON",
+    value:
+    /**
+     * Returns a JSON representation of the map.
+     *
+     * @returns {object}
+     */
+    function toJSON() {
+      return Object.fromEntries(this);
+    }
+  }]);
+}(/*#__PURE__*/_wrapNativeSuper(Map));
+
+export { ARRAY, FLOAT, FLOAT_ANY, FLOAT_LAX, FLOAT_LAX_ANY, INT, INT_ANY, INT_LAX, INT_LAX_ANY, ISSET, IS_ARRAY, IS_OBJECT, LeUtils, LinkedList, OBJECT, STRING, STRING_ANY, SerializableMap };
 //# sourceMappingURL=index.js.map