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

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

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

package/dist/esm/util/RangeMap.js

@@ -0,0 +1,358 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+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';
+_Symbol$iterator = Symbol.iterator;
+_Symbol$toStringTag = Symbol.toStringTag;
+export var RangeMap = /*#__PURE__*/function () {
+  function RangeMap(entries) {
+    var _this = this;
+    var validation = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    _classCallCheck(this, RangeMap);
+    _defineProperty(this, "keyMap", new Map());
+    _defineProperty(this, "valueMap", new Map());
+    entries === null || entries === void 0 || entries.forEach(function (entry) {
+      var _entry = _slicedToArray(entry, 2),
+        k = _entry[0],
+        v = _entry[1];
+      _this.set(k, v, validation);
+    });
+  }
+  _createClass(RangeMap, [{
+    key: "get",
+    value: function get(key, defaults) {
+      var _this$valueMap$get;
+      var hash = objectHash(this.toInternalKey(key));
+      return (_this$valueMap$get = this.valueMap.get(hash)) !== null && _this$valueMap$get !== void 0 ? _this$valueMap$get : defaults;
+    }
+  }, {
+    key: "getByDigit",
+    value: function getByDigit(digit, defaults) {
+      if (this.isEmpty()) {
+        return defaults;
+      }
+      var _iterator = _createForOfIteratorHelper(this.keyMap.entries()),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _step$value = _slicedToArray(_step.value, 2),
+            k = _step$value[0],
+            v = _step$value[1];
+          if ((v.startInclusive ? digit >= v.start : digit > v.start) && (v.endInclusive ? digit <= v.end : digit < v.end)) {
+            return this.valueMap.get(k);
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return defaults;
+    }
+  }, {
+    key: "set",
+    value: function set(key, value) {
+      var validation = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+      var alias = this.toInternalKey(key);
+      if (alias.start > alias.end || alias.start === alias.end && !alias.startInclusive && !alias.endInclusive) {
+        throw RangeError("Range start ".concat(alias.start, " must be less than or equal to it's end ").concat(alias.end));
+      }
+      if (validation) {
+        this.checkRangeConflict(alias);
+      }
+      var hash = objectHash(alias);
+      this.keyMap.set(hash, alias);
+      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 _iterator2 = _createForOfIteratorHelper(this.valueMap),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var _step2$value = _slicedToArray(_step2.value, 2),
+            k = _step2$value[0],
+            v = _step2$value[1];
+          result.push([this.keyMap.get(k), v]);
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      return result;
+    }
+  }, {
+    key: "deleteByKey",
+    value: function deleteByKey(key) {
+      if (this.isEmpty()) {
+        return false;
+      }
+      var hash = objectHash(this.toInternalKey(key));
+      return this.keyMap.delete(hash) && this.valueMap.delete(hash);
+    }
+  }, {
+    key: "deleteByKeys",
+    value: function deleteByKeys(keys) {
+      if (!keys.length || this.isEmpty()) {
+        return false;
+      }
+      var result = false;
+      var _iterator3 = _createForOfIteratorHelper(keys),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var _key = _step3.value;
+          if (this.deleteByKey(_key)) {
+            result = true;
+          }
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+      return result;
+    }
+  }, {
+    key: "deleteByValue",
+    value: function deleteByValue(value) {
+      if (this.isEmpty()) {
+        return false;
+      }
+      var result = false;
+      var _iterator4 = _createForOfIteratorHelper(this.valueMap.entries()),
+        _step4;
+      try {
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var _step4$value = _slicedToArray(_step4.value, 2),
+            k = _step4$value[0],
+            v = _step4$value[1];
+          if (v === value && this.keyMap.delete(k) && this.valueMap.delete(k)) {
+            result = true;
+          }
+        }
+      } catch (err) {
+        _iterator4.e(err);
+      } finally {
+        _iterator4.f();
+      }
+      return result;
+    }
+  }, {
+    key: "deleteByValues",
+    value: function deleteByValues(values) {
+      if (!values.length || this.isEmpty()) {
+        return false;
+      }
+      var result = false;
+      var _iterator5 = _createForOfIteratorHelper(values),
+        _step5;
+      try {
+        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+          var _value = _step5.value;
+          if (this.deleteByValue(_value)) {
+            result = true;
+          }
+        }
+      } catch (err) {
+        _iterator5.e(err);
+      } finally {
+        _iterator5.f();
+      }
+      return result;
+    }
+  }, {
+    key: "forEach",
+    value: function forEach(callback, thisArg) {
+      this.entries().forEach(function (entry) {
+        var _entry2 = _slicedToArray(entry, 2),
+          k = _entry2[0],
+          v = _entry2[1];
+        callback(v, k);
+      }, thisArg);
+    }
+  }, {
+    key: "forEachIndexing",
+    value: function forEachIndexing(callback, thisArg) {
+      var index = 0;
+      this.entries().forEach(function (entry) {
+        var _entry3 = _slicedToArray(entry, 2),
+          k = _entry3[0],
+          v = _entry3[1];
+        callback(v, k, index++);
+      }, thisArg);
+    }
+  }, {
+    key: "forEachBreakable",
+    value: function forEachBreakable(callback, thisArg) {
+      this.entries().forEach(function (entry) {
+        var _entry4 = _slicedToArray(entry, 2),
+          k = _entry4[0],
+          v = _entry4[1];
+        if (!callback(v, k)) {
+          return;
+        }
+      }, thisArg);
+    }
+  }, {
+    key: "hasKey",
+    value: function hasKey(key) {
+      return this.isNotEmpty() && this.keyMap.has(objectHash(this.toInternalKey(key)));
+    }
+  }, {
+    key: "hasKeyValue",
+    value: function hasKeyValue(key, value) {
+      return this.isNotEmpty() && this.get(key) === 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(value) {
+      return this.isNotEmpty() && 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: _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 'RangeMap';
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      return _toConsumableArray(this).map(function (entry) {
+        var _ref = entry,
+          _ref2 = _slicedToArray(_ref, 2),
+          k = _ref2[0],
+          v = _ref2[1];
+        var ks = Object.keys(k).map(function (item) {
+          return "".concat(item, ":").concat(k[item]);
+        }).join();
+        return "[".concat(ks, "]:").concat(v);
+      }).join(';');
+    }
+  }, {
+    key: "toInternalKey",
+    value: function toInternalKey(key) {
+      return !Array.isArray(key) ? key : {
+        start: key.length > 0 ? key[0] : 0,
+        end: key.length > 1 ? key[1] : 0,
+        startInclusive: key.length > 2 ? key[2] : true,
+        endInclusive: key.length > 3 ? key[3] : false
+      };
+    }
+  }, {
+    key: "checkRangeConflict",
+    value: function checkRangeConflict(key) {
+      if (this.isEmpty()) {
+        return;
+      }
+      var keyExpress = "".concat(key.startInclusive ? '[' : '(').concat(key.start, ",").concat(key.end).concat(key.endInclusive ? ']' : ')');
+      var _iterator6 = _createForOfIteratorHelper(this.keyMap.values()),
+        _step6;
+      try {
+        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+          var k = _step6.value;
+          var kExpress = "".concat(k.startInclusive ? '[' : '(').concat(k.start, ",").concat(k.end).concat(k.endInclusive ? ']' : ')');
+          if (key.start <= k.start && key.end >= k.end) {
+            throw RangeError("Range ".concat(keyExpress, " must not override the range ").concat(kExpress));
+          }
+          var badStart = (key.startInclusive ? key.start >= k.start : key.start > k.start) && (key.startInclusive && k.endInclusive ? key.start <= k.end : key.start < k.end);
+          var badEnd = (key.endInclusive && k.startInclusive ? key.end >= k.start : key.end > k.start) && key.end <= k.end;
+          if (badStart || badEnd) {
+            throw RangeError("Range ".concat(keyExpress, " must not intersect the range ").concat(kExpress));
+          }
+        }
+      } catch (err) {
+        _iterator6.e(err);
+      } finally {
+        _iterator6.f();
+      }
+    }
+  }], [{
+    key: "of",
+    value: function of(entries) {
+      var validation = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      return new RangeMap(entries, validation);
+    }
+  }]);
+  return RangeMap;
+}();

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

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

