es-toolkit 1.15.1-dev.445 → 1.15.1-dev.447

package/dist/compat/function/rest.d.mts

@@ -0,0 +1,33 @@
+/**
+ * Creates a function that transforms the arguments of the provided function `func`.
+ * The transformed arguments are passed to `func` such that the arguments starting from a specified index
+ * are grouped into an array, while the previous arguments are passed as individual elements.
+ *
+ * @template F - The type of the function being transformed.
+ * @param {F} func - The function whose arguments are to be transformed.
+ * @param {number} [startIndex=func.length - 1] - The index from which to start grouping the remaining arguments into an array.
+ *                                            Defaults to `func.length - 1`, grouping all arguments after the last parameter.
+ * @returns {(...args: any[]) => ReturnType<F>} A new function that, when called, returns the result of calling `func` with the transformed arguments.
+ *
+ * The transformed arguments are:
+ * - The first `start` arguments as individual elements.
+ * - The remaining arguments from index `start` onward grouped into an array.
+ * @example
+ * function fn(a, b, c) {
+ *   return [a, b, c];
+ * }
+ *
+ * // Using default start index (func.length - 1, which is 2 in this case)
+ * const transformedFn = rest(fn);
+ * console.log(transformedFn(1, 2, 3, 4)); // [1, 2, [3, 4]]
+ *
+ * // Using start index 1
+ * const transformedFnWithStart = rest(fn, 1);
+ * console.log(transformedFnWithStart(1, 2, 3, 4)); // [1, [2, 3, 4]]
+ *
+ * // With fewer arguments than the start index
+ * console.log(transformedFn(1)); // [1, undefined, []]
+ */
+declare function rest<F extends (...args: any[]) => any>(func: F, start?: number): (...args: any[]) => ReturnType<F>;
+
+export { rest };

package/dist/compat/function/rest.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Creates a function that transforms the arguments of the provided function `func`.
+ * The transformed arguments are passed to `func` such that the arguments starting from a specified index
+ * are grouped into an array, while the previous arguments are passed as individual elements.
+ *
+ * @template F - The type of the function being transformed.
+ * @param {F} func - The function whose arguments are to be transformed.
+ * @param {number} [startIndex=func.length - 1] - The index from which to start grouping the remaining arguments into an array.
+ *                                            Defaults to `func.length - 1`, grouping all arguments after the last parameter.
+ * @returns {(...args: any[]) => ReturnType<F>} A new function that, when called, returns the result of calling `func` with the transformed arguments.
+ *
+ * The transformed arguments are:
+ * - The first `start` arguments as individual elements.
+ * - The remaining arguments from index `start` onward grouped into an array.
+ * @example
+ * function fn(a, b, c) {
+ *   return [a, b, c];
+ * }
+ *
+ * // Using default start index (func.length - 1, which is 2 in this case)
+ * const transformedFn = rest(fn);
+ * console.log(transformedFn(1, 2, 3, 4)); // [1, 2, [3, 4]]
+ *
+ * // Using start index 1
+ * const transformedFnWithStart = rest(fn, 1);
+ * console.log(transformedFnWithStart(1, 2, 3, 4)); // [1, [2, 3, 4]]
+ *
+ * // With fewer arguments than the start index
+ * console.log(transformedFn(1)); // [1, undefined, []]
+ */
+declare function rest<F extends (...args: any[]) => any>(func: F, start?: number): (...args: any[]) => ReturnType<F>;
+
+export { rest };

package/dist/compat/function/rest.mjs

@@ -0,0 +1,11 @@
+import { rest as rest$1 } from '../../function/rest.mjs';
+
+function rest(func, start = func.length - 1) {
+    start = Number.parseInt(start, 10);
+    if (Number.isNaN(start) || start < 0) {
+        start = func.length - 1;
+    }
+    return rest$1(func, start);
+}
+
+export { rest };

package/dist/compat/index.d.mts

@@ -108,6 +108,7 @@ export { zipObjectDeep } from './array/zipObjectDeep.mjs';
 export { indexOf } from './array/indexOf.mjs';
 export { ary } from './function/ary.mjs';
 export { bind } from './function/bind.mjs';
+export { rest } from './function/rest.mjs';
 export { get } from './object/get.mjs';
 export { set } from './object/set.mjs';
 export { has } from './object/has.mjs';

package/dist/compat/index.d.ts

