@r01al/array-polyfills 1.0.5 → 1.0.7

package/dist/index.umd.js

@@ -0,0 +1,580 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ArrayPolyfills = {}));
+})(this, (function (exports) { 'use strict';
+
+    /******************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+    /* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+    function __spreadArray(to, from, pack) {
+        if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+            if (ar || !(i in from)) {
+                if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+                ar[i] = from[i];
+            }
+        }
+        return to.concat(ar || Array.prototype.slice.call(from));
+    }
+
+    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+
+    /**
+    * @returns the first element of the array, or undefined if the array is empty.
+    */
+    function _first () { return this.length ? this[0] : undefined; }
+
+    /**
+    * @returns the last element of the array, or undefined if the array is empty.
+    */
+    function _last () { return this.length ? this[this.length - 1] : undefined; }
+
+    /**
+     * @returns a new array with only unique elements from the original array.
+     * Supports deep comparison for objects.
+     * Uses a map for improved performance with primitives.
+     */
+    function deepEqual(a, b) {
+        if (a === b)
+            return true;
+        if (typeof a !== "object" || typeof b !== "object" || a === null || b === null)
+            return false;
+        var keysA = Object.keys(a), keysB = Object.keys(b);
+        if (keysA.length !== keysB.length)
+            return false;
+        for (var _i = 0, keysA_1 = keysA; _i < keysA_1.length; _i++) {
+            var key = keysA_1[_i];
+            if (!keysB.includes(key) || !deepEqual(a[key], b[key]))
+                return false;
+        }
+        return true;
+    }
+    function _unique () {
+        var result = [];
+        var primitiveMap = new Map();
+        var _loop_1 = function (item) {
+            if (item === null || typeof item !== "object") {
+                if (!primitiveMap.has(item)) {
+                    primitiveMap.set(item, true);
+                    result.push(item);
+                }
+            }
+            else {
+                if (!result.some(function (existing) { return deepEqual(existing, item); })) {
+                    result.push(item);
+                }
+            }
+        };
+        for (var _i = 0, _a = this; _i < _a.length; _i++) {
+            var item = _a[_i];
+            _loop_1(item);
+        }
+        return result;
+    }
+
+    /**
+    * Splits the array into smaller arrays of the given size.
+    * @param size Number of items per chunk
+    * @returns Array of chunks
+    */
+    function _chunk (size) {
+        if (!Number.isInteger(size) || size <= 0)
+            throw new Error("size must be a positive integer");
+        var out = [];
+        for (var i = 0; i < this.length; i += size)
+            out.push(this.slice(i, i + size));
+        return out;
+    }
+
+    /**
+     * Removes falsy values from the array.
+     * @returns A new array without falsy values.
+     */
+    function _compact () {
+        return this.filter(function (value) { return Boolean(value); });
+    }
+
+    /**
+     * Maps items and removes null/undefined results.
+     * @param mapper Function to map items.
+     * @returns A new array of mapped values without null/undefined.
+     */
+    function _compactMap (mapper) {
+        var out = [];
+        for (var index = 0; index < this.length; index++) {
+            var value = mapper(this[index], index, this);
+            if (value !== null && value !== undefined) {
+                out.push(value);
+            }
+        }
+        return out;
+    }
+
+    /**
+     * @returns a random element from the array, or undefined if the array is empty.
+     */
+    function _random () {
+        return this.length ? this[Math.floor(Math.random() * this.length)] : undefined;
+    }
+
+    /**
+     * Creates an object mapping each value of the given key to the corresponding value from the array of objects.
+     * @param key The property name to use as keys in the result object.
+     * @param value The property name to use as values in the result object.
+     * @returns An object mapping key values to value values.
+     */
+    function _keyValueMap (key, value) {
+        if (!key) {
+            throw new Error('keyValueMap: key is required');
+        }
+        if (!value) {
+            throw new Error("keyValueMap: value is required");
+        }
+        if (this.some(function (el) { return !el; })) {
+            throw new Error('keyValueMap: Array contains falsy values');
+        }
+        if (this.some(function (el) { return typeof el !== 'object'; })) {
+            throw new Error('keyValueMap: Array contains non-object values');
+        }
+        if (this.some(function (el) { return !el.hasOwnProperty(key); })) {
+            throw new Error("keyValueMap: key \"".concat(key, "\" does not exist on all objects"));
+        }
+        var map = {};
+        for (var index = 0; index < this.length; index++) {
+            var element = this[index];
+            map[element[key]] = element[value];
+        }
+        return map;
+    }
+
+    /**
+     * Calculates the sum of all numbers in an array.
+     * @returns The sum of all numbers in the array.
+     * @throws Will throw an error if any element in the array is not a number.
+     * @example
+     * [1, 2, 3].sum() // returns 6
+     * [10, -2, 5].sum() // returns 13
+     * [1, '2', 3].sum() // throws Error
+     */
+    function _sum () {
+        if (this.some(function (el) { return typeof el !== 'number'; })) {
+            throw new Error('All elements must be numbers');
+        }
+        var sum = 0;
+        for (var _i = 0, _a = this; _i < _a.length; _i++) {
+            var num = _a[_i];
+            sum += num;
+        }
+        return sum;
+    }
+
+    /**
+     * Calculates the average of all numbers in an array.
+     * @returns The average value.
+     * @throws If any element is not a number.
+     */
+    function _avg () {
+        if (this.length === 0)
+            return undefined;
+        if (this.some(function (el) { return typeof el !== 'number'; })) {
+            throw new Error('All elements must be numbers');
+        }
+        return this.reduce(function (a, b) { return a + b; }, 0) / this.length;
+    }
+
+    /**
+     * Returns the maximum number in the array.
+     * @returns The maximum value.
+     * @throws If any element is not a number.
+     */
+    function _max () {
+        if (this.length === 0)
+            return undefined;
+        if (this.some(function (el) { return typeof el !== 'number'; })) {
+            throw new Error('All elements must be numbers');
+        }
+        return Math.max.apply(Math, this);
+    }
+
+    /**
+     * Returns the minimum number in the array.
+     * @returns The minimum value.
+     * @throws If any element is not a number.
+     */
+    function _min () {
+        if (this.length === 0)
+            return undefined;
+        if (this.some(function (el) { return typeof el !== 'number'; })) {
+            throw new Error('All elements must be numbers');
+        }
+        return Math.min.apply(Math, this);
+    }
+
+    function shuffle$1() {
+        var _a;
+        for (var i = this.length - 1; i > 0; i--) {
+            var j = Math.floor(Math.random() * (i + 1));
+            _a = [this[j], this[i]], this[i] = _a[0], this[j] = _a[1];
+        }
+        return this;
+    }
+
+    /**
+     * Groups array items by a key or mapper function.
+     * @param key The property name or mapper function to group by.
+     * @returns An object where keys are group identifiers and values are arrays of items.
+     */
+    function _groupBy (key) {
+        var result = {};
+        var getKey = typeof key === "function"
+            ? key
+            : function (item) { return item[key]; };
+        for (var index = 0; index < this.length; index++) {
+            var item = this[index];
+            var groupKey = getKey(item, index, this);
+            if (!result[groupKey])
+                result[groupKey] = [];
+            result[groupKey].push(item);
+        }
+        return result;
+    }
+
+    /**
+     * Flattens the array by one level.
+     * @returns A new flattened array.
+     */
+    function _flatten () {
+        var out = [];
+        for (var _i = 0, _a = this; _i < _a.length; _i++) {
+            var item = _a[_i];
+            if (Array.isArray(item))
+                out.push.apply(out, item);
+            else
+                out.push(item);
+        }
+        return out;
+    }
+
+    /**
+     * Zips the array with other arrays.
+     * @param arrays Arrays to zip with.
+     * @returns An array of tuples, truncated to the shortest length.
+     */
+    function _zip () {
+        var arrays = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            arrays[_i] = arguments[_i];
+        }
+        if (arrays.length === 0)
+            return this.map(function (item) { return [item]; });
+        var minLength = Math.min.apply(Math, __spreadArray([this.length], arrays.map(function (arr) { return arr.length; }), false));
+        var out = [];
+        var _loop_1 = function (index) {
+            out.push(__spreadArray([this_1[index]], arrays.map(function (arr) { return arr[index]; }), true));
+        };
+        var this_1 = this;
+        for (var index = 0; index < minLength; index++) {
+            _loop_1(index);
+        }
+        return out;
+    }
+
+    /**
+     * Splits the array into two arrays based on a predicate.
+     * @param predicate Function to test each element.
+     * @returns A tuple: [items that pass, items that fail].
+     */
+    function _partition (predicate) {
+        var pass = [];
+        var fail = [];
+        for (var index = 0; index < this.length; index++) {
+            var item = this[index];
+            if (predicate(item, index, this))
+                pass.push(item);
+            else
+                fail.push(item);
+        }
+        return [pass, fail];
+    }
+
+    /**
+     * Plucks a property from each item in the array.
+     * @param key Property name to pluck.
+     * @returns A new array of property values.
+     */
+    function _pluck (key) {
+        return this.map(function (item) { return item[key]; });
+    }
+
+    /**
+     * Counts items by a key or mapper function.
+     * @param key The property name or mapper function to count by.
+     * @returns An object where keys are group identifiers and values are counts.
+     */
+    function _countBy (key) {
+        var _a;
+        var result = {};
+        var getKey = typeof key === "function"
+            ? key
+            : function (item) { return item[key]; };
+        for (var index = 0; index < this.length; index++) {
+            var item = this[index];
+            var groupKey = getKey(item, index, this);
+            result[groupKey] = ((_a = result[groupKey]) !== null && _a !== void 0 ? _a : 0) + 1;
+        }
+        return result;
+    }
+
+    /**
+     * Returns items that are not present in the other arrays.
+     * @param arrays Arrays to exclude.
+     * @returns A new array of values not found in other arrays.
+     */
+    function _difference () {
+        var arrays = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            arrays[_i] = arguments[_i];
+        }
+        if (arrays.length === 0)
+            return this.slice();
+        var other = new Set();
+        for (var _a = 0, arrays_1 = arrays; _a < arrays_1.length; _a++) {
+            var arr = arrays_1[_a];
+            for (var _b = 0, arr_1 = arr; _b < arr_1.length; _b++) {
+                var item = arr_1[_b];
+                other.add(item);
+            }
+        }
+        return this.filter(function (item) { return !other.has(item); });
+    }
+
+    /**
+     * Returns items present in all arrays.
+     * @param arrays Arrays to intersect with.
+     * @returns A new array of items found in every array.
+     */
+    function _intersection () {
+        var arrays = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            arrays[_i] = arguments[_i];
+        }
+        if (arrays.length === 0)
+            return this.slice();
+        var sets = arrays.map(function (arr) { return new Set(arr); });
+        return this.filter(function (item) { return sets.every(function (set) { return set.has(item); }); });
+    }
+
+    /**
+     * Returns a unique merge of the array and the other arrays.
+     * @param arrays Arrays to merge.
+     * @returns A new array with unique values.
+     */
+    function _union () {
+        var arrays = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            arrays[_i] = arguments[_i];
+        }
+        var out = [];
+        var seen = new Set();
+        var push = function (item) {
+            if (seen.has(item))
+                return;
+            seen.add(item);
+            out.push(item);
+        };
+        for (var _a = 0, _b = this; _a < _b.length; _a++) {
+            var item = _b[_a];
+            push(item);
+        }
+        for (var _c = 0, arrays_1 = arrays; _c < arrays_1.length; _c++) {
+            var arr = arrays_1[_c];
+            for (var _d = 0, arr_1 = arr; _d < arr_1.length; _d++) {
+                var item = arr_1[_d];
+                push(item);
+            }
+        }
+        return out;
+    }
+
+    /**
+     * Returns unique items by a key or mapper function.
+     * @param key The property name or mapper function to determine uniqueness.
+     * @returns A new array with unique items.
+     */
+    function _uniqBy (key) {
+        var result = [];
+        var seen = new Set();
+        var getKey = typeof key === "function"
+            ? key
+            : function (item) { return item[key]; };
+        for (var index = 0; index < this.length; index++) {
+            var item = this[index];
+            var keyValue = getKey(item, index, this);
+            if (!seen.has(keyValue)) {
+                seen.add(keyValue);
+                result.push(item);
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Sorts items by a key or mapper function (stable).
+     * @param key The property name or mapper function to sort by.
+     * @returns A new array sorted by the key.
+     */
+    function _sortBy (key) {
+        var _this = this;
+        var getKey = typeof key === "function"
+            ? key
+            : function (item) { return item[key]; };
+        return this
+            .map(function (item, index) { return ({ item: item, index: index, key: getKey(item, index, _this) }); })
+            .sort(function (a, b) {
+            if (a.key < b.key)
+                return -1;
+            if (a.key > b.key)
+                return 1;
+            return a.index - b.index;
+        })
+            .map(function (entry) { return entry.item; });
+    }
+
+    /**
+     * Returns a random sample of items without replacement.
+     * @param count Number of items to sample.
+     * @returns A new array containing sampled items.
+     */
+    function _sample (count) {
+        var _a;
+        if (!Number.isInteger(count) || count <= 0) {
+            throw new Error("count must be a positive integer");
+        }
+        var out = this.slice();
+        for (var i = out.length - 1; i > 0; i--) {
+            var j = Math.floor(Math.random() * (i + 1));
+            _a = [out[j], out[i]], out[i] = _a[0], out[j] = _a[1];
+        }
+        return out.slice(0, Math.min(count, out.length));
+    }
+
+    /**
+     * Pads the array to the given length with the provided value.
+     * @param length Target length.
+     * @param value Value to pad with.
+     * @returns A new padded array.
+     */
+    function _pad (length, value) {
+        if (!Number.isInteger(length) || length < 0) {
+            throw new Error("length must be a non-negative integer");
+        }
+        var out = this.slice();
+        while (out.length < length)
+            out.push(value);
+        return out;
+    }
+
+    var call = function (fn, thisArg) {
+        var args = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+            args[_i - 2] = arguments[_i];
+        }
+        return fn.apply(thisArg, args);
+    };
+    var first = function (arr) { return call(_first, arr); };
+    var last = function (arr) { return call(_last, arr); };
+    var unique = function (arr) { return call(_unique, arr); };
+    var chunk = function (arr, size) { return call(_chunk, arr, size); };
+    var compact = function (arr) { return call(_compact, arr); };
+    var compactMap = function (arr, mapper) { return call(_compactMap, arr, mapper); };
+    var random = function (arr) { return call(_random, arr); };
+    var keyValueMap = function (arr, key, value) { return call(_keyValueMap, arr, key, value); };
+    var sum = function (arr) { return call(_sum, arr); };
+    var avg = function (arr) { return call(_avg, arr); };
+    var max = function (arr) { return call(_max, arr); };
+    var min = function (arr) { return call(_min, arr); };
+    var shuffle = function (arr) { return call(shuffle$1, arr); };
+    var groupBy = function (arr, key) { return call(_groupBy, arr, key); };
+    var flatten = function (arr) { return call(_flatten, arr); };
+    var zip = function (arr) {
+        var arrays = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            arrays[_i - 1] = arguments[_i];
+        }
+        return call.apply(void 0, __spreadArray([_zip, arr], arrays, false));
+    };
+    var partition = function (arr, predicate) { return call(_partition, arr, predicate); };
+    var pluck = function (arr, key) { return call(_pluck, arr, key); };
+    var countBy = function (arr, key) { return call(_countBy, arr, key); };
+    var difference = function (arr) {
+        var arrays = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            arrays[_i - 1] = arguments[_i];
+        }
+        return call.apply(void 0, __spreadArray([_difference, arr], arrays, false));
+    };
+    var intersection = function (arr) {
+        var arrays = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            arrays[_i - 1] = arguments[_i];
+        }
+        return call.apply(void 0, __spreadArray([_intersection, arr], arrays, false));
+    };
+    var union = function (arr) {
+        var arrays = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            arrays[_i - 1] = arguments[_i];
+        }
+        return call.apply(void 0, __spreadArray([_union, arr], arrays, false));
+    };
+    var uniqBy = function (arr, key) { return call(_uniqBy, arr, key); };
+    var sortBy = function (arr, key) { return call(_sortBy, arr, key); };
+    var sample = function (arr, count) { return call(_sample, arr, count); };
+    var pad = function (arr, length, value) { return call(_pad, arr, length, value); };
+
+    exports.avg = avg;
+    exports.chunk = chunk;
+    exports.compact = compact;
+    exports.compactMap = compactMap;
+    exports.countBy = countBy;
+    exports.difference = difference;
+    exports.first = first;
+    exports.flatten = flatten;
+    exports.groupBy = groupBy;
+    exports.intersection = intersection;
+    exports.keyValueMap = keyValueMap;
+    exports.last = last;
+    exports.max = max;
+    exports.min = min;
+    exports.pad = pad;
+    exports.partition = partition;
+    exports.pluck = pluck;
+    exports.random = random;
+    exports.sample = sample;
+    exports.shuffle = shuffle;
+    exports.sortBy = sortBy;
+    exports.sum = sum;
+    exports.union = union;
+    exports.uniqBy = uniqBy;
+    exports.unique = unique;
+    exports.zip = zip;
+
+}));
+//# sourceMappingURL=index.umd.js.map