@yookue/ts-multi-map
Version:
Multiple key/value map & range map for typescript
318 lines • 9.35 kB
JavaScript
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;
}();