@studyportals/sp-hs-misc/bin-browser/src/utils/array-helper.class.js

Miscellaneous code used in HouseStark's projects

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

//# sourceMappingURL=array-helper.class.js.map
var ArrayHelper = function () {
    function ArrayHelper() {
        _classCallCheck(this, ArrayHelper);
    }

    _createClass(ArrayHelper, [{
        key: "first",
        value: function first(input) {
            if (0 === input.length) {
                throw new Error("Could not extract the first item of an empty array");
            }
            return input[0];
        }
    }, {
        key: "firstOrDefault",
        value: function firstOrDefault(input, defaultValueFactoryFn) {
            if (0 === input.length) {
                return defaultValueFactoryFn();
            }
            return input[0];
        }
    }, {
        key: "last",
        value: function last(input) {
            if (0 === input.length) {
                throw new Error("Could not extract the last item of an empty array");
            }
            return input[input.length - 1];
        }
    }, {
        key: "lastOrDefault",
        value: function lastOrDefault(input, defaultValueFactoryFn) {
            if (0 === input.length) {
                return defaultValueFactoryFn();
            }
            return input[input.length - 1];
        }
    }, {
        key: "toSet",
        value: function toSet(input) {
            return new Set(input);
        }
    }, {
        key: "mapFirst",
        value: function mapFirst(input, mapperFn) {
            return mapperFn(this.first(input));
        }
    }, {
        key: "minimum",
        value: function minimum(input) {
            return input.reduce(function (left, right) {
                return left < right ? left : right;
            });
        }
    }, {
        key: "maximum",
        value: function maximum(input) {
            return input.reduce(function (left, right) {
                return left > right ? left : right;
            });
        }
    }, {
        key: "extractMinimum",
        value: function extractMinimum(input, extractorFn) {
            return this.minimum(input.map(function (_) {
                return extractorFn(_);
            }));
        }
    }, {
        key: "extractMaximum",
        value: function extractMaximum(input, extractorFn) {
            return this.maximum(input.map(function (_) {
                return extractorFn(_);
            }));
        }
    }, {
        key: "equivalent",
        value: function equivalent(input, other, toPrimitiveFn) {
            var inputItemToOccurances = this.countMembers(input, toPrimitiveFn);
            var otherItemToOccurances = this.countMembers(other, toPrimitiveFn);
            var _iteratorNormalCompletion = true;
            var _didIteratorError = false;
            var _iteratorError = undefined;

            try {
                for (var _iterator = input[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                    var item = _step.value;

                    var key = toPrimitiveFn ? toPrimitiveFn(item) : item;
                    if (inputItemToOccurances.get(key) !== otherItemToOccurances.get(key)) {
                        return false;
                    }
                }
            } catch (err) {
                _didIteratorError = true;
                _iteratorError = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion && _iterator.return) {
                        _iterator.return();
                    }
                } finally {
                    if (_didIteratorError) {
                        throw _iteratorError;
                    }
                }
            }

            return input.length === other.length;
        }
    }, {
        key: "removeDuplicates",
        value: function removeDuplicates(input, toPrimitiveFn) {
            var map = new Map();
            var _iteratorNormalCompletion2 = true;
            var _didIteratorError2 = false;
            var _iteratorError2 = undefined;

            try {
                for (var _iterator2 = input[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
                    var item = _step2.value;

                    var primitive = toPrimitiveFn ? toPrimitiveFn(item) : item;
                    map.set(primitive, item);
                }
            } catch (err) {
                _didIteratorError2 = true;
                _iteratorError2 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion2 && _iterator2.return) {
                        _iterator2.return();
                    }
                } finally {
                    if (_didIteratorError2) {
                        throw _iteratorError2;
                    }
                }
            }

            return Array.from(map.values());
        }
    }, {
        key: "countMembers",
        value: function countMembers(input, toPrimitiveFn) {
            var itemToOccurances = new Map();
            var _iteratorNormalCompletion3 = true;
            var _didIteratorError3 = false;
            var _iteratorError3 = undefined;

            try {
                for (var _iterator3 = input[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
                    var item = _step3.value;

                    var key = toPrimitiveFn ? toPrimitiveFn(item) : item;
                    var occurances = itemToOccurances.get(key);
                    if (occurances) {
                        itemToOccurances.set(key, occurances + 1);
                    } else {
                        itemToOccurances.set(key, 1);
                    }
                }
            } catch (err) {
                _didIteratorError3 = true;
                _iteratorError3 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion3 && _iterator3.return) {
                        _iterator3.return();
                    }
                } finally {
                    if (_didIteratorError3) {
                        throw _iteratorError3;
                    }
                }
            }

            return itemToOccurances;
        }
    }]);

    return ArrayHelper;
}();