es-toolkit 1.32.0-dev.1007 → 1.32.0-dev.1009

package/dist/compat/array/reduce.d.mts

@@ -0,0 +1,109 @@
+/**
+ * Reduces an array to a single value using an iteratee function.
+ *
+ * The `reduce()` function goes through each element in an array and applies a special function (called a "reducer") to them, one by one.
+ * This function takes the result of the previous step and the current element to perform a calculation.
+ * After going through all the elements, the function gives you one final result.
+ *
+ * When the `reduce()` function starts, there's no previous result to use.
+ * If you provide an initial value, it starts with that.
+ * If not, it uses the first element of the array and begins with the second element for the calculation.
+ *
+ * @param {readonly T[]} collection - The collection to iterate over.
+ * @param {(accumulator: U, value: T, index: number, collection: readonly T[]) => U} iteratee - The function invoked per iteration.
+ * @param {U} initialValue - The initial value.
+ * @returns {U} - Returns the accumulated value.
+ *
+ * @example
+ * const arrayLike = [1, 2, 3];
+ * reduce(arrayLike, (acc, value) => acc && value % 2 === 0, true); // => false
+ */
+declare function reduce<T, U>(collection: readonly T[], iteratee: (accumulator: U, value: T, index: number, collection: readonly T[]) => U, initialValue: U): U;
+/**
+ * Reduces an array to a single value using an iteratee function.
+ *
+ * The `reduce()` function goes through each element in an array and applies a special function (called a "reducer") to them, one by one.
+ * This function takes the result of the previous step and the current element to perform a calculation.
+ * After going through all the elements, the function gives you one final result.
+ *
+ * When the `reduce()` function starts, there's no previous result to use.
+ * If you provide an initial value, it starts with that.
+ * If not, it uses the first element of the array and begins with the second element for the calculation.
+ *
+ * @param {readonly T[]} collection - The collection to iterate over.
+ * @param {(accumulator: T, value: T, index: number, collection: readonly T[]) => T} iteratee - The function invoked per iteration.
+ * @returns {T} - Returns the accumulated value.
+ *
+ * @example
+ * const arrayLike = [1, 2, 3];
+ * reduce(arrayLike, (acc, value) => acc + value); // => 6
+ */
+declare function reduce<T>(collection: readonly T[], iteratee: (accumulator: T, value: T, index: number, collection: readonly T[]) => T): T;
+/**
+ * Reduces an array to a single value using an iteratee function.
+ *
+ * The `reduce()` function goes through each element in an array and applies a special function (called a "reducer") to them, one by one.
+ * This function takes the result of the previous step and the current element to perform a calculation.
+ * After going through all the elements, the function gives you one final result.
+ *
+ * When the `reduce()` function starts, there's no previous result to use.
+ * If you provide an initial value, it starts with that.
+ * If not, it uses the first element of the array and begins with the second element for the calculation.
+ *
+ * @param {ArrayLike<T>} collection - The collection to iterate over.
+ * @param {(accumulator: U, value: T, index: number, collection: ArrayLike<T>) => U} iteratee - The function invoked per iteration.
+ * @param {U} initialValue - The initial value.
+ * @returns {U} - Returns the accumulated value.
+ *
+ * @example
+ * const arrayLike = {0: 1, 1: 2, 2: 3, length: 3};
+ * reduce(arrayLike, (acc, value) => acc + value % 2 === 0, true); // => false
+ */
+declare function reduce<T, U>(collection: ArrayLike<T>, iteratee: (accumulator: U, value: T, index: number, collection: ArrayLike<T>) => U, initialValue: U): U;
+/**
+ * Reduces an array to a single value using an iteratee function.
+ *
+ * The `reduce()` function goes through each element in an array and applies a special function (called a "reducer") to them, one by one.
+ * This function takes the result of the previous step and the current element to perform a calculation.
+ * After going through all the elements, the function gives you one final result.
+ *
+ * When the `reduce()` function starts, there's no previous result to use.
+ * If you provide an initial value, it starts with that.
+ * If not, it uses the first element of the array and begins with the second element for the calculation.
+ *
+ * @param {ArrayLike<T>} collection - The collection to iterate over.
+ * @param {(accumulator: U, value: T, index: number, collection: ArrayLike<T>) => U} iteratee - The function invoked per iteration.
+ * @returns {T} - Returns the accumulated value.
+ *
+ * @example
+ * const arrayLike = {0: 1, 1: 2, 2: 3, length: 3};
+ * reduce(arrayLike, (acc, value) => acc + value); // => 6
+ */
+declare function reduce<T>(collection: ArrayLike<T>, iteratee: (accumulator: T, value: T, index: number, collection: ArrayLike<T>) => T): T;
+/**
+ * Reduces an object to a single value using an iteratee function.
+ *
+ * @param {T} collection - The object to iterate over.
+ * @param {(accumulator: U, value: T[keyof T], key: string, collection: T) => U} iteratee - The function invoked per iteration.
+ * @param {U} initialValue - The initial value.
+ * @returns {U} - Returns the accumulated value.
+ *
+ * @example
+ * const obj = { a: 1, b: 2, c: 3 };
+ * reduce(obj, (acc, value) => acc + value % 2 === 0, true); // => false
+ */
+declare function reduce<T extends object, U>(collection: T, iteratee: (accumulator: U, value: T[keyof T], key: keyof T, collection: T) => U, initialValue: U): U;
+/**
+ * Reduces an object to a single value using an iteratee function.
+ *
+ * @param {T} collection - The object to iterate over.
+ * @param {(accumulator: T[keyof T], value: T[keyof T], key: keyof T, collection: T) => U} iteratee - The function invoked per iteration.
+ * @returns {T[keyof T]} - Returns the accumulated value.
+ *
+ * @example
+ * const obj = { a: 1, b: 2, c: 3 };
+ * reduce(obj, (acc, value) => acc + value); // => 6
+ */
+declare function reduce<T extends object>(collection: T, iteratee: (accumulator: T[keyof T], value: T[keyof T], key: keyof T, collection: T) => T[keyof T]): T[keyof T];
+
+export { reduce };