package/dist/esm/util/ReadonlyMultiKeyMap.js

@@ -0,0 +1,136 @@
+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 { MultiKeyMap } from "./..";
+_Symbol$iterator = Symbol.iterator;
+_Symbol$toStringTag = Symbol.toStringTag;
+export var ReadonlyMultiKeyMap = /*#__PURE__*/function () {
+  function ReadonlyMultiKeyMap(entries) {
+    var _this = this;
+    _classCallCheck(this, ReadonlyMultiKeyMap);
+    _defineProperty(this, "map", new MultiKeyMap());
+    entries === null || entries === void 0 || entries.forEach(function (entry) {
+      var _entry = _slicedToArray(entry, 2),
+        ks = _entry[0],
+        v = _entry[1];
+      _this.map.set(ks, v);
+    });
+  }
+  _createClass(ReadonlyMultiKeyMap, [{
+    key: "get",
+    value: function get(keys, defaults) {
+      return this.map.get(keys, defaults);
+    }
+  }, {
+    key: "keys",
+    value: function keys() {
+      return this.map.keys();
+    }
+  }, {
+    key: "values",
+    value: function values() {
+      return this.map.values();
+    }
+  }, {
+    key: "entries",
+    value: function entries() {
+      return this.map.entries();
+    }
+  }, {
+    key: "forEach",
+    value: function forEach(callback, thisArg) {
+      this.map.forEach(callback, thisArg);
+    }
+  }, {
+    key: "forEachIndexing",
+    value: function forEachIndexing(callback, thisArg) {
+      this.map.forEachIndexing(callback, thisArg);
+    }
+  }, {
+    key: "forEachBreakable",
+    value: function forEachBreakable(callback, thisArg) {
+      this.map.forEachBreakable(callback, thisArg);
+    }
+  }, {
+    key: "hasKey",
+    value: function hasKey(keys) {
+      var exact = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      return this.map.hasKey(keys, exact);
+    }
+  }, {
+    key: "hasKeyValue",
+    value: function hasKeyValue(keys, value) {
+      return this.map.hasKeyValue(keys, value);
+    }
+  }, {
+    key: "hasAnyKeys",
+    value: function hasAnyKeys(keys) {
+      var exact = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      return this.map.hasAnyKeys(keys, exact);
+    }
+  }, {
+    key: "hasAllKeys",
+    value: function hasAllKeys(keys) {
+      var exact = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      return this.map.hasAllKeys(keys, exact);
+    }
+  }, {
+    key: "hasValue",
+    value: function hasValue(value) {
+      return this.map.hasValue(value);
+    }
+  }, {
+    key: "hasAnyValues",
+    value: function hasAnyValues(values) {
+      return this.map.hasAnyValues(values);
+    }
+  }, {
+    key: "hasAllValues",
+    value: function hasAllValues(values) {
+      return this.map.hasAllValues(values);
+    }
+  }, {
+    key: "isEmpty",
+    value: function isEmpty() {
+      return this.map.isEmpty();
+    }
+  }, {
+    key: "isNotEmpty",
+    value: function isNotEmpty() {
+      return this.map.isNotEmpty();
+    }
+  }, {
+    key: "getKey",
+    value: function getKey(value, defaults) {
+      return this.map.getKey(value, 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 'ReadonlyMultiKeyMap';
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      return this.map.toString();
+    }
+  }], [{
+    key: "of",
+    value: function of(entries) {
+      return new ReadonlyMultiKeyMap(entries);
+    }
+  }]);
+  return ReadonlyMultiKeyMap;
+}();

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

@@ -0,0 +1,27 @@
+import { type MultiValueMapEntries } from "..";
+export declare class ReadonlyMultiValueMap<K, V> implements Omit<ReadonlyMap<K, V[]>, 'forEach' | 'get' | 'has' | 'entries' | 'keys' | 'values'> {
+    private readonly map;
+    static of<K, V>(entries?: MultiValueMapEntries<K, V>): ReadonlyMultiValueMap<K, V>;
+    constructor(entries?: MultiValueMapEntries<K, V>);
+    get(key: K, defaults?: V[]): V[] | undefined;
+    keys(): K[];
+    values(): V[][];
+    entries(): [K, V[]][];
+    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;
+}