@yookue/ts-multi-map/dist/esm/util/ReadonlyMultiKeyMap.js

Multiple key/value map & range map for typescript

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;
}();