es-toolkit 1.35.0-dev.1202 → 1.35.0-dev.1206

package/dist/_chunk/{unary-BsNWRM.js → unary-EIEhcF.js}

@@ -134,6 +134,48 @@ function once(func) {
     };
 }
 
+function partial(func, ...partialArgs) {
+    return partialImpl(func, placeholderSymbol$1, ...partialArgs);
+}
+function partialImpl(func, placeholder, ...partialArgs) {
+    const partialed = function (...providedArgs) {
+        let providedArgsIndex = 0;
+        const substitutedArgs = partialArgs
+            .slice()
+            .map(arg => (arg === placeholder ? providedArgs[providedArgsIndex++] : arg));
+        const remainingArgs = providedArgs.slice(providedArgsIndex);
+        return func.apply(this, substitutedArgs.concat(remainingArgs));
+    };
+    if (func.prototype) {
+        partialed.prototype = Object.create(func.prototype);
+    }
+    return partialed;
+}
+const placeholderSymbol$1 = Symbol('partial.placeholder');
+partial.placeholder = placeholderSymbol$1;
+
+function partialRight(func, ...partialArgs) {
+    return partialRightImpl(func, placeholderSymbol, ...partialArgs);
+}
+function partialRightImpl(func, placeholder, ...partialArgs) {
+    const partialedRight = function (...providedArgs) {
+        const placeholderLength = partialArgs.filter(arg => arg === placeholder).length;
+        const rangeLength = Math.max(providedArgs.length - placeholderLength, 0);
+        const remainingArgs = providedArgs.slice(0, rangeLength);
+        let providedArgsIndex = rangeLength;
+        const substitutedArgs = partialArgs
+            .slice()
+            .map(arg => (arg === placeholder ? providedArgs[providedArgsIndex++] : arg));
+        return func.apply(this, remainingArgs.concat(substitutedArgs));
+    };
+    if (func.prototype) {
+        partialedRight.prototype = Object.create(func.prototype);
+    }
+    return partialedRight;
+}
+const placeholderSymbol = Symbol('partialRight.placeholder');
+partialRight.placeholder = placeholderSymbol;
+
 function rest(func, startIndex = func.length - 1) {
     return function (...args) {
         const rest = args.slice(startIndex);
@@ -192,6 +234,10 @@ exports.identity = identity;
 exports.memoize = memoize;
 exports.negate = negate;
 exports.once = once;
+exports.partial = partial;
+exports.partialImpl = partialImpl;
+exports.partialRight = partialRight;
+exports.partialRightImpl = partialRightImpl;
 exports.rest = rest;
 exports.retry = retry;
 exports.unary = unary;

package/dist/_chunk/{zip-DxZJSH.js → zipWith-ChDTPy.js}

@@ -2,6 +2,20 @@
 
 const randomInt = require('./randomInt-CF7bZK.js');
 
+function at(arr, indices) {
+    const result = new Array(indices.length);
+    const length = arr.length;
+    for (let i = 0; i < indices.length; i++) {
+        let index = indices[i];
+        index = Number.isInteger(index) ? index : Math.trunc(index) || 0;
+        if (index < 0) {
+            index += length;
+        }
+        result[i] = arr[index];
+    }
+    return result;
+}
+
 function chunk(arr, size) {
     if (!Number.isInteger(size) || size <= 0) {
         throw new Error('Size must be an integer greater than zero.');
@@ -115,6 +129,10 @@ function flatten(arr, depth = 1) {
     return result;
 }
 
+function flatMap(arr, iteratee, depth = 1) {
+    return flatten(arr.map(item => iteratee(item)), depth);
+}
+
 function flattenDeep(arr) {
     return flatten(arr, Infinity);
 }
@@ -123,6 +141,13 @@ 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 (let i = 0; i < arr.length; i++) {
@@ -214,6 +239,21 @@ function minBy(items, getValue) {
     return minElement;
 }
 
+function partition(arr, isInTruthy) {
+    const truthy = [];
+    const falsy = [];
+    for (let i = 0; i < arr.length; i++) {
+        const item = arr[i];
+        if (isInTruthy(item)) {
+            truthy.push(item);
+        }
+        else {
+            falsy.push(item);
+        }
+    }
+    return [truthy, falsy];
+}
+
 function pull(arr, valuesToRemove) {
     const valuesSet = new Set(valuesToRemove);
     let resultIndex = 0;
@@ -231,6 +271,15 @@ function pull(arr, valuesToRemove) {
     return arr;
 }
 
+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 remove(arr, shouldRemoveElement) {
     const originalArr = arr.slice();
     const removed = [];
@@ -431,6 +480,27 @@ function zip(...arrs) {
     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 maxIndex = Math.max(...arrs.map(arr => arr.length));
+    const result = Array(maxIndex);
+    for (let i = 0; i < maxIndex; i++) {
+        const elements = arrs.map(arr => arr[i]);
+        result[i] = combine(...elements);
+    }
+    return result;
+}
+
+exports.at = at;
 exports.chunk = chunk;
 exports.compact = compact;
 exports.countBy = countBy;
@@ -442,9 +512,11 @@ 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;
@@ -457,7 +529,9 @@ exports.keyBy = keyBy;
 exports.last = last;
 exports.maxBy = maxBy;
 exports.minBy = minBy;
+exports.partition = partition;
 exports.pull = pull;
+exports.pullAt = pullAt;
 exports.remove = remove;
 exports.sample = sample;
 exports.sampleSize = sampleSize;
@@ -480,3 +554,5 @@ exports.xor = xor;
 exports.xorBy = xorBy;
 exports.xorWith = xorWith;
 exports.zip = zip;
+exports.zipObject = zipObject;
+exports.zipWith = zipWith;

package/dist/array/index.js

@@ -2,32 +2,7 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const zip = require('../_chunk/zip-DxZJSH.js');
-
-function at(arr, indices) {
-    const result = new Array(indices.length);
-    const length = arr.length;
-    for (let i = 0; i < indices.length; i++) {
-        let index = indices[i];
-        index = Number.isInteger(index) ? index : Math.trunc(index) || 0;
-        if (index < 0) {
-            index += length;
-        }
-        result[i] = arr[index];
-    }
-    return result;
-}
-
-function flatMap(arr, iteratee, depth = 1) {
-    return zip.flatten(arr.map(item => iteratee(item)), depth);
-}
-
-function forEachRight(arr, callback) {
-    for (let i = arr.length - 1; i >= 0; i--) {
-        const element = arr[i];
-        callback(element, i, arr);
-    }
-}
+const zipWith = require('../_chunk/zipWith-ChDTPy.js');
 
 function compareValues(a, b, order) {
     if (a < b) {
@@ -57,30 +32,6 @@ function orderBy(arr, criteria, orders) {
     });
 }
 
-function partition(arr, isInTruthy) {
-    const truthy = [];
-    const falsy = [];
-    for (let i = 0; i < arr.length; i++) {
-        const item = arr[i];
-        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']);
 }
@@ -106,83 +57,63 @@ function takeWhile(arr, shouldContinueTaking) {
     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 maxIndex = Math.max(...arrs.map(arr => arr.length));
-    const result = Array(maxIndex);
-    for (let i = 0; i < maxIndex; i++) {
-        const elements = arrs.map(arr => arr[i]);
-        result[i] = combine(...elements);
-    }
-    return result;
-}
-
-exports.chunk = zip.chunk;
-exports.compact = zip.compact;
-exports.countBy = zip.countBy;
-exports.difference = zip.difference;
-exports.differenceBy = zip.differenceBy;
-exports.differenceWith = zip.differenceWith;
-exports.drop = zip.drop;
-exports.dropRight = zip.dropRight;
-exports.dropRightWhile = zip.dropRightWhile;
-exports.dropWhile = zip.dropWhile;
-exports.fill = zip.fill;
-exports.flatMapDeep = zip.flatMapDeep;
-exports.flatten = zip.flatten;
-exports.flattenDeep = zip.flattenDeep;
-exports.groupBy = zip.groupBy;
-exports.head = zip.head;
-exports.initial = zip.initial;
-exports.intersection = zip.intersection;
-exports.intersectionBy = zip.intersectionBy;
-exports.intersectionWith = zip.intersectionWith;
-exports.isSubset = zip.isSubset;
-exports.isSubsetWith = zip.isSubsetWith;
-exports.keyBy = zip.keyBy;
-exports.last = zip.last;
-exports.maxBy = zip.maxBy;
-exports.minBy = zip.minBy;
-exports.pull = zip.pull;
-exports.remove = zip.remove;
-exports.sample = zip.sample;
-exports.sampleSize = zip.sampleSize;
-exports.shuffle = zip.shuffle;
-exports.tail = zip.tail;
-exports.take = zip.take;
-exports.takeRight = zip.takeRight;
-exports.toFilled = zip.toFilled;
-exports.union = zip.union;
-exports.unionBy = zip.unionBy;
-exports.unionWith = zip.unionWith;
-exports.uniq = zip.uniq;
-exports.uniqBy = zip.uniqBy;
-exports.uniqWith = zip.uniqWith;
-exports.unzip = zip.unzip;
-exports.unzipWith = zip.unzipWith;
-exports.windowed = zip.windowed;
-exports.without = zip.without;
-exports.xor = zip.xor;
-exports.xorBy = zip.xorBy;
-exports.xorWith = zip.xorWith;
-exports.zip = zip.zip;
-exports.at = at;
-exports.flatMap = flatMap;
-exports.forEachRight = forEachRight;
+exports.at = zipWith.at;
+exports.chunk = zipWith.chunk;
+exports.compact = zipWith.compact;
+exports.countBy = zipWith.countBy;
+exports.difference = zipWith.difference;
+exports.differenceBy = zipWith.differenceBy;
+exports.differenceWith = zipWith.differenceWith;
+exports.drop = zipWith.drop;
+exports.dropRight = zipWith.dropRight;
+exports.dropRightWhile = zipWith.dropRightWhile;
+exports.dropWhile = zipWith.dropWhile;
+exports.fill = zipWith.fill;
+exports.flatMap = zipWith.flatMap;
+exports.flatMapDeep = zipWith.flatMapDeep;
+exports.flatten = zipWith.flatten;
+exports.flattenDeep = zipWith.flattenDeep;
+exports.forEachRight = zipWith.forEachRight;
+exports.groupBy = zipWith.groupBy;
+exports.head = zipWith.head;
+exports.initial = zipWith.initial;
+exports.intersection = zipWith.intersection;
+exports.intersectionBy = zipWith.intersectionBy;
+exports.intersectionWith = zipWith.intersectionWith;
+exports.isSubset = zipWith.isSubset;
+exports.isSubsetWith = zipWith.isSubsetWith;
+exports.keyBy = zipWith.keyBy;
+exports.last = zipWith.last;
+exports.maxBy = zipWith.maxBy;
+exports.minBy = zipWith.minBy;
+exports.partition = zipWith.partition;
+exports.pull = zipWith.pull;
+exports.pullAt = zipWith.pullAt;
+exports.remove = zipWith.remove;
+exports.sample = zipWith.sample;
+exports.sampleSize = zipWith.sampleSize;
+exports.shuffle = zipWith.shuffle;
+exports.tail = zipWith.tail;
+exports.take = zipWith.take;
+exports.takeRight = zipWith.takeRight;
+exports.toFilled = zipWith.toFilled;
+exports.union = zipWith.union;
+exports.unionBy = zipWith.unionBy;
+exports.unionWith = zipWith.unionWith;
+exports.uniq = zipWith.uniq;
+exports.uniqBy = zipWith.uniqBy;
+exports.uniqWith = zipWith.uniqWith;
+exports.unzip = zipWith.unzip;
+exports.unzipWith = zipWith.unzipWith;
+exports.windowed = zipWith.windowed;
+exports.without = zipWith.without;
+exports.xor = zipWith.xor;
+exports.xorBy = zipWith.xorBy;
+exports.xorWith = zipWith.xorWith;
+exports.zip = zipWith.zip;
+exports.zipObject = zipWith.zipObject;
+exports.zipWith = zipWith.zipWith;
 exports.orderBy = orderBy;
-exports.partition = partition;
-exports.pullAt = pullAt;
 exports.sortBy = sortBy;
 exports.takeRightWhile = takeRightWhile;
 exports.takeWhile = takeWhile;
-exports.zipObject = zipObject;
-exports.zipWith = zipWith;