es-toolkit 1.17.0-dev.522 → 1.17.0-dev.523

package/dist/array/flatMapDeep.d.mts

@@ -0,0 +1,18 @@
+import { ExtractNestedArrayType } from './flattenDeep.mjs';
+
+/**
+ * Recursively maps each element in an array using a provided iteratee function and then deeply flattens the resulting array.
+ *
+ * @template T - The type of elements within the array.
+ * @template U - The type of elements within the returned array from the iteratee function.
+ * @param {T[]} arr - The array to flatten.
+ * @param {(item: T) => U} iteratee - The function that produces the new array elements.
+ * @returns {Array<ExtractNestedArrayType<U>>} A new array that has been flattened.
+ *
+ * @example
+ * const result = flatMapDeep([1, 2, 3], n => [[n, n]]);
+ * // [1, 1, 2, 2, 3, 3]
+ */
+declare function flatMapDeep<T, U>(arr: readonly T[], iteratee: (item: T) => U): Array<ExtractNestedArrayType<U>>;
+
+export { flatMapDeep };

package/dist/array/flatMapDeep.d.ts

@@ -0,0 +1,18 @@
+import { ExtractNestedArrayType } from './flattenDeep.js';
+
+/**
+ * Recursively maps each element in an array using a provided iteratee function and then deeply flattens the resulting array.
+ *
+ * @template T - The type of elements within the array.
+ * @template U - The type of elements within the returned array from the iteratee function.
+ * @param {T[]} arr - The array to flatten.
+ * @param {(item: T) => U} iteratee - The function that produces the new array elements.
+ * @returns {Array<ExtractNestedArrayType<U>>} A new array that has been flattened.
+ *
+ * @example
+ * const result = flatMapDeep([1, 2, 3], n => [[n, n]]);
+ * // [1, 1, 2, 2, 3, 3]
+ */
+declare function flatMapDeep<T, U>(arr: readonly T[], iteratee: (item: T) => U): Array<ExtractNestedArrayType<U>>;
+
+export { flatMapDeep };

package/dist/array/flatMapDeep.mjs

@@ -0,0 +1,7 @@
+import { flattenDeep } from './flattenDeep.mjs';
+
+function flatMapDeep(arr, iteratee) {
+    return flattenDeep(arr.map((item) => iteratee(item)));
+}
+
+export { flatMapDeep };

package/dist/array/flattenDeep.d.mts

@@ -22,4 +22,4 @@ type ExtractNestedArrayType<T> = T extends ReadonlyArray<infer U> ? ExtractNeste
  */
 declare function flattenDeep<T>(arr: readonly T[]): Array<ExtractNestedArrayType<T>>;
 
-export { flattenDeep };
+export { type ExtractNestedArrayType, flattenDeep };

package/dist/array/flattenDeep.d.ts

@@ -22,4 +22,4 @@ type ExtractNestedArrayType<T> = T extends ReadonlyArray<infer U> ? ExtractNeste
  */
 declare function flattenDeep<T>(arr: readonly T[]): Array<ExtractNestedArrayType<T>>;
 
-export { flattenDeep };
+export { type ExtractNestedArrayType, flattenDeep };

package/dist/array/index.d.mts

@@ -11,6 +11,7 @@ export { dropRightWhile } from './dropRightWhile.mjs';
 export { dropWhile } from './dropWhile.mjs';
 export { fill } from './fill.mjs';
 export { flatMap } from './flatMap.mjs';
+export { flatMapDeep } from './flatMapDeep.mjs';
 export { flatten } from './flatten.mjs';
 export { flattenDeep } from './flattenDeep.mjs';
 export { forEachRight } from './forEachRight.mjs';

package/dist/array/index.d.ts

@@ -11,6 +11,7 @@ export { dropRightWhile } from './dropRightWhile.js';
 export { dropWhile } from './dropWhile.js';
 export { fill } from './fill.js';
 export { flatMap } from './flatMap.js';
+export { flatMapDeep } from './flatMapDeep.js';
 export { flatten } from './flatten.js';
 export { flattenDeep } from './flattenDeep.js';
 export { forEachRight } from './forEachRight.js';

package/dist/array/index.js