@@ -108,6 +108,7 @@ export { zipObjectDeep } from './array/zipObjectDeep.js';
 export { indexOf } from './array/indexOf.js';
 export { ary } from './function/ary.js';
 export { bind } from './function/bind.js';
+export { rest } from './function/rest.js';
 export { get } from './object/get.js';
 export { set } from './object/set.js';
 export { has } from './object/has.js';

package/dist/compat/index.js

@@ -601,6 +601,14 @@ function bind(func, thisObj, ...partialArgs) {
 const bindPlaceholder = Symbol('bind.placeholder');
 bind.placeholder = bindPlaceholder;
 
+function rest(func, start = func.length - 1) {
+    start = Number.parseInt(start, 10);
+    if (Number.isNaN(start) || start < 0) {
+        start = func.length - 1;
+    }
+    return function_index.rest(func, start);
+}
+
 function identity(x) {
     return x;
 }
@@ -936,6 +944,7 @@ exports.orderBy = orderBy;
 exports.padEnd = padEnd;
 exports.padStart = padStart;
 exports.property = property;
+exports.rest = rest;
 exports.set = set;
 exports.size = size;
 exports.startsWith = startsWith;

package/dist/compat/index.mjs

@@ -109,6 +109,7 @@ export { zipObjectDeep } from './array/zipObjectDeep.mjs';
 export { indexOf } from './array/indexOf.mjs';
 export { ary } from './function/ary.mjs';
 export { bind } from './function/bind.mjs';
+export { rest } from './function/rest.mjs';
 export { get } from './object/get.mjs';
 export { set } from './object/set.mjs';
 export { has } from './object/has.mjs';

package/dist/function/index.d.mts

@@ -9,3 +9,4 @@ export { ary } from './ary.mjs';
 export { unary } from './unary.mjs';
 export { partial } from './partial.mjs';
 export { partialRight } from './partialRight.mjs';
+export { rest } from './rest.mjs';

package/dist/function/index.d.ts

@@ -9,3 +9,4 @@ export { ary } from './ary.js';
 export { unary } from './unary.js';
 export { partial } from './partial.js';
 export { partialRight } from './partialRight.js';
+export { rest } from './rest.js';

package/dist/function/index.js

@@ -143,6 +143,17 @@ function partialRight(func, ...partialArgs) {
 const partialRightPlaceholder = Symbol('partialRight.placeholder');
 partialRight.placeholder = partialRightPlaceholder;
 
+function rest(func, startIndex = func.length - 1) {
+    return function (...args) {
+        const rest = args.slice(startIndex);
+        const params = args.slice(0, startIndex);
+        while (params.length < startIndex) {
+            params.push(undefined);
+        }
+        return func.apply(this, [...params, rest]);
+    };
+}
+
 exports.after = after;
 exports.ary = ary;
 exports.before = before;
@@ -152,5 +163,6 @@ exports.noop = noop;
 exports.once = once;
 exports.partial = partial;
 exports.partialRight = partialRight;
+exports.rest = rest;
 exports.throttle = throttle;
 exports.unary = unary;

package/dist/function/index.mjs

@@ -9,3 +9,4 @@ export { ary } from './ary.mjs';
 export { unary } from './unary.mjs';
 export { partial } from './partial.mjs';
 export { partialRight } from './partialRight.mjs';
+export { rest } from './rest.mjs';

package/dist/function/rest.d.mts

@@ -0,0 +1,33 @@
+/**
+ * Creates a function that transforms the arguments of the provided function `func`.
+ * The transformed arguments are passed to `func` such that the arguments starting from a specified index
+ * are grouped into an array, while the previous arguments are passed as individual elements.
+ *
+ * @template F - The type of the function being transformed.
+ * @param {F} func - The function whose arguments are to be transformed.
+ * @param {number} [startIndex=func.length - 1] - The index from which to start grouping the remaining arguments into an array.
+ *                                            Defaults to `func.length - 1`, grouping all arguments after the last parameter.
+ * @returns {(...args: any[]) => ReturnType<F>} A new function that, when called, returns the result of calling `func` with the transformed arguments.
+ *
+ * The transformed arguments are:
+ * - The first `start` arguments as individual elements.
+ * - The remaining arguments from index `start` onward grouped into an array.
+ * @example
+ * function fn(a, b, c) {
+ *   return [a, b, c];
+ * }
+ *
+ * // Using default start index (func.length - 1, which is 2 in this case)
+ * const transformedFn = rest(fn);
+ * console.log(transformedFn(1, 2, 3, 4)); // [1, 2, [3, 4]]
+ *
+ * // Using start index 1
+ * const transformedFnWithStart = rest(fn, 1);
+ * console.log(transformedFnWithStart(1, 2, 3, 4)); // [1, [2, 3, 4]]
+ *
+ * // With fewer arguments than the start index
+ * console.log(transformedFn(1)); // [1, undefined, []]
+ */
+declare function rest<F extends (...args: any[]) => any>(func: F, startIndex?: number): (...args: any[]) => ReturnType<F>;
+
+export { rest };

package/dist/function/rest.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Creates a function that transforms the arguments of the provided function `func`.
+ * The transformed arguments are passed to `func` such that the arguments starting from a specified index
+ * are grouped into an array, while the previous arguments are passed as individual elements.
+ *
+ * @template F - The type of the function being transformed.
+ * @param {F} func - The function whose arguments are to be transformed.
+ * @param {number} [startIndex=func.length - 1] - The index from which to start grouping the remaining arguments into an array.
+ *                                            Defaults to `func.length - 1`, grouping all arguments after the last parameter.
+ * @returns {(...args: any[]) => ReturnType<F>} A new function that, when called, returns the result of calling `func` with the transformed arguments.
+ *
+ * The transformed arguments are:
+ * - The first `start` arguments as individual elements.
+ * - The remaining arguments from index `start` onward grouped into an array.
+ * @example
+ * function fn(a, b, c) {
+ *   return [a, b, c];
+ * }
+ *
+ * // Using default start index (func.length - 1, which is 2 in this case)
+ * const transformedFn = rest(fn);
+ * console.log(transformedFn(1, 2, 3, 4)); // [1, 2, [3, 4]]
+ *
+ * // Using start index 1
+ * const transformedFnWithStart = rest(fn, 1);
+ * console.log(transformedFnWithStart(1, 2, 3, 4)); // [1, [2, 3, 4]]
+ *
+ * // With fewer arguments than the start index
+ * console.log(transformedFn(1)); // [1, undefined, []]
+ */
+declare function rest<F extends (...args: any[]) => any>(func: F, startIndex?: number): (...args: any[]) => ReturnType<F>;
+
+export { rest };

package/dist/function/rest.mjs

@@ -0,0 +1,12 @@
+function rest(func, startIndex = func.length - 1) {
+    return function (...args) {
+        const rest = args.slice(startIndex);
+        const params = args.slice(0, startIndex);
+        while (params.length < startIndex) {
+            params.push(undefined);
+        }
+        return func.apply(this, [...params, rest]);
+    };
+}
+
+export { rest };

package/dist/index.d.mts

@@ -64,6 +64,7 @@ export { ary } from './function/ary.mjs';
 export { unary } from './function/unary.mjs';
 export { partial } from './function/partial.mjs';
 export { partialRight } from './function/partialRight.mjs';
+export { rest } from './function/rest.mjs';
 export { clamp } from './math/clamp.mjs';
 export { inRange } from './math/inRange.mjs';
 export { mean } from './math/mean.mjs';

package/dist/index.d.ts

@@ -64,6 +64,7 @@ export { ary } from './function/ary.js';
 export { unary } from './function/unary.js';
 export { partial } from './function/partial.js';
 export { partialRight } from './function/partialRight.js';
+export { rest } from './function/rest.js';
 export { clamp } from './math/clamp.js';
 export { inRange } from './math/inRange.js';
 export { mean } from './math/mean.js';

package/dist/index.js

@@ -83,6 +83,7 @@ exports.noop = function_index.noop;
 exports.once = function_index.once;
 exports.partial = function_index.partial;
 exports.partialRight = function_index.partialRight;
+exports.rest = function_index.rest;
 exports.throttle = function_index.throttle;
 exports.unary = function_index.unary;
 exports.clamp = math_index.clamp;

package/dist/index.mjs

@@ -64,6 +64,7 @@ export { ary } from './function/ary.mjs';
 export { unary } from './function/unary.mjs';
 export { partial } from './function/partial.mjs';
 export { partialRight } from './function/partialRight.mjs';
+export { rest } from './function/rest.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.15.1-dev.445+50b48669",
+  "version": "1.15.1-dev.447+98af4a3a",
   "homepage": "https://es-toolkit.slash.page",
   "bugs": "https://github.com/toss/es-toolkit/issues",
   "repository": {