@jiovan-labs/ts-multi-map 0.0.0-stage → 2.0.0

package/dist/esm/util/MultiKeyMap.js

@@ -0,0 +1,318 @@
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+var _Symbol$iterator, _Symbol$toStringTag;
+import objectHash from 'object-hash';
+import { MultiValueMap } from "./..";
+_Symbol$iterator = Symbol.iterator;
+_Symbol$toStringTag = Symbol.toStringTag;
+export var MultiKeyMap = /*#__PURE__*/function () {
+  function MultiKeyMap(entries) {
+    var _this = this;
+    _classCallCheck(this, MultiKeyMap);
+    _defineProperty(this, "keyMap", new MultiValueMap());
+    _defineProperty(this, "valueMap", new Map());
+    entries === null || entries === void 0 || entries.forEach(function (entry) {
+      var _entry = _slicedToArray(entry, 2),
+        ks = _entry[0],
+        v = _entry[1];
+      _this.set(ks, v);
+    });
+  }
+  _createClass(MultiKeyMap, [{
+    key: "get",
+    value: function get(keys, defaults) {
+      var _this$valueMap$get;
+      if (keys.length == 0 || this.isEmpty()) {
+        return defaults;
+      }
+      var hash = objectHash(keys);
+      return (_this$valueMap$get = this.valueMap.get(hash)) !== null && _this$valueMap$get !== void 0 ? _this$valueMap$get : defaults;
+    }
+  }, {
+    key: "set",
+    value: function set(keys, value) {
+      if (keys.length == 0) {
+        return;
+      }
+      var hash = objectHash(keys);
+      this.keyMap.set(hash, _toConsumableArray(keys));
+      this.valueMap.set(hash, value);
+    }
+  }, {
+    key: "clear",
+    value: function clear() {
+      this.keyMap.clear();
+      this.valueMap.clear();
+    }
+  }, {
+    key: "keys",
+    value: function keys() {
+      return _toConsumableArray(this.keyMap.values());
+    }
+  }, {
+    key: "values",
+    value: function values() {
+      return _toConsumableArray(this.valueMap.values());
+    }
+  }, {
+    key: "entries",
+    value: function entries() {
+      if (this.isEmpty()) {
+        return [];
+      }
+      if (this.keyMap.size !== this.valueMap.size) {
+        throw EvalError("Internal maps size mismatch!");
+      }
+      var result = [];
+      var _iterator = _createForOfIteratorHelper(this.valueMap),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _this$keyMap$get;
+          var _step$value = _slicedToArray(_step.value, 2),
+            k = _step$value[0],
+            v = _step$value[1];
+          result.push([(_this$keyMap$get = this.keyMap.get(k)) !== null && _this$keyMap$get !== void 0 ? _this$keyMap$get : [], v]);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return result;
+    }
+  }, {
+    key: "deleteByKey",
+    value: function deleteByKey(key) {
+      if (!key.length || this.isEmpty()) {
+        return false;
+      }
+      var hash = objectHash(key);
+      return this.keyMap.deleteByKey(hash) && this.valueMap.delete(hash);
+    }
+  }, {
+    key: "deleteByKeys",
+    value: function deleteByKeys(keys) {
+      if (!keys.length || this.isEmpty()) {
+        return false;
+      }
+      var result = false;
+      var _iterator2 = _createForOfIteratorHelper(keys),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var key = _step2.value;
+          if (this.deleteByKey(key)) {
+            result = true;
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      return result;
+    }
+  }, {
+    key: "deleteByValue",
+    value: function deleteByValue(value) {
+      if (this.isEmpty()) {
+        return false;
+      }
+      var result = false;
+      var _iterator3 = _createForOfIteratorHelper(this.valueMap.entries()),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var _step3$value = _slicedToArray(_step3.value, 2),
+            k = _step3$value[0],
+            v = _step3$value[1];
+          if (v === value && this.keyMap.deleteByKey(k) && this.valueMap.delete(k)) {
+            result = true;
+          }
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+      return result;
+    }
+  }, {
+    key: "deleteByValues",
+    value: function deleteByValues(values) {
+      if (!values.length || this.isEmpty()) {
+        return false;
+      }
+      var result = false;
+      var _iterator4 = _createForOfIteratorHelper(values),
+        _step4;
+      try {
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var _value = _step4.value;
+          if (this.deleteByValue(_value)) {
+            result = true;
+          }
+        }
+      } catch (err) {
+        _iterator4.e(err);
+      } finally {
+        _iterator4.f();
+      }
+      return result;
+    }
+  }, {
+    key: "forEach",
+    value: function forEach(callback, thisArg) {
+      this.entries().forEach(function (entry) {
+        var _entry2 = _slicedToArray(entry, 2),
+          ks = _entry2[0],
+          v = _entry2[1];
+        callback(v, ks);
+      }, thisArg);
+    }
+  }, {
+    key: "forEachIndexing",
+    value: function forEachIndexing(callback, thisArg) {
+      var index = 0;
+      this.entries().forEach(function (entry) {
+        var _entry3 = _slicedToArray(entry, 2),
+          ks = _entry3[0],
+          v = _entry3[1];
+        callback(v, ks, index++);
+      }, thisArg);
+    }
+  }, {
+    key: "forEachBreakable",
+    value: function forEachBreakable(callback, thisArg) {
+      this.entries().forEach(function (entry) {
+        var _entry4 = _slicedToArray(entry, 2),
+          ks = _entry4[0],
+          v = _entry4[1];
+        if (!callback(v, ks)) {
+          return;
+        }
+      }, thisArg);
+    }
+  }, {
+    key: "hasKey",
+    value: function hasKey(keys) {
+      var exact = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      return this.isNotEmpty() && keys.length > 0 && this.keyMap.hasValue(keys, exact);
+    }
+  }, {
+    key: "hasKeyValue",
+    value: function hasKeyValue(keys, value) {
+      return this.isNotEmpty() && keys.length > 0 && this.get(keys) === value;
+    }
+  }, {
+    key: "hasAnyKeys",
+    value: function hasAnyKeys(keys) {
+      var _this2 = this;
+      var exact = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      return this.isNotEmpty() && keys.length > 0 && keys.some(function (item) {
+        return _this2.hasKey(item, exact);
+      });
+    }
+  }, {
+    key: "hasAllKeys",
+    value: function hasAllKeys(keys) {
+      var _this3 = this;
+      var exact = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      return this.isNotEmpty() && keys.length > 0 && keys.every(function (item) {
+        return _this3.hasKey(item, exact);
+      });
+    }
+  }, {
+    key: "hasValue",
+    value: function hasValue(value) {
+      return this.values().includes(value);
+    }
+  }, {
+    key: "hasAnyValues",
+    value: function hasAnyValues(values) {
+      var _this4 = this;
+      return this.isNotEmpty() && values.length > 0 && values.some(function (item) {
+        return _this4.hasValue(item);
+      });
+    }
+  }, {
+    key: "hasAllValues",
+    value: function hasAllValues(values) {
+      var _this5 = this;
+      return this.isNotEmpty() && values.length > 0 && values.every(function (item) {
+        return _this5.hasValue(item);
+      });
+    }
+  }, {
+    key: "isEmpty",
+    value: function isEmpty() {
+      return !this.valueMap.size;
+    }
+  }, {
+    key: "isNotEmpty",
+    value: function isNotEmpty() {
+      return this.valueMap.size > 0;
+    }
+  }, {
+    key: "getKey",
+    value: function getKey(value, defaults) {
+      if (this.isEmpty()) {
+        return defaults;
+      }
+      var _iterator5 = _createForOfIteratorHelper(this.valueMap.entries()),
+        _step5;
+      try {
+        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+          var _step5$value = _slicedToArray(_step5.value, 2),
+            k = _step5$value[0],
+            v = _step5$value[1];
+          if (v === value) {
+            return this.keyMap.get(k, defaults);
+          }
+        }
+      } catch (err) {
+        _iterator5.e(err);
+      } finally {
+        _iterator5.f();
+      }
+      return defaults;
+    }
+  }, {
+    key: _Symbol$iterator,
+    value: function value() {
+      return this.entries()[Symbol.iterator]();
+    }
+  }, {
+    key: "size",
+    get: function get() {
+      return this.valueMap.size;
+    }
+  }, {
+    key: _Symbol$toStringTag,
+    get: function get() {
+      return 'MultiKeyMap';
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      return _toConsumableArray(this).map(function (entry) {
+        var _ref = entry.length <= 1 ? [[], entry[0]] : [entry.slice(0, -1), entry[entry.length - 1]],
+          _ref2 = _slicedToArray(_ref, 2),
+          ks = _ref2[0],
+          v = _ref2[1];
+        return "[".concat(ks.join(), "]:").concat(v);
+      }).join(';');
+    }
+  }], [{
+    key: "of",
+    value: function of(entries) {
+      return new MultiKeyMap(entries);
+    }
+  }]);
+  return MultiKeyMap;
+}();