@@ -2,65 +2,548 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const initial = require('../_chunk/initial-L_KfII.js');
+const randomInt = require('../_chunk/randomInt-CF7bZK.js');
+
+function at(arr, indices) {
+    const result = [];
+    for (let i = 0; i < indices.length; i++) {
+        const index = indices[i];
+        result.push(arr.at(index));
+    }
+    return result;
+}
+
+function chunk(arr, size) {
+    if (!Number.isInteger(size) || size <= 0) {
+        throw new Error('Size must be an integer greater than zero.');
+    }
+    const chunkLength = Math.ceil(arr.length / size);
+    const result = Array(chunkLength);
+    for (let index = 0; index < chunkLength; index++) {
+        const start = index * size;
+        const end = start + size;
+        result[index] = arr.slice(start, end);
+    }
+    return result;
+}
+
+function compact(arr) {
+    const result = [];
+    for (const item of arr) {
+        if (item) {
+            result.push(item);
+        }
+    }
+    return result;
+}
+
+function countBy(arr, mapper) {
+    const result = {};
+    for (const item of arr) {
+        const key = mapper(item);
+        result[key] = (result[key] ?? 0) + 1;
+    }
+    return result;
+}
+
+function difference(firstArr, secondArr) {
+    const secondSet = new Set(secondArr);
+    return firstArr.filter(item => !secondSet.has(item));
+}
+
+function differenceBy(firstArr, secondArr, mapper) {
+    const mappedSecondSet = new Set(secondArr.map(item => mapper(item)));
+    return firstArr.filter(item => {
+        return !mappedSecondSet.has(mapper(item));
+    });
+}
+
+function differenceWith(firstArr, secondArr, areItemsEqual) {
+    return firstArr.filter(firstItem => {
+        return secondArr.every(secondItem => {
+            return !areItemsEqual(firstItem, secondItem);
+        });
+    });
+}
+
+function drop(arr, itemsCount) {
+    itemsCount = Math.max(itemsCount, 0);
+    return arr.slice(itemsCount);
+}
+
+function dropRight(arr, itemsCount) {
+    itemsCount = Math.min(-itemsCount, 0);
+    if (itemsCount === 0) {
+        return arr.slice();
+    }
+    return arr.slice(0, itemsCount);
+}
+
+function dropRightWhile(arr, canContinueDropping) {
+    for (let i = arr.length - 1; i >= 0; i--) {
+        if (!canContinueDropping(arr[i])) {
+            return arr.slice(0, i + 1);
+        }
+    }
+    return [];
+}
+
+function dropWhile(arr, canContinueDropping) {
+    const dropEndIndex = arr.findIndex(item => !canContinueDropping(item));
+    if (dropEndIndex === -1) {
+        return [];
+    }
+    return arr.slice(dropEndIndex);
+}
+
+function fill(array, value, start = 0, end = array.length) {
+    const length = array.length;
+    const finalStart = Math.max(start >= 0 ? start : length + start, 0);
+    const finalEnd = Math.min(end >= 0 ? end : length + end, length);
+    for (let i = finalStart; i < finalEnd; i++) {
+        array[i] = value;
+    }
+    return array;
+}
+
+function flatten(arr, depth = 1) {
+    const result = [];
+    const flooredDepth = Math.floor(depth);
+    const recursive = (arr, currentDepth) => {
+        for (const item of arr) {
+            if (Array.isArray(item) && currentDepth < flooredDepth) {
+                recursive(item, currentDepth + 1);
+            }
+            else {
+                result.push(item);
+            }
+        }
+    };
+    recursive(arr, 0);
+    return result;
+}
+
+function flatMap(arr, iteratee, depth = 1) {
+    return flatten(arr.map(item => iteratee(item)), depth);
+}
 
 function flattenDeep(arr) {
-    return initial.flatten(arr, Infinity);
-}
-
-exports.at = initial.at;
-exports.chunk = initial.chunk;
-exports.compact = initial.compact;
-exports.countBy = initial.countBy;
-exports.difference = initial.difference;
-exports.differenceBy = initial.differenceBy;
-exports.differenceWith = initial.differenceWith;
-exports.drop = initial.drop;
-exports.dropRight = initial.dropRight;
-exports.dropRightWhile = initial.dropRightWhile;
-exports.dropWhile = initial.dropWhile;
-exports.fill = initial.fill;
-exports.flatMap = initial.flatMap;
-exports.flatten = initial.flatten;
-exports.forEachRight = initial.forEachRight;
-exports.groupBy = initial.groupBy;
-exports.head = initial.head;
-exports.initial = initial.initial;
-exports.intersection = initial.intersection;
-exports.intersectionBy = initial.intersectionBy;
-exports.intersectionWith = initial.intersectionWith;
-exports.isSubset = initial.isSubset;
-exports.join = initial.join;
-exports.keyBy = initial.keyBy;
-exports.last = initial.last;
-exports.maxBy = initial.maxBy;
-exports.minBy = initial.minBy;
-exports.orderBy = initial.orderBy;
-exports.partition = initial.partition;
-exports.pullAt = initial.pullAt;
-exports.sample = initial.sample;
-exports.sampleSize = initial.sampleSize;
-exports.shuffle = initial.shuffle;
-exports.sortBy = initial.sortBy;
-exports.tail = initial.tail;
-exports.take = initial.take;
-exports.takeRight = initial.takeRight;
-exports.takeRightWhile = initial.takeRightWhile;
-exports.takeWhile = initial.takeWhile;
-exports.toFilled = initial.toFilled;
-exports.union = initial.union;
-exports.unionBy = initial.unionBy;
-exports.unionWith = initial.unionWith;
-exports.uniq = initial.uniq;
-exports.uniqBy = initial.uniqBy;
-exports.uniqWith = initial.uniqWith;
-exports.unzip = initial.unzip;
-exports.unzipWith = initial.unzipWith;
-exports.without = initial.without;
-exports.xor = initial.xor;
-exports.xorBy = initial.xorBy;
-exports.xorWith = initial.xorWith;
-exports.zip = initial.zip;
-exports.zipObject = initial.zipObject;
-exports.zipWith = initial.zipWith;
+    return flatten(arr, Infinity);
+}
+
+function flatMapDeep(arr, iteratee) {
+    return flattenDeep(arr.map((item) => iteratee(item)));
+}
+
+function forEachRight(arr, callback) {
+    for (let i = arr.length - 1; i >= 0; i--) {
+        const element = arr[i];
+        callback(element, i, arr);
+    }
+}
+
+function groupBy(arr, getKeyFromItem) {
+    const result = {};
+    for (const item of arr) {
+        const key = getKeyFromItem(item);
+        if (result[key] == null) {
+            result[key] = [];
+        }
+        result[key].push(item);
+    }
+    return result;
+}
+
+function intersection(firstArr, secondArr) {
+    const secondSet = new Set(secondArr);
+    return firstArr.filter(item => {
+        return secondSet.has(item);
+    });
+}
+
+function intersectionBy(firstArr, secondArr, mapper) {
+    const mappedSecondSet = new Set(secondArr.map(mapper));
+    return firstArr.filter(item => mappedSecondSet.has(mapper(item)));
+}
+
+function intersectionWith(firstArr, secondArr, areItemsEqual) {
+    return firstArr.filter(firstItem => {
+        return secondArr.some(secondItem => {
+            return areItemsEqual(firstItem, secondItem);
+        });
+    });
+}
+
+function join(array, separator = ',') {
+    return array.join(separator);
+}
+
+function keyBy(arr, getKeyFromItem) {
+    const result = {};
+    for (const item of arr) {
+        const key = getKeyFromItem(item);
+        result[key] = item;
+    }
+    return result;
+}
+
+function maxBy(items, getValue) {
+    let maxElement = items[0];
+    let max = -Infinity;
+    for (const element of items) {
+        const value = getValue(element);
+        if (value > max) {
+            max = value;
+            maxElement = element;
+        }
+    }
+    return maxElement;
+}
+
+function minBy(items, getValue) {
+    let minElement = items[0];
+    let min = Infinity;
+    for (const element of items) {
+        const value = getValue(element);
+        if (value < min) {
+            min = value;
+            minElement = element;
+        }
+    }
+    return minElement;
+}
+
+function compareValues(a, b, order) {
+    if (a < b) {
+        return order === 'asc' ? -1 : 1;
+    }
+    if (a > b) {
+        return order === 'asc' ? 1 : -1;
+    }
+    return 0;
+}
+
+function orderBy(arr, criteria, orders) {
+    return arr.slice().sort((a, b) => {
+        const ordersLength = orders.length;
+        for (let i = 0; i < criteria.length; i++) {
+            const order = ordersLength > i ? orders[i] : orders[ordersLength - 1];
+            const criterion = criteria[i];
+            const criterionIsFunction = typeof criterion === 'function';
+            const valueA = criterionIsFunction ? criterion(a) : a[criterion];
+            const valueB = criterionIsFunction ? criterion(b) : b[criterion];
+            const result = compareValues(valueA, valueB, order);
+            if (result !== 0) {
+                return result;
+            }
+        }
+        return 0;
+    });
+}
+
+function partition(arr, isInTruthy) {
+    const truthy = [];
+    const falsy = [];
+    for (const item of arr) {
+        if (isInTruthy(item)) {
+            truthy.push(item);
+        }
+        else {
+            falsy.push(item);
+        }
+    }
+    return [truthy, falsy];
+}
+
+function pullAt(arr, indicesToRemove) {
+    const removed = at(arr, indicesToRemove);
+    const indices = new Set(indicesToRemove.slice().sort((x, y) => y - x));
+    for (const index of indices) {
+        arr.splice(index, 1);
+    }
+    return removed;
+}
+
+function sortBy(arr, criteria) {
+    return orderBy(arr, criteria, ['asc']);
+}
+
+function sample(arr) {
+    const randomIndex = Math.floor(Math.random() * arr.length);
+    return arr[randomIndex];
+}
+
+function sampleSize(array, size) {
+    if (size > array.length) {
+        throw new Error('Size must be less than or equal to the length of array.');
+    }
+    const result = new Array(size);
+    const selected = new Set();
+    for (let step = array.length - size, resultIndex = 0; step < array.length; step++, resultIndex++) {
+        let index = randomInt.randomInt(0, step + 1);
+        if (selected.has(index)) {
+            index = step;
+        }
+        selected.add(index);
+        result[resultIndex] = array[index];
+    }
+    return result;
+}
+
+function shuffle(arr) {
+    const result = arr.slice();
+    for (let i = result.length - 1; i >= 1; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [result[i], result[j]] = [result[j], result[i]];
+    }
+    return result;
+}
+
+function take(arr, count) {
+    return arr.slice(0, count);
+}
+
+function takeRight(arr, count = 1) {
+    if (count <= 0) {
+        return [];
+    }
+    return arr.slice(-count);
+}
+
+function takeRightWhile(arr, shouldContinueTaking) {
+    for (let i = arr.length - 1; i >= 0; i--) {
+        if (!shouldContinueTaking(arr[i])) {
+            return arr.slice(i + 1);
+        }
+    }
+    return arr.slice();
+}
+
+function takeWhile(arr, shouldContinueTaking) {
+    const result = [];
+    for (const item of arr) {
+        if (!shouldContinueTaking(item)) {
+            break;
+        }
+        result.push(item);
+    }
+    return result;
+}
+
+function uniq(arr) {
+    return Array.from(new Set(arr));
+}
+
+function union(arr1, arr2) {
+    return uniq(arr1.concat(arr2));
+}
+
+function unionBy(arr1, arr2, mapper) {
+    const map = new Map();
+    for (const item of [...arr1, ...arr2]) {
+        const key = mapper(item);
+        if (!map.has(key)) {
+            map.set(key, item);
+        }
+    }
+    return Array.from(map.values());
+}
+
+function uniqWith(arr, areItemsEqual) {
+    const result = [];
+    for (const item of arr) {
+        const isUniq = result.every(v => !areItemsEqual(v, item));
+        if (isUniq) {
+            result.push(item);
+        }
+    }
+    return result;
+}
+
+function unionWith(arr1, arr2, areItemsEqual) {
+    return uniqWith(arr1.concat(arr2), areItemsEqual);
+}
+
+function uniqBy(arr, mapper) {
+    const map = new Map();
+    for (const item of arr) {
+        const key = mapper(item);
+        if (!map.has(key)) {
+            map.set(key, item);
+        }
+    }
+    return Array.from(map.values());
+}
+
+function unzip(zipped) {
+    let maxLen = 0;
+    for (let i = 0; i < zipped.length; i++) {
+        if (zipped[i].length > maxLen) {
+            maxLen = zipped[i].length;
+        }
+    }
+    const result = new Array(maxLen);
+    for (let i = 0; i < maxLen; i++) {
+        result[i] = new Array(zipped.length);
+        for (let j = 0; j < zipped.length; j++) {
+            result[i][j] = zipped[j][i];
+        }
+    }
+    return result;
+}
+
+function unzipWith(target, iteratee) {
+    const maxLength = Math.max(...target.map(innerArray => innerArray.length));
+    const result = new Array(maxLength);
+    for (let i = 0; i < maxLength; i++) {
+        const group = new Array(target.length);
+        for (let j = 0; j < target.length; j++) {
+            group[j] = target[j][i];
+        }
+        result[i] = iteratee(...group);
+    }
+    return result;
+}
+
+function xor(arr1, arr2) {
+    return difference(union(arr1, arr2), intersection(arr1, arr2));
+}
+
+function xorBy(arr1, arr2, mapper) {
+    const union = unionBy(arr1, arr2, mapper);
+    const intersection = intersectionBy(arr1, arr2, mapper);
+    return differenceBy(union, intersection, mapper);
+}
+
+function xorWith(arr1, arr2, areElementsEqual) {
+    const union = unionWith(arr1, arr2, areElementsEqual);
+    const intersection = intersectionWith(arr1, arr2, areElementsEqual);
+    return differenceWith(union, intersection, areElementsEqual);
+}
+
+function zip(...arrs) {
+    const result = [];
+    const maxIndex = Math.max(...arrs.map(x => x.length));
+    for (let i = 0; i < maxIndex; i++) {
+        const element = [];
+        for (const arr of arrs) {
+            element.push(arr[i]);
+        }
+        result.push(element);
+    }
+    return result;
+}
+
+function zipObject(keys, values) {
+    const result = {};
+    for (let i = 0; i < keys.length; i++) {
+        result[keys[i]] = values[i];
+    }
+    return result;
+}
+
+function zipWith(arr1, ...rest) {
+    const arrs = [arr1, ...rest.slice(0, -1)];
+    const combine = rest[rest.length - 1];
+    const result = [];
+    const maxIndex = Math.max(...arrs.map(arr => arr.length));
+    for (let i = 0; i < maxIndex; i++) {
+        const elements = arrs.map(arr => arr[i]);
+        result.push(combine(...elements));
+    }
+    return result;
+}
+
+function without(array, ...values) {
+    const valuesSet = new Set(values);
+    return array.filter(item => !valuesSet.has(item));
+}
+
+function head(arr) {
+    return arr[0];
+}
+
+function isSubset(superset, subset) {
+    return difference(subset, superset).length === 0;
+}
+
+function tail(arr) {
+    return arr.slice(1);
+}
+
+function toFilled(arr, value, start = 0, end = arr.length) {
+    const length = arr.length;
+    const finalStart = Math.max(start >= 0 ? start : length + start, 0);
+    const finalEnd = Math.min(end >= 0 ? end : length + end, length);
+    const newArr = arr.slice();
+    for (let i = finalStart; i < finalEnd; i++) {
+        newArr[i] = value;
+    }
+    return newArr;
+}
+
+function last(arr) {
+    return arr[arr.length - 1];
+}
+
+function initial(arr) {
+    return arr.slice(0, -1);
+}
+
+exports.at = at;
+exports.chunk = chunk;
+exports.compact = compact;
+exports.countBy = countBy;
+exports.difference = difference;
+exports.differenceBy = differenceBy;
+exports.differenceWith = differenceWith;
+exports.drop = drop;
+exports.dropRight = dropRight;
+exports.dropRightWhile = dropRightWhile;
+exports.dropWhile = dropWhile;
+exports.fill = fill;
+exports.flatMap = flatMap;
+exports.flatMapDeep = flatMapDeep;
+exports.flatten = flatten;
 exports.flattenDeep = flattenDeep;