package/dist/compat/array/reduce.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Reduces an array to a single value using an iteratee function.
+ *
+ * The `reduce()` function goes through each element in an array and applies a special function (called a "reducer") to them, one by one.
+ * This function takes the result of the previous step and the current element to perform a calculation.
+ * After going through all the elements, the function gives you one final result.
+ *
+ * When the `reduce()` function starts, there's no previous result to use.
+ * If you provide an initial value, it starts with that.
+ * If not, it uses the first element of the array and begins with the second element for the calculation.
+ *
+ * @param {readonly T[]} collection - The collection to iterate over.
+ * @param {(accumulator: U, value: T, index: number, collection: readonly T[]) => U} iteratee - The function invoked per iteration.
+ * @param {U} initialValue - The initial value.
+ * @returns {U} - Returns the accumulated value.
+ *
+ * @example
+ * const arrayLike = [1, 2, 3];
+ * reduce(arrayLike, (acc, value) => acc && value % 2 === 0, true); // => false
+ */
+declare function reduce<T, U>(collection: readonly T[], iteratee: (accumulator: U, value: T, index: number, collection: readonly T[]) => U, initialValue: U): U;
+/**
+ * Reduces an array to a single value using an iteratee function.
+ *
+ * The `reduce()` function goes through each element in an array and applies a special function (called a "reducer") to them, one by one.
+ * This function takes the result of the previous step and the current element to perform a calculation.
+ * After going through all the elements, the function gives you one final result.
+ *
+ * When the `reduce()` function starts, there's no previous result to use.
+ * If you provide an initial value, it starts with that.
+ * If not, it uses the first element of the array and begins with the second element for the calculation.
+ *
+ * @param {readonly T[]} collection - The collection to iterate over.
+ * @param {(accumulator: T, value: T, index: number, collection: readonly T[]) => T} iteratee - The function invoked per iteration.
+ * @returns {T} - Returns the accumulated value.
+ *
+ * @example
+ * const arrayLike = [1, 2, 3];
+ * reduce(arrayLike, (acc, value) => acc + value); // => 6
+ */
+declare function reduce<T>(collection: readonly T[], iteratee: (accumulator: T, value: T, index: number, collection: readonly T[]) => T): T;
+/**
+ * Reduces an array to a single value using an iteratee function.
+ *
+ * The `reduce()` function goes through each element in an array and applies a special function (called a "reducer") to them, one by one.
+ * This function takes the result of the previous step and the current element to perform a calculation.
+ * After going through all the elements, the function gives you one final result.
+ *
+ * When the `reduce()` function starts, there's no previous result to use.
+ * If you provide an initial value, it starts with that.
+ * If not, it uses the first element of the array and begins with the second element for the calculation.
+ *
+ * @param {ArrayLike<T>} collection - The collection to iterate over.
+ * @param {(accumulator: U, value: T, index: number, collection: ArrayLike<T>) => U} iteratee - The function invoked per iteration.
+ * @param {U} initialValue - The initial value.
+ * @returns {U} - Returns the accumulated value.
+ *
+ * @example
+ * const arrayLike = {0: 1, 1: 2, 2: 3, length: 3};
+ * reduce(arrayLike, (acc, value) => acc + value % 2 === 0, true); // => false
+ */
+declare function reduce<T, U>(collection: ArrayLike<T>, iteratee: (accumulator: U, value: T, index: number, collection: ArrayLike<T>) => U, initialValue: U): U;
+/**
+ * Reduces an array to a single value using an iteratee function.
+ *
+ * The `reduce()` function goes through each element in an array and applies a special function (called a "reducer") to them, one by one.
+ * This function takes the result of the previous step and the current element to perform a calculation.
+ * After going through all the elements, the function gives you one final result.
+ *
+ * When the `reduce()` function starts, there's no previous result to use.
+ * If you provide an initial value, it starts with that.
+ * If not, it uses the first element of the array and begins with the second element for the calculation.
+ *
+ * @param {ArrayLike<T>} collection - The collection to iterate over.
+ * @param {(accumulator: U, value: T, index: number, collection: ArrayLike<T>) => U} iteratee - The function invoked per iteration.
+ * @returns {T} - Returns the accumulated value.
+ *
+ * @example
+ * const arrayLike = {0: 1, 1: 2, 2: 3, length: 3};
+ * reduce(arrayLike, (acc, value) => acc + value); // => 6
+ */
+declare function reduce<T>(collection: ArrayLike<T>, iteratee: (accumulator: T, value: T, index: number, collection: ArrayLike<T>) => T): T;
+/**
+ * Reduces an object to a single value using an iteratee function.
+ *
+ * @param {T} collection - The object to iterate over.
+ * @param {(accumulator: U, value: T[keyof T], key: string, collection: T) => U} iteratee - The function invoked per iteration.
+ * @param {U} initialValue - The initial value.
+ * @returns {U} - Returns the accumulated value.
+ *
+ * @example
+ * const obj = { a: 1, b: 2, c: 3 };
+ * reduce(obj, (acc, value) => acc + value % 2 === 0, true); // => false
+ */
+declare function reduce<T extends object, U>(collection: T, iteratee: (accumulator: U, value: T[keyof T], key: keyof T, collection: T) => U, initialValue: U): U;
+/**
+ * Reduces an object to a single value using an iteratee function.
+ *
+ * @param {T} collection - The object to iterate over.
+ * @param {(accumulator: T[keyof T], value: T[keyof T], key: keyof T, collection: T) => U} iteratee - The function invoked per iteration.
+ * @returns {T[keyof T]} - Returns the accumulated value.
+ *
+ * @example
+ * const obj = { a: 1, b: 2, c: 3 };
+ * reduce(obj, (acc, value) => acc + value); // => 6
+ */
+declare function reduce<T extends object>(collection: T, iteratee: (accumulator: T[keyof T], value: T[keyof T], key: keyof T, collection: T) => T[keyof T]): T[keyof T];
+
+export { reduce };

