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