es-toolkit 1.21.0-dev.668 → 1.21.0-dev.670

package/dist/compat/index.d.mts

@@ -57,6 +57,7 @@ export { MemoizeCache, memoize } from '../function/memoize.mjs';
 export { unary } from '../function/unary.mjs';
 export { partial } from '../function/partial.mjs';
 export { partialRight } from '../function/partialRight.mjs';
+export { flow } from '../function/flow.mjs';
 export { mean } from '../math/mean.mjs';
 export { meanBy } from '../math/meanBy.mjs';
 export { randomInt } from '../math/randomInt.mjs';

package/dist/compat/index.d.ts

@@ -57,6 +57,7 @@ export { MemoizeCache, memoize } from '../function/memoize.js';
 export { unary } from '../function/unary.js';
 export { partial } from '../function/partial.js';
 export { partialRight } from '../function/partialRight.js';
+export { flow } from '../function/flow.js';
 export { mean } from '../math/mean.js';
 export { meanBy } from '../math/meanBy.js';
 export { randomInt } from '../math/randomInt.js';

package/dist/compat/index.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const zipWith = require('../_chunk/zipWith-DEcUS4.js');
 const promise_index = require('../_chunk/index-BGZDR9.js');
-const rest$1 = require('../_chunk/rest-pUyjvl.js');
+const flow = require('../_chunk/flow-Au34h2.js');
 const range = require('../_chunk/range-BXlMmn.js');
 const randomInt = require('../_chunk/randomInt-CF7bZK.js');
 const toMerged = require('../_chunk/toMerged-DVBECd.js');