package/dist/compat/array/reduce.mjs

@@ -0,0 +1,33 @@
+import { identity } from '../../function/identity.mjs';
+import { range } from '../../math/range.mjs';
+import { isArrayLike } from '../predicate/isArrayLike.mjs';
+
+function reduce(collection, iteratee = identity, accumulator) {
+    if (!collection) {
+        return accumulator;
+    }
+    let keys;
+    let startIndex = 0;
+    if (isArrayLike(collection)) {
+        keys = range(0, collection.length);
+        if (accumulator == null && collection.length > 0) {
+            accumulator = collection[0];
+            startIndex += 1;
+        }
+    }
+    else {
+        keys = Object.keys(collection);
+        if (accumulator == null) {
+            accumulator = collection[keys[0]];
+            startIndex += 1;
+        }
+    }
+    for (let i = startIndex; i < keys.length; i++) {
+        const key = keys[i];
+        const value = collection[key];
+        accumulator = iteratee(accumulator, value, key, collection);
+    }
+    return accumulator;
+}
+
+export { reduce };

package/dist/compat/index.d.mts

@@ -105,6 +105,7 @@ export { orderBy } from './array/orderBy.mjs';
 export { pull } from './array/pull.mjs';
 export { pullAll } from './array/pullAll.mjs';
 export { pullAllBy } from './array/pullAllBy.mjs';
