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