@@ -730,7 +730,7 @@ function ary(func, n = func.length, guard) {
     if (Number.isNaN(n) || n < 0) {
         n = 0;
     }
-    return rest$1.ary(func, n);
+    return flow.ary(func, n);
 }
 
 function bind(func, thisObj, ...partialArgs) {
@@ -797,7 +797,7 @@ function rest(func, start = func.length - 1) {
     if (Number.isNaN(start) || start < 0) {
         start = func.length - 1;
     }
-    return rest$1.rest(func, start);
+    return flow.rest(func, start);
 }
 
 function spread(func, argsIndex = 0) {
@@ -905,7 +905,7 @@ function debounce(func, debounceMs = 0, options = {}) {
     }
     let result = undefined;
     let pendingAt = null;
-    const _debounced = rest$1.debounce(function (...args) {
+    const _debounced = flow.debounce(function (...args) {
         result = func.apply(this, args);
         pendingAt = null;
     }, debounceMs, { signal, edges });
@@ -1211,7 +1211,7 @@ function mergeWithDeep(target, source, merge, stack) {
 }
 
 function merge(object, ...sources) {
-    return mergeWith(object, ...sources, rest$1.noop);
+    return mergeWith(object, ...sources, flow.noop);
 }
 
 function isArrayLike(value) {
@@ -1702,15 +1702,16 @@ exports.TimeoutError = promise_index.TimeoutError;
 exports.delay = promise_index.delay;
 exports.timeout = promise_index.timeout;
 exports.withTimeout = promise_index.withTimeout;
-exports.after = rest$1.after;
-exports.before = rest$1.before;
-exports.memoize = rest$1.memoize;
-exports.negate = rest$1.negate;
-exports.noop = rest$1.noop;
-exports.once = rest$1.once;
-exports.partial = rest$1.partial;
-exports.partialRight = rest$1.partialRight;
-exports.unary = rest$1.unary;
+exports.after = flow.after;
+exports.before = flow.before;
+exports.flow = flow.flow;
+exports.memoize = flow.memoize;
+exports.negate = flow.negate;
+exports.noop = flow.noop;
+exports.once = flow.once;
+exports.partial = flow.partial;
+exports.partialRight = flow.partialRight;
+exports.unary = flow.unary;
 exports.mean = range.mean;
 exports.meanBy = range.meanBy;
 exports.range = range.range;

package/dist/compat/index.mjs

@@ -57,6 +57,7 @@ export { memoize } from '../function/memoize.mjs';
 export { unary } from '../function/unary.mjs';
 export { partial } from '../function/partial.mjs';
 export { partialRight } from '../function/partialRight.mjs';
+export { flow } from '../function/flow.mjs';
 export { mean } from '../math/mean.mjs';
 export { meanBy } from '../math/meanBy.mjs';
 export { randomInt } from '../math/randomInt.mjs';

package/dist/function/flow.d.mts

@@ -0,0 +1,118 @@
+/**
+ * Creates a function that returns the result of invoking the given functions with the `this` binding of the created function, where each successive invocation is supplied the return value of the previous.
+ *
+ * @param {() => R} f The function to invoke.
+ * @returns {() => R} Returns the new composite function.
+ *
+ * @example
+ * function noArgFunc() {
+ *  return 42;
+ * }
+ *
+ * const combined = flow(noArgFunc);
+ * console.log(combined()); // 42
+ */
+declare function flow<R>(f: () => R): () => R;
+/**
+ * Creates a function that returns the result of invoking the given functions with the `this` binding of the created function, where each successive invocation is supplied the return value of the previous.
+ *
+ * @param {(...args: A) => R} f1 The function to invoke.
+ * @returns {(...args: A) => R} Returns the new composite function.
+ *
+ * @example
+ * function oneArgFunc(a: number) {
+ *   return a * 2;
+ * }
+ *
+ * const combined = flow(oneArgFunc);
+ * console.log(combined(5)); // 10
+ */
+declare function flow<A extends any[], R>(f1: (...args: A) => R): (...args: A) => R;
+/**
+ * Creates a function that returns the result of invoking the given functions with the `this` binding of the created function, where each successive invocation is supplied the return value of the previous.
+ *
+ * @param {(...args: A) => R1} f1 The function to invoke.
+ * @param {(a: R1) => R2} f2 The function to invoke.
+ * @returns {(...args: A) => R2} Returns the new composite function.
+ *
+ * @example
+ * const add = (x: number, y: number) => x + y;
+ * const square = (n: number) => n * n;
+ *
+ * const combined = flow(add, square);
+ * console.log(combined(1, 2)); // 9
+ */
+declare function flow<A extends any[], R1, R2>(f1: (...args: A) => R1, f2: (a: R1) => R2): (...args: A) => R2;
+/**
+ * Creates a function that returns the result of invoking the given functions with the `this` binding of the created function, where each successive invocation is supplied the return value of the previous.
+ *
+ * @param {(...args: A) => R1} f1 The function to invoke.
+ * @param {(a: R1) => R2} f2 The function to invoke.
+ * @param {(a: R2) => R3} f3 The function to invoke.
+ * @returns {(...args: A) => R3} Returns the new composite function.
+ *
+ * @example
+ * const add = (x: number, y: number) => x + y;
+ * const square = (n: number) => n * n;
+ * const double = (n: number) => n * 2;
+ *
+ * const combined = flow(add, square, double);
+ * console.log(combined(1, 2)); // 18
+ */
+declare function flow<A extends any[], R1, R2, R3>(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3): (...args: A) => R3;
+/**
+ * Creates a function that returns the result of invoking the given functions with the `this` binding of the created function, where each successive invocation is supplied the return value of the previous.
+ *
+ * @param {(...args: A) => R1} f1 The function to invoke.
+ * @param {(a: R1) => R2} f2 The function to invoke.
+ * @param {(a: R2) => R3} f3 The function to invoke.
+ * @param {(a: R3) => R4} f4 The function to invoke.
+ * @returns {(...args: A) => R4} Returns the new composite function.
+ *
+ * @example
+ * const add = (x: number, y: number) => x + y;
+ * const square = (n: number) => n * n;
+ * const double = (n: number) => n * 2;
+ * const toStr = (n: number) => n.toString();
+ *
+ * const combined = flow(add, square, double, toStr);
+ * console.log(combined(1, 2)); // '18'
+ */
+declare function flow<A extends any[], R1, R2, R3, R4>(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): (...args: A) => R4;
+/**
+ * Creates a function that returns the result of invoking the given functions with the `this` binding of the created function, where each successive invocation is supplied the return value of the previous.
+ *
+ * @param {(...args: A) => R1} f1 The function to invoke.
+ * @param {(a: R1) => R2} f2 The function to invoke.
+ * @param {(a: R2) => R3} f3 The function to invoke.
+ * @param {(a: R3) => R4} f4 The function to invoke.
+ * @param {(a: R4) => R5} f5 The function to invoke.
+ * @returns {(...args: A) => R5} Returns the new composite function.
+ *
+ * @example
+ * const add = (x: number, y: number) => x + y;
+ * const square = (n: number) => n * n;
+ * const double = (n: number) => n * 2;
+ * const toStr = (n: number) => n.toString();
+ * const split = (s: string) => s.split('');
+ *
+ * const combined = flow(add, square, double, toStr, split);
+ * console.log(combined(1, 2)); // ['1', '8']
+ */
+declare function flow<A extends any[], R1, R2, R3, R4, R5>(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): (...args: A) => R5;
+/**
+ * Creates a function that returns the result of invoking the given functions with the `this` binding of the created function, where each successive invocation is supplied the return value of the previous.
+ *
+ * @param {Array<(...args: any[]) => any>} funcs The functions to invoke.
+ * @returns {(...args: any[]) => any} Returns the new composite function.
+ *
+ * @example
+ * const add = (x: number, y: number) => x + y;
+ * const square = (n: number) => n * n;
+ *
+ * const combined = flow(add, square);
+ * console.log(combined(1, 2)); // 9
+ */
+declare function flow(...funcs: Array<(...args: any[]) => any>): (...args: any[]) => any;
+
+export { flow };

package/dist/function/flow.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Creates a function that returns the result of invoking the given functions with the `this` binding of the created function, where each successive invocation is supplied the return value of the previous.
+ *
+ * @param {() => R} f The function to invoke.
+ * @returns {() => R} Returns the new composite function.
+ *
+ * @example
+ * function noArgFunc() {
+ *  return 42;
+ * }
+ *
+ * const combined = flow(noArgFunc);
+ * console.log(combined()); // 42
+ */
+declare function flow<R>(f: () => R): () => R;
+/**
+ * Creates a function that returns the result of invoking the given functions with the `this` binding of the created function, where each successive invocation is supplied the return value of the previous.
+ *
+ * @param {(...args: A) => R} f1 The function to invoke.
+ * @returns {(...args: A) => R} Returns the new composite function.
+ *
+ * @example
+ * function oneArgFunc(a: number) {
+ *   return a * 2;
+ * }
+ *
+ * const combined = flow(oneArgFunc);
+ * console.log(combined(5)); // 10
+ */
+declare function flow<A extends any[], R>(f1: (...args: A) => R): (...args: A) => R;
+/**
+ * Creates a function that returns the result of invoking the given functions with the `this` binding of the created function, where each successive invocation is supplied the return value of the previous.
+ *
+ * @param {(...args: A) => R1} f1 The function to invoke.
+ * @param {(a: R1) => R2} f2 The function to invoke.
+ * @returns {(...args: A) => R2} Returns the new composite function.
+ *
+ * @example
+ * const add = (x: number, y: number) => x + y;
+ * const square = (n: number) => n * n;
+ *
+ * const combined = flow(add, square);
+ * console.log(combined(1, 2)); // 9
+ */
+declare function flow<A extends any[], R1, R2>(f1: (...args: A) => R1, f2: (a: R1) => R2): (...args: A) => R2;
+/**
+ * Creates a function that returns the result of invoking the given functions with the `this` binding of the created function, where each successive invocation is supplied the return value of the previous.
+ *
+ * @param {(...args: A) => R1} f1 The function to invoke.
+ * @param {(a: R1) => R2} f2 The function to invoke.
+ * @param {(a: R2) => R3} f3 The function to invoke.
+ * @returns {(...args: A) => R3} Returns the new composite function.
+ *
+ * @example
+ * const add = (x: number, y: number) => x + y;
+ * const square = (n: number) => n * n;
+ * const double = (n: number) => n * 2;
+ *
+ * const combined = flow(add, square, double);
+ * console.log(combined(1, 2)); // 18
+ */
+declare function flow<A extends any[], R1, R2, R3>(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3): (...args: A) => R3;
+/**
+ * Creates a function that returns the result of invoking the given functions with the `this` binding of the created function, where each successive invocation is supplied the return value of the previous.
+ *
+ * @param {(...args: A) => R1} f1 The function to invoke.
+ * @param {(a: R1) => R2} f2 The function to invoke.
+ * @param {(a: R2) => R3} f3 The function to invoke.
+ * @param {(a: R3) => R4} f4 The function to invoke.
+ * @returns {(...args: A) => R4} Returns the new composite function.
+ *
+ * @example
+ * const add = (x: number, y: number) => x + y;
+ * const square = (n: number) => n * n;
+ * const double = (n: number) => n * 2;
+ * const toStr = (n: number) => n.toString();
+ *
+ * const combined = flow(add, square, double, toStr);
+ * console.log(combined(1, 2)); // '18'
+ */
+declare function flow<A extends any[], R1, R2, R3, R4>(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): (...args: A) => R4;
+/**
+ * Creates a function that returns the result of invoking the given functions with the `this` binding of the created function, where each successive invocation is supplied the return value of the previous.
+ *
+ * @param {(...args: A) => R1} f1 The function to invoke.
+ * @param {(a: R1) => R2} f2 The function to invoke.
+ * @param {(a: R2) => R3} f3 The function to invoke.
+ * @param {(a: R3) => R4} f4 The function to invoke.
+ * @param {(a: R4) => R5} f5 The function to invoke.
+ * @returns {(...args: A) => R5} Returns the new composite function.
+ *
+ * @example
+ * const add = (x: number, y: number) => x + y;
+ * const square = (n: number) => n * n;
+ * const double = (n: number) => n * 2;
+ * const toStr = (n: number) => n.toString();
+ * const split = (s: string) => s.split('');
+ *
+ * const combined = flow(add, square, double, toStr, split);
+ * console.log(combined(1, 2)); // ['1', '8']
+ */
+declare function flow<A extends any[], R1, R2, R3, R4, R5>(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): (...args: A) => R5;
+/**
+ * Creates a function that returns the result of invoking the given functions with the `this` binding of the created function, where each successive invocation is supplied the return value of the previous.
+ *
+ * @param {Array<(...args: any[]) => any>} funcs The functions to invoke.
+ * @returns {(...args: any[]) => any} Returns the new composite function.
+ *
+ * @example
+ * const add = (x: number, y: number) => x + y;
+ * const square = (n: number) => n * n;
+ *
+ * const combined = flow(add, square);
+ * console.log(combined(1, 2)); // 9
+ */
+declare function flow(...funcs: Array<(...args: any[]) => any>): (...args: any[]) => any;
+
+export { flow };

package/dist/function/flow.mjs

@@ -0,0 +1,11 @@
+function flow(...funcs) {
+    return function (...args) {
+        let result = funcs.length ? funcs[0].apply(this, args) : args[0];
+        for (let i = 1; i < funcs.length; i++) {
+            result = funcs[i].call(this, result);
+        }
+        return result;
+    };
+}
+
+export { flow };

package/dist/function/index.d.mts

@@ -13,3 +13,4 @@ export { partialRight } from './partialRight.mjs';
 export { rest } from './rest.mjs';
 export { curry } from './curry.mjs';
 export { spread } from './spread.mjs';
+export { flow } from './flow.mjs';

package/dist/function/index.d.ts

@@ -13,3 +13,4 @@ export { partialRight } from './partialRight.js';
 export { rest } from './rest.js';
 export { curry } from './curry.js';
 export { spread } from './spread.js';
+export { flow } from './flow.js';

package/dist/function/index.js

@@ -2,11 +2,11 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const rest = require('../_chunk/rest-pUyjvl.js');
+const flow = require('../_chunk/flow-Au34h2.js');
 
 function throttle(func, throttleMs, { signal, edges = ['leading', 'trailing'] } = {}) {
     let pendingAt = null;
-    const debounced = rest.debounce(func, throttleMs, { signal, edges });
+    const debounced = flow.debounce(func, throttleMs, { signal, edges });
     const throttled = function (...args) {
         if (pendingAt == null) {
             pendingAt = Date.now();
@@ -50,18 +50,19 @@ function spread(func) {
     };
 }
 
-exports.after = rest.after;
-exports.ary = rest.ary;
-exports.before = rest.before;
-exports.debounce = rest.debounce;
-exports.memoize = rest.memoize;
-exports.negate = rest.negate;
-exports.noop = rest.noop;
-exports.once = rest.once;
-exports.partial = rest.partial;
-exports.partialRight = rest.partialRight;
-exports.rest = rest.rest;
-exports.unary = rest.unary;
+exports.after = flow.after;
+exports.ary = flow.ary;
+exports.before = flow.before;
+exports.debounce = flow.debounce;
+exports.flow = flow.flow;
+exports.memoize = flow.memoize;
+exports.negate = flow.negate;
+exports.noop = flow.noop;
+exports.once = flow.once;
+exports.partial = flow.partial;
+exports.partialRight = flow.partialRight;
+exports.rest = flow.rest;
+exports.unary = flow.unary;
 exports.curry = curry;
 exports.spread = spread;
 exports.throttle = throttle;

package/dist/function/index.mjs

@@ -13,3 +13,4 @@ export { partialRight } from './partialRight.mjs';
 export { rest } from './rest.mjs';
 export { curry } from './curry.mjs';
 export { spread } from './spread.mjs';
+export { flow } from './flow.mjs';

package/dist/index.d.mts

@@ -71,6 +71,7 @@ export { partialRight } from './function/partialRight.mjs';
 export { rest } from './function/rest.mjs';
 export { curry } from './function/curry.mjs';
 export { spread } from './function/spread.mjs';
+export { flow } from './function/flow.mjs';
 export { clamp } from './math/clamp.mjs';
 export { inRange } from './math/inRange.mjs';
 export { mean } from './math/mean.mjs';

package/dist/index.d.ts

@@ -71,6 +71,7 @@ export { partialRight } from './function/partialRight.js';
 export { rest } from './function/rest.js';
 export { curry } from './function/curry.js';
 export { spread } from './function/spread.js';
+export { flow } from './function/flow.js';
 export { clamp } from './math/clamp.js';
 export { inRange } from './math/inRange.js';
 export { mean } from './math/mean.js';

package/dist/index.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const zipWith = require('./_chunk/zipWith-DEcUS4.js');
 const array_index = require('./array/index.js');
 const promise_index = require('./_chunk/index-BGZDR9.js');
-const rest = require('./_chunk/rest-pUyjvl.js');
+const flow = require('./_chunk/flow-Au34h2.js');
 const function_index = require('./function/index.js');
 const range = require('./_chunk/range-BXlMmn.js');
 const randomInt = require('./_chunk/randomInt-CF7bZK.js');
@@ -81,18 +81,19 @@ exports.TimeoutError = promise_index.TimeoutError;
 exports.delay = promise_index.delay;
 exports.timeout = promise_index.timeout;
 exports.withTimeout = promise_index.withTimeout;
-exports.after = rest.after;
-exports.ary = rest.ary;
-exports.before = rest.before;
-exports.debounce = rest.debounce;
-exports.memoize = rest.memoize;
-exports.negate = rest.negate;
-exports.noop = rest.noop;
-exports.once = rest.once;
-exports.partial = rest.partial;
-exports.partialRight = rest.partialRight;
-exports.rest = rest.rest;
-exports.unary = rest.unary;
+exports.after = flow.after;
+exports.ary = flow.ary;
+exports.before = flow.before;
+exports.debounce = flow.debounce;
+exports.flow = flow.flow;
+exports.memoize = flow.memoize;
+exports.negate = flow.negate;
+exports.noop = flow.noop;
+exports.once = flow.once;
+exports.partial = flow.partial;
+exports.partialRight = flow.partialRight;
+exports.rest = flow.rest;
+exports.unary = flow.unary;
 exports.curry = function_index.curry;
 exports.spread = function_index.spread;
 exports.throttle = function_index.throttle;

package/dist/index.mjs

@@ -71,6 +71,7 @@ export { partialRight } from './function/partialRight.mjs';
 export { rest } from './function/rest.mjs';
 export { curry } from './function/curry.mjs';
 export { spread } from './function/spread.mjs';
+export { flow } from './function/flow.mjs';
 export { clamp } from './math/clamp.mjs';
 export { inRange } from './math/inRange.mjs';
 export { mean } from './math/mean.mjs';

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.21.0-dev.668+f70e36bd",
+  "version": "1.21.0-dev.670+893ed163",
   "homepage": "https://es-toolkit.slash.page",
   "bugs": "https://github.com/toss/es-toolkit/issues",
   "repository": {