+exports.forEachRight = forEachRight;
+exports.groupBy = groupBy;
+exports.head = head;
+exports.initial = initial;
+exports.intersection = intersection;
+exports.intersectionBy = intersectionBy;
+exports.intersectionWith = intersectionWith;
+exports.isSubset = isSubset;
+exports.join = join;
+exports.keyBy = keyBy;
+exports.last = last;
+exports.maxBy = maxBy;
+exports.minBy = minBy;
+exports.orderBy = orderBy;
+exports.partition = partition;
+exports.pullAt = pullAt;
+exports.sample = sample;
+exports.sampleSize = sampleSize;
+exports.shuffle = shuffle;
+exports.sortBy = sortBy;
+exports.tail = tail;
+exports.take = take;
+exports.takeRight = takeRight;
+exports.takeRightWhile = takeRightWhile;
+exports.takeWhile = takeWhile;
+exports.toFilled = toFilled;
+exports.union = union;
+exports.unionBy = unionBy;
+exports.unionWith = unionWith;
+exports.uniq = uniq;
+exports.uniqBy = uniqBy;
+exports.uniqWith = uniqWith;
+exports.unzip = unzip;
+exports.unzipWith = unzipWith;
+exports.without = without;
+exports.xor = xor;
+exports.xorBy = xorBy;
+exports.xorWith = xorWith;
+exports.zip = zip;
+exports.zipObject = zipObject;
+exports.zipWith = zipWith;

package/dist/array/index.mjs

@@ -11,6 +11,7 @@ export { dropRightWhile } from './dropRightWhile.mjs';
 export { dropWhile } from './dropWhile.mjs';
 export { fill } from './fill.mjs';
 export { flatMap } from './flatMap.mjs';
+export { flatMapDeep } from './flatMapDeep.mjs';
 export { flatten } from './flatten.mjs';
 export { flattenDeep } from './flattenDeep.mjs';
 export { forEachRight } from './forEachRight.mjs';