package/dist/esm/util/MultiValueMap.d.ts

@@ -0,0 +1,35 @@
+import { type MultiValueMapEntries } from "..";
+export declare class MultiValueMap<K, V> implements Omit<Map<K, V[]>, 'delete' | 'forEach' | 'get' | 'has' | 'set' | 'entries' | 'keys' | 'values' | 'push'> {
+    private readonly map;
+    static of<K, V>(entries?: MultiValueMapEntries<K, V>): MultiValueMap<K, V>;
+    constructor(entries?: MultiValueMapEntries<K, V>);
+    get(key: K, defaults?: V[]): V[] | undefined;
+    set(key: K, values: V[]): void;
+    push(key: K, values: V[]): void;
+    clear(): void;
+    keys(): K[];
+    values(): V[][];
+    entries(): [K, V[]][];
+    deleteByKey(key: K): boolean;
+    deleteByKeys(keys: K[]): boolean;
+    deleteByValue(value: V): boolean;
+    deleteByValues(values: V[]): boolean;
+    deleteValueOfKey(key: K, value: V): boolean;
+    forEach(callback: (values?: V[], key?: K) => void, thisArg?: any): void;
+    forEachIndexing(callback: (values?: V[], key?: K, index?: number) => void, thisArg?: any): void;
+    forEachBreakable(callback: (values?: V[], key?: K) => boolean, thisArg?: any): void;
+    hasKey(key: K): boolean;
+    hasKeyValue(key: K, value: V): boolean;
+    hasAnyKeys(keys: K[]): boolean;
+    hasAllKeys(keys: K[]): boolean;
+    hasValue(values: V[], exact?: boolean): boolean;
+    hasAnyValues(values: V[][], exact?: boolean): boolean;
+    hasAllValues(values: V[][], exact?: boolean): boolean;
+    isEmpty(): boolean;
+    isNotEmpty(): boolean;
+    getKey(values: V[], defaults?: K): K | undefined;
+    [Symbol.iterator](): IterableIterator<[K, V[]]>;
+    get size(): number;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+}