+export { reduce } from './array/reduce.mjs';
 export { remove } from './array/remove.mjs';
 export { reverse } from './array/reverse.mjs';
 export { sample } from './array/sample.mjs';

package/dist/compat/index.d.ts

@@ -105,6 +105,7 @@ export { orderBy } from './array/orderBy.js';
 export { pull } from './array/pull.js';
 export { pullAll } from './array/pullAll.js';
 export { pullAllBy } from './array/pullAllBy.js';
+export { reduce } from './array/reduce.js';
 export { remove } from './array/remove.js';
 export { reverse } from './array/reverse.js';
 export { sample } from './array/sample.js';

package/dist/compat/index.js

@@ -1250,6 +1250,34 @@ function pullAllBy(arr, valuesToRemove, _getValue) {
     return arr;
 }
 
+function reduce(collection, iteratee = unary.identity, accumulator) {
+    if (!collection) {
+        return accumulator;
+    }
+    let keys;
+    let startIndex = 0;
+    if (isArrayLike(collection)) {
+        keys = range$1.range(0, collection.length);
+        if (accumulator == null && collection.length > 0) {
+            accumulator = collection[0];
+            startIndex += 1;
+        }
+    }
+    else {
+        keys = Object.keys(collection);
+        if (accumulator == null) {
+            accumulator = collection[keys[0]];
+            startIndex += 1;
+        }
+    }
+    for (let i = startIndex; i < keys.length; i++) {
+        const key = keys[i];
+        const value = collection[key];
+        accumulator = iteratee(accumulator, value, key, collection);
+    }
+    return accumulator;
+}
+
 function remove(arr, shouldRemoveElement) {
     return zipWith.remove(arr, iteratee(shouldRemoveElement));
 }
@@ -2173,11 +2201,16 @@ function sumBy(array, iteratee$1) {
     if (iteratee$1 != null) {
         iteratee$1 = iteratee(iteratee$1);
     }
-    let result = iteratee$1 ? iteratee$1(array[0]) : array[0];
-    for (let i = 1; i < array.length; i++) {
+    let result = undefined;
+    for (let i = 0; i < array.length; i++) {
         const current = iteratee$1 ? iteratee$1(array[i]) : array[i];
         if (current !== undefined) {
-            result += current;
+            if (result === undefined) {
+                result = current;
+            }
+            else {
+                result += current;
+            }
         }
     }
     return result;
@@ -3429,6 +3462,7 @@ exports.random = random;
 exports.range = range;
 exports.rangeRight = rangeRight;
 exports.rearg = rearg;
+exports.reduce = reduce;
 exports.remove = remove;
 exports.repeat = repeat;
 exports.replace = replace;

package/dist/compat/index.mjs

@@ -107,6 +107,7 @@ export { orderBy } from './array/orderBy.mjs';
 export { pull } from './array/pull.mjs';
 export { pullAll } from './array/pullAll.mjs';
 export { pullAllBy } from './array/pullAllBy.mjs';
+export { reduce } from './array/reduce.mjs';
 export { remove } from './array/remove.mjs';
 export { reverse } from './array/reverse.mjs';
 export { sample } from './array/sample.mjs';

package/dist/compat/math/sumBy.mjs

@@ -7,11 +7,16 @@ function sumBy(array, iteratee$1) {
     if (iteratee$1 != null) {
         iteratee$1 = iteratee(iteratee$1);
     }
-    let result = iteratee$1 ? iteratee$1(array[0]) : array[0];
-    for (let i = 1; i < array.length; i++) {
+    let result = undefined;
+    for (let i = 0; i < array.length; i++) {
         const current = iteratee$1 ? iteratee$1(array[i]) : array[i];
         if (current !== undefined) {
-            result += current;
+            if (result === undefined) {
+                result = current;
+            }
+            else {
+                result += current;
+            }
         }
     }
     return result;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "es-toolkit",
   "description": "A state-of-the-art, high-performance JavaScript utility library with a small bundle size and strong type annotations.",
-  "version": "1.32.0-dev.1007+9bc5fa98",
+  "version": "1.32.0-dev.1009+f0e254af",
   "homepage": "https://es-toolkit.slash.page",
   "bugs": "https://github.com/toss/es-toolkit/issues",
   "repository": {