package/dist/esm/util/MultiValueMap.js

@@ -0,0 +1,328 @@
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+var _Symbol$iterator, _Symbol$toStringTag;
+_Symbol$iterator = Symbol.iterator;
+_Symbol$toStringTag = Symbol.toStringTag;
+export var MultiValueMap = /*#__PURE__*/function () {
+  function MultiValueMap(entries) {
+    var _this = this;
+    _classCallCheck(this, MultiValueMap);
+    _defineProperty(this, "map", new Map());
+    entries === null || entries === void 0 || entries.forEach(function (entry) {
+      var _entry = _slicedToArray(entry, 2),
+        k = _entry[0],
+        vs = _entry[1];
+      _this.set(k, vs);
+    });
+  }
+  _createClass(MultiValueMap, [{
+    key: "get",
+    value: function get(key, defaults) {
+      var _this$map$get;
+      return (_this$map$get = this.map.get(key)) !== null && _this$map$get !== void 0 ? _this$map$get : defaults;
+    }
+  }, {
+    key: "set",
+    value: function set(key, values) {
+      this.map.set(key, values);
+    }
+  }, {
+    key: "push",
+    value: function push(key, values) {
+      var array = this.get(key) || [];
+      array.push.apply(array, _toConsumableArray(values));
+      this.map.set(key, array);
+    }
+  }, {
+    key: "clear",
+    value: function clear() {
+      this.map.clear();
+    }
+  }, {
+    key: "keys",
+    value: function keys() {
+      return _toConsumableArray(this.map.keys());
+    }
+  }, {
+    key: "values",
+    value: function values() {
+      return _toConsumableArray(this.map.values());
+    }
+  }, {
+    key: "entries",
+    value: function entries() {
+      return _toConsumableArray(this.map.entries());
+    }
+  }, {
+    key: "deleteByKey",
+    value: function deleteByKey(key) {
+      return this.map.delete(key);
+    }
+  }, {
+    key: "deleteByKeys",
+    value: function deleteByKeys(keys) {
+      if (!keys.length || this.isEmpty()) {
+        return false;
+      }
+      var result = false;
+      var _iterator = _createForOfIteratorHelper(keys),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _key = _step.value;
+          if (this.deleteByKey(_key)) {
+            result = true;
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return result;
+    }
+  }, {
+    key: "deleteByValue",
+    value: function deleteByValue(value) {
+      if (this.isEmpty()) {
+        return false;
+      }
+      var result = false;
+      var _iterator2 = _createForOfIteratorHelper(this.entries()),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var _step2$value = _slicedToArray(_step2.value, 2),
+            k = _step2$value[0],
+            vs = _step2$value[1];
+          if (vs !== null && vs !== void 0 && vs.includes(value) && this.map.delete(k)) {
+            result = true;
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      return result;
+    }
+  }, {
+    key: "deleteByValues",
+    value: function deleteByValues(values) {
+      if (!values.length || this.isEmpty()) {
+        return false;
+      }
+      var result = false;
+      var _iterator3 = _createForOfIteratorHelper(values),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var value = _step3.value;
+          if (this.deleteByValue(value)) {
+            result = true;
+          }
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+      return result;
+    }
+  }, {
+    key: "deleteValueOfKey",
+    value: function deleteValueOfKey(key, value) {
+      var array = this.get(key) || [];
+      if (!array.includes(value)) {
+        return false;
+      }
+      array = array.filter(function (v) {
+        return v !== value;
+      });
+      this.map.set(key, array);
+      return true;
+    }
+  }, {
+    key: "forEach",
+    value: function forEach(callback, thisArg) {
+      this.map.forEach(function (vs, k) {
+        callback(vs, k);
+      }, thisArg);
+    }
+  }, {
+    key: "forEachIndexing",
+    value: function forEachIndexing(callback, thisArg) {
+      var index = 0;
+      this.map.forEach(function (vs, k) {
+        callback(vs, k, index++);
+      }, thisArg);
+    }
+  }, {
+    key: "forEachBreakable",
+    value: function forEachBreakable(callback, thisArg) {
+      this.map.forEach(function (vs, k) {
+        if (!callback(vs, k)) {
+          return;
+        }
+      }, thisArg);
+    }
+  }, {
+    key: "hasKey",
+    value: function hasKey(key) {
+      return this.map.has(key);
+    }
+  }, {
+    key: "hasKeyValue",
+    value: function hasKeyValue(key, value) {
+      return this.isNotEmpty() && this.get(key, []).includes(value);
+    }
+  }, {
+    key: "hasAnyKeys",
+    value: function hasAnyKeys(keys) {
+      var _this2 = this;
+      return this.isNotEmpty() && keys.length > 0 && keys.some(function (item) {
+        return _this2.hasKey(item);
+      });
+    }
+  }, {
+    key: "hasAllKeys",
+    value: function hasAllKeys(keys) {
+      var _this3 = this;
+      return this.isNotEmpty() && keys.length > 0 && keys.every(function (item) {
+        return _this3.hasKey(item);
+      });
+    }
+  }, {
+    key: "hasValue",
+    value: function hasValue(values) {
+      var exact = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      if (!values.length || this.isEmpty()) {
+        return false;
+      }
+      var _iterator4 = _createForOfIteratorHelper(this.map.values()),
+        _step4;
+      try {
+        var _loop = function _loop() {
+            var vs = _step4.value;
+            var result = exact ? values.length === vs.length && values.every(function (item) {
+              return vs.includes(item);
+            }) : values.some(function (item) {
+              return vs.includes(item);
+            });
+            if (result) {
+              return {
+                v: true
+              };
+            }
+          },
+          _ret;
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          _ret = _loop();
+          if (_ret) return _ret.v;
+        }
+      } catch (err) {
+        _iterator4.e(err);
+      } finally {
+        _iterator4.f();
+      }
+      return false;
+    }
+  }, {
+    key: "hasAnyValues",
+    value: function hasAnyValues(values) {
+      var _this4 = this;
+      var exact = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      return this.isNotEmpty() && values.length > 0 && values.some(function (item) {
+        return _this4.hasValue(item, exact);
+      });
+    }
+  }, {
+    key: "hasAllValues",
+    value: function hasAllValues(values) {
+      var _this5 = this;
+      var exact = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      return this.isNotEmpty() && values.length > 0 && values.every(function (item) {
+        return _this5.hasValue(item, exact);
+      });
+    }
+  }, {
+    key: "isEmpty",
+    value: function isEmpty() {
+      return !this.map.size;
+    }
+  }, {
+    key: "isNotEmpty",
+    value: function isNotEmpty() {
+      return this.map.size > 0;
+    }
+  }, {
+    key: "getKey",
+    value: function getKey(values, defaults) {
+      if (this.isEmpty()) {
+        return defaults;
+      }
+      var _iterator5 = _createForOfIteratorHelper(this.entries()),
+        _step5;
+      try {
+        var _loop2 = function _loop2() {
+            var _step5$value = _slicedToArray(_step5.value, 2),
+              k = _step5$value[0],
+              vs = _step5$value[1];
+            if (values.length === vs.length && values.every(function (item) {
+              return vs.includes(item);
+            })) {
+              return {
+                v: k
+              };
+            }
+          },
+          _ret2;
+        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+          _ret2 = _loop2();
+          if (_ret2) return _ret2.v;
+        }
+      } catch (err) {
+        _iterator5.e(err);
+      } finally {
+        _iterator5.f();
+      }
+      return defaults;
+    }
+  }, {
+    key: _Symbol$iterator,
+    value: function value() {
+      return this.map[Symbol.iterator]();
+    }
+  }, {
+    key: "size",
+    get: function get() {
+      return this.map.size;
+    }
+  }, {
+    key: _Symbol$toStringTag,
+    get: function get() {
+      return 'MultiValueMap';
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      return _toConsumableArray(this).map(function (entry) {
+        var _ref = entry.length <= 1 ? [[], entry[0]] : [entry.slice(0, -1), entry[entry.length - 1]],
+          _ref2 = _slicedToArray(_ref, 2),
+          k = _ref2[0],
+          vs = _ref2[1];
+        return "".concat(k, ":[").concat(vs.join(), "]");
+      }).join(';');
+    }
+  }], [{
+    key: "of",
+    value: function of(entries) {
+      return new MultiValueMap(entries);
+    }
+  }]);
+  return MultiValueMap;
+}();