es-toolkit 1.30.1 → 1.31.0-dev.1001

package/dist/compat/math/subtract.d.mts

@@ -0,0 +1,17 @@
+/**
+ * Subtracts one number from another.
+ *
+ * If either of the numbers is `NaN`, the function returns `NaN`.
+ *
+ * @param {number} value The first number. (minuend)
+ * @param {number} other The second number.(subtrahend)
+ * @returns {number} The difference of the two numbers, or `NaN` if any input is `NaN`.
+ *
+ * @example
+ * subtract(6, 3); // => 3
+ * subtract(6, NaN); // => NaN
+ * subtract(NaN, 3); // => NaN
+ */
+declare function subtract(value: number, other: number): number;
+
+export { subtract };

package/dist/compat/math/subtract.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Subtracts one number from another.
+ *
+ * If either of the numbers is `NaN`, the function returns `NaN`.
+ *
+ * @param {number} value The first number. (minuend)
+ * @param {number} other The second number.(subtrahend)
+ * @returns {number} The difference of the two numbers, or `NaN` if any input is `NaN`.
+ *
+ * @example
+ * subtract(6, 3); // => 3
+ * subtract(6, NaN); // => NaN
+ * subtract(NaN, 3); // => NaN
+ */
+declare function subtract(value: number, other: number): number;
+
+export { subtract };

package/dist/compat/math/subtract.mjs

@@ -0,0 +1,5 @@
+function subtract(value, other) {
+    return value - other;
+}
+
+export { subtract };

package/dist/compat/object/mergeWith.mjs

@@ -1,5 +1,6 @@
 import { cloneDeep } from './cloneDeep.mjs';
 import { clone } from '../../object/clone.mjs';
+import { isPrimitive } from '../../predicate/isPrimitive.mjs';
 import { getSymbols } from '../_internal/getSymbols.mjs';
 import { isArguments } from '../predicate/isArguments.mjs';
 import { isObjectLike } from '../predicate/isObjectLike.mjs';
@@ -12,11 +13,14 @@ function mergeWith(object, ...otherArgs) {
     let result = object;
     for (let i = 0; i < sources.length; i++) {
         const source = sources[i];
-        result = mergeWithDeep(object, source, merge, new Map());
+        result = mergeWithDeep(result, source, merge, new Map());
     }
     return result;
 }
 function mergeWithDeep(target, source, merge, stack) {
+    if (isPrimitive(target)) {
+        target = Object(target);
+    }
     if (source == null || typeof source !== 'object') {
         return target;
     }
@@ -45,7 +49,7 @@ function mergeWithDeep(target, source, merge, stack) {
             sourceValue = cloneDeep(sourceValue);
         }
         if (Array.isArray(sourceValue)) {
-            if (typeof targetValue === 'object') {
+            if (typeof targetValue === 'object' && targetValue != null) {
                 const cloned = [];
                 const targetKeys = Reflect.ownKeys(targetValue);
                 for (let i = 0; i < targetKeys.length; i++) {

package/dist/compat/predicate/isBuffer.d.mts

@@ -0,0 +1,21 @@
+/**
+ * Checks if the given value is a Buffer instance.
+ *
+ * This function tests whether the provided value is an instance of Buffer.
+ * It returns `true` if the value is a Buffer, and `false` otherwise.
+ *
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `Buffer`.
+ *
+ * @param {unknown} x - The value to check if it is a Buffer.
+ * @returns {boolean} Returns `true` if `x` is a Buffer, else `false`.
+ *
+ * @example
+ * const buffer = Buffer.from("test");
+ * console.log(isBuffer(buffer)); // true
+ *
+ * const notBuffer = "not a buffer";
+ * console.log(isBuffer(notBuffer)); // false
+ */
+declare function isBuffer(x?: unknown): boolean;
+
+export { isBuffer };

package/dist/compat/predicate/isBuffer.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Checks if the given value is a Buffer instance.
+ *
+ * This function tests whether the provided value is an instance of Buffer.
+ * It returns `true` if the value is a Buffer, and `false` otherwise.
+ *
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `Buffer`.
+ *
+ * @param {unknown} x - The value to check if it is a Buffer.
+ * @returns {boolean} Returns `true` if `x` is a Buffer, else `false`.
+ *
+ * @example
+ * const buffer = Buffer.from("test");
+ * console.log(isBuffer(buffer)); // true
+ *
+ * const notBuffer = "not a buffer";
+ * console.log(isBuffer(notBuffer)); // false
+ */
+declare function isBuffer(x?: unknown): boolean;
+
+export { isBuffer };

package/dist/compat/predicate/isBuffer.mjs

@@ -0,0 +1,7 @@
+import { isBuffer as isBuffer$1 } from '../../predicate/isBuffer.mjs';
+
+function isBuffer(x) {
+    return isBuffer$1(x);
+}
+
+export { isBuffer };

package/dist/compat/predicate/isMatch.mjs

@@ -13,10 +13,7 @@ function isMatch(target, source) {
             }
             const keys = Object.keys(source);
             if (target == null) {
-                if (keys.length === 0) {
-                    return true;
-                }
-                return false;
+                return keys.length === 0;
             }
             if (Array.isArray(source)) {
                 return isArrayMatch(target, source);

package/dist/compat/util/methodOf.d.mts

@@ -0,0 +1,22 @@
+/**
+ * Creates a function that invokes the method at a given path of `object` with the provided arguments.
+ *
+ * @param {object} object - The object to query.
+ * @param {...any} args - The arguments to invoke the method with.
+ * @returns {(path: PropertyKey | PropertyKey[]) => any} - Returns a new function that takes a path and invokes the method at `path` with `args`.
+ *
+ * @example
+ * const object = {
+ *  a: {
+ *   b: function (x, y) {
+ *    return x + y;
+ *    }
+ *   }
+ * };
+ *
+ * const add = methodOf(object, 1, 2);
+ * console.log(add('a.b')); // => 3
+ */
+declare function methodOf(object: object, ...args: any[]): (path: PropertyKey | PropertyKey[]) => any;
+
+export { methodOf };

package/dist/compat/util/methodOf.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Creates a function that invokes the method at a given path of `object` with the provided arguments.
+ *
+ * @param {object} object - The object to query.
+ * @param {...any} args - The arguments to invoke the method with.
+ * @returns {(path: PropertyKey | PropertyKey[]) => any} - Returns a new function that takes a path and invokes the method at `path` with `args`.
+ *
+ * @example
+ * const object = {
+ *  a: {
+ *   b: function (x, y) {
+ *    return x + y;
+ *    }
+ *   }
+ * };
+ *
+ * const add = methodOf(object, 1, 2);
+ * console.log(add('a.b')); // => 3
+ */
+declare function methodOf(object: object, ...args: any[]): (path: PropertyKey | PropertyKey[]) => any;
+
+export { methodOf };

package/dist/compat/util/methodOf.mjs

@@ -0,0 +1,9 @@
+import { invoke } from './invoke.mjs';
+
+function methodOf(object, ...args) {
+    return function (path) {
+        return invoke(object, path, args);
+    };
+}
+
+export { methodOf };

package/dist/error/index.d.mts

@@ -0,0 +1,2 @@
+export { AbortError } from './AbortError.mjs';
+export { TimeoutError } from './TimeoutError.mjs';

package/dist/error/index.d.ts

@@ -0,0 +1,2 @@
+export { AbortError } from './AbortError.js';
+export { TimeoutError } from './TimeoutError.js';

package/dist/error/index.js

@@ -0,0 +1,15 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const AbortError = require('../_chunk/AbortError-Cg4ZQ1.js');
+
+class TimeoutError extends Error {
+    constructor(message = 'The operation was timed out') {
+        super(message);
+        this.name = 'TimeoutError';
+    }
+}
+
+exports.AbortError = AbortError.AbortError;
+exports.TimeoutError = TimeoutError;

package/dist/error/index.mjs

@@ -0,0 +1,2 @@
+export { AbortError } from './AbortError.mjs';
+export { TimeoutError } from './TimeoutError.mjs';

package/dist/function/asyncNoop.d.mts

@@ -0,0 +1,12 @@
+/**
+ * An asynchronous no-operation function that does nothing.
+ * This can be used as a placeholder or default function.
+ *
+ * @example
+ * asyncNoop(); // Does nothing
+ *
+ * @returns {Promise<void>} This function returns a Promise that resolves to undefined.
+ */
+declare function asyncNoop(): Promise<void>;
+
+export { asyncNoop };

package/dist/function/asyncNoop.d.ts

@@ -0,0 +1,12 @@
+/**
+ * An asynchronous no-operation function that does nothing.
+ * This can be used as a placeholder or default function.
+ *
+ * @example
+ * asyncNoop(); // Does nothing
+ *
+ * @returns {Promise<void>} This function returns a Promise that resolves to undefined.
+ */
+declare function asyncNoop(): Promise<void>;
+
+export { asyncNoop };

package/dist/function/asyncNoop.mjs

@@ -0,0 +1,3 @@
+async function asyncNoop() { }
+
+export { asyncNoop };

package/dist/function/index.d.mts

@@ -1,5 +1,6 @@
 export { after } from './after.mjs';
 export { ary } from './ary.mjs';
+export { asyncNoop } from './asyncNoop.mjs';
 export { before } from './before.mjs';
 export { curry } from './curry.mjs';
 export { curryRight } from './curryRight.mjs';
@@ -14,6 +15,7 @@ export { once } from './once.mjs';
 export { partial } from './partial.mjs';
 export { partialRight } from './partialRight.mjs';
 export { rest } from './rest.mjs';
+export { retry } from './retry.mjs';
 export { spread } from './spread.mjs';
 export { ThrottledFunction, throttle } from './throttle.mjs';
 export { unary } from './unary.mjs';

package/dist/function/index.d.ts

@@ -1,5 +1,6 @@
 export { after } from './after.js';
 export { ary } from './ary.js';
+export { asyncNoop } from './asyncNoop.js';
 export { before } from './before.js';
 export { curry } from './curry.js';
 export { curryRight } from './curryRight.js';
@@ -14,6 +15,7 @@ export { once } from './once.js';
 export { partial } from './partial.js';
 export { partialRight } from './partialRight.js';
 export { rest } from './rest.js';
+export { retry } from './retry.js';
 export { spread } from './spread.js';
 export { ThrottledFunction, throttle } from './throttle.js';
 export { unary } from './unary.js';

package/dist/function/index.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const unary = require('../_chunk/unary-CcTNuC.js');
+const unary = require('../_chunk/unary-c1NFA5.js');
 const noop = require('../_chunk/noop-2IwLUk.js');
 
 function before(n, func) {
@@ -87,6 +87,7 @@ function throttle(func, throttleMs, { signal, edges = ['leading', 'trailing'] }
 
 exports.after = unary.after;
 exports.ary = unary.ary;
+exports.asyncNoop = unary.asyncNoop;
 exports.debounce = unary.debounce;
 exports.flow = unary.flow;
 exports.flowRight = unary.flowRight;
@@ -97,6 +98,7 @@ exports.once = unary.once;
 exports.partial = unary.partial;
 exports.partialRight = unary.partialRight;
 exports.rest = unary.rest;
+exports.retry = unary.retry;
 exports.unary = unary.unary;
 exports.noop = noop.noop;
 exports.before = before;

package/dist/function/index.mjs

@@ -1,5 +1,6 @@
 export { after } from './after.mjs';
 export { ary } from './ary.mjs';
+export { asyncNoop } from './asyncNoop.mjs';
 export { before } from './before.mjs';
 export { curry } from './curry.mjs';
 export { curryRight } from './curryRight.mjs';
@@ -14,6 +15,7 @@ export { once } from './once.mjs';
 export { partial } from './partial.mjs';
 export { partialRight } from './partialRight.mjs';
 export { rest } from './rest.mjs';
+export { retry } from './retry.mjs';
 export { spread } from './spread.mjs';
 export { throttle } from './throttle.mjs';
 export { unary } from './unary.mjs';

package/dist/function/retry.d.mts

@@ -0,0 +1,59 @@
+interface RetryOptions {
+    /**
+     * The number of milliseconds to interval delay.
+     * @default 0
+     */
+    delay?: number;
+    /**
+     * The number of retries to attempt.
+     * @default Number.POSITIVE_INFINITY
+     */
+    retries?: number;
+    /**
+     * An AbortSignal to cancel the retry operation.
+     */
+    signal?: AbortSignal;
+}
+/**
+ * Retries a function that returns a promise until it resolves successfully.
+ *
+ * @template T
+ * @param {() => Promise<T>} func - The function to retry.
+ * @returns {Promise<T>} A promise that resolves with the value of the successful function call.
+ *
+ * @example
+ * // Basic usage with default retry options
+ * retry(() => fetchData()).then(data => console.log(data));
+ */
+declare function retry<T>(func: () => Promise<T>): Promise<T>;
+/**
+ * Retries a function that returns a promise a specified number of times.
+ *
+ * @template T
+ * @param {() => Promise<T>} func - The function to retry. It should return a promise.
+ * @param {number} retries - The number of retries to attempt. Default is Infinity.
+ * @returns {Promise<T>} A promise that resolves with the value of the successful function call.
+ *
+ * @example
+ * // Retry a function up to 3 times
+ * retry(() => fetchData(), 3).then(data => console.log(data));
+ */
+declare function retry<T>(func: () => Promise<T>, retries: number): Promise<T>;
+/**
+ * Retries a function that returns a promise with specified options.
+ *
+ * @template T
+ * @param {() => Promise<T>} func - The function to retry. It should return a promise.
+ * @param {RetryOptions} options - Options to configure the retry behavior.
+ * @param {number} [options.delay=0] - The number of milliseconds to wait between retries.
+ * @param {number} [options.retries=Infinity] - The number of retries to attempt.
+ * @param {AbortSignal} [options.signal] - An AbortSignal to cancel the retry operation.
+ * @returns {Promise<T>} A promise that resolves with the value of the successful function call.
+ *
+ * @example
+ * // Retry a function with a delay of 1000ms between attempts
+ * retry(() => fetchData(), { delay: 1000, times: 5 }).then(data => console.log(data));
+ */
+declare function retry<T>(func: () => Promise<T>, options: RetryOptions): Promise<T>;
+
+export { retry };

package/dist/function/retry.d.ts

@@ -0,0 +1,59 @@
+interface RetryOptions {
+    /**
+     * The number of milliseconds to interval delay.
+     * @default 0
+     */
+    delay?: number;
+    /**
+     * The number of retries to attempt.
+     * @default Number.POSITIVE_INFINITY
+     */
+    retries?: number;
+    /**
+     * An AbortSignal to cancel the retry operation.
+     */
+    signal?: AbortSignal;
+}
+/**
+ * Retries a function that returns a promise until it resolves successfully.
+ *
+ * @template T
+ * @param {() => Promise<T>} func - The function to retry.
+ * @returns {Promise<T>} A promise that resolves with the value of the successful function call.
+ *
+ * @example
+ * // Basic usage with default retry options
+ * retry(() => fetchData()).then(data => console.log(data));
+ */
+declare function retry<T>(func: () => Promise<T>): Promise<T>;
+/**
+ * Retries a function that returns a promise a specified number of times.
+ *
+ * @template T
+ * @param {() => Promise<T>} func - The function to retry. It should return a promise.
+ * @param {number} retries - The number of retries to attempt. Default is Infinity.
+ * @returns {Promise<T>} A promise that resolves with the value of the successful function call.
+ *
+ * @example
+ * // Retry a function up to 3 times
+ * retry(() => fetchData(), 3).then(data => console.log(data));
+ */
+declare function retry<T>(func: () => Promise<T>, retries: number): Promise<T>;
+/**
+ * Retries a function that returns a promise with specified options.
+ *
+ * @template T
+ * @param {() => Promise<T>} func - The function to retry. It should return a promise.
+ * @param {RetryOptions} options - Options to configure the retry behavior.
+ * @param {number} [options.delay=0] - The number of milliseconds to wait between retries.
+ * @param {number} [options.retries=Infinity] - The number of retries to attempt.
+ * @param {AbortSignal} [options.signal] - An AbortSignal to cancel the retry operation.
+ * @returns {Promise<T>} A promise that resolves with the value of the successful function call.
+ *
+ * @example
+ * // Retry a function with a delay of 1000ms between attempts
+ * retry(() => fetchData(), { delay: 1000, times: 5 }).then(data => console.log(data));
+ */
+declare function retry<T>(func: () => Promise<T>, options: RetryOptions): Promise<T>;
+
+export { retry };

package/dist/function/retry.mjs

@@ -0,0 +1,35 @@
+import { delay } from '../promise/delay.mjs';
+
+const DEFAULT_DELAY = 0;
+const DEFAULT_RETRIES = Number.POSITIVE_INFINITY;
+async function retry(func, _options) {
+    let delay$1;
+    let retries;
+    let signal;
+    if (typeof _options === 'number') {
+        delay$1 = DEFAULT_DELAY;
+        retries = _options;
+        signal = undefined;
+    }
+    else {
+        delay$1 = _options?.delay ?? DEFAULT_DELAY;
+        retries = _options?.retries ?? DEFAULT_RETRIES;
+        signal = _options?.signal;
+    }
+    let error;
+    for (let i = 0; i < retries; i++) {
+        if (signal?.aborted) {
+            throw error ?? new Error(`The retry operation was aborted due to an abort signal.`);
+        }
+        try {
+            return await func();
+        }
+        catch (err) {
+            error = err;
+            await delay(delay$1);
+        }
+    }
+    throw error;
+}
+
+export { retry };

package/dist/index.d.mts

@@ -31,6 +31,7 @@ export { orderBy } from './array/orderBy.mjs';
 export { partition } from './array/partition.mjs';
 export { pull } from './array/pull.mjs';
 export { pullAt } from './array/pullAt.mjs';
+export { remove } from './array/remove.mjs';
 export { sample } from './array/sample.mjs';
 export { sampleSize } from './array/sampleSize.mjs';
 export { shuffle } from './array/shuffle.mjs';
@@ -49,6 +50,7 @@ export { uniqBy } from './array/uniqBy.mjs';
 export { uniqWith } from './array/uniqWith.mjs';
 export { unzip } from './array/unzip.mjs';
 export { unzipWith } from './array/unzipWith.mjs';
+export { windowed } from './array/windowed.mjs';
 export { without } from './array/without.mjs';
 export { xor } from './array/xor.mjs';
 export { xorBy } from './array/xorBy.mjs';
@@ -60,6 +62,7 @@ export { AbortError } from './error/AbortError.mjs';
 export { TimeoutError } from './error/TimeoutError.mjs';
 export { after } from './function/after.mjs';
 export { ary } from './function/ary.mjs';
+export { asyncNoop } from './function/asyncNoop.mjs';
 export { before } from './function/before.mjs';
 export { curry } from './function/curry.mjs';
 export { curryRight } from './function/curryRight.mjs';
@@ -74,6 +77,7 @@ export { once } from './function/once.mjs';
 export { partial } from './function/partial.mjs';
 export { partialRight } from './function/partialRight.mjs';
 export { rest } from './function/rest.mjs';
+export { retry } from './function/retry.mjs';
 export { spread } from './function/spread.mjs';
 export { ThrottledFunction, throttle } from './function/throttle.mjs';
 export { unary } from './function/unary.mjs';
@@ -123,6 +127,7 @@ export { isNotNil } from './predicate/isNotNil.mjs';
 export { isNull } from './predicate/isNull.mjs';
 export { isPlainObject } from './predicate/isPlainObject.mjs';
 export { isPrimitive } from './predicate/isPrimitive.mjs';
+export { isPromise } from './predicate/isPromise.mjs';
 export { isRegExp } from './predicate/isRegExp.mjs';
 export { isSet } from './predicate/isSet.mjs';
 export { isString } from './predicate/isString.mjs';
@@ -132,6 +137,8 @@ export { isUndefined } from './predicate/isUndefined.mjs';
 export { isWeakMap } from './predicate/isWeakMap.mjs';
 export { isWeakSet } from './predicate/isWeakSet.mjs';
 export { delay } from './promise/delay.mjs';
+export { Mutex } from './promise/mutex.mjs';
+export { Semaphore } from './promise/semaphore.mjs';
 export { timeout } from './promise/timeout.mjs';
 export { withTimeout } from './promise/withTimeout.mjs';
 export { camelCase } from './string/camelCase.mjs';

package/dist/index.d.ts

@@ -31,6 +31,7 @@ export { orderBy } from './array/orderBy.js';
 export { partition } from './array/partition.js';
 export { pull } from './array/pull.js';
 export { pullAt } from './array/pullAt.js';
+export { remove } from './array/remove.js';
 export { sample } from './array/sample.js';
 export { sampleSize } from './array/sampleSize.js';
 export { shuffle } from './array/shuffle.js';
@@ -49,6 +50,7 @@ export { uniqBy } from './array/uniqBy.js';
 export { uniqWith } from './array/uniqWith.js';
 export { unzip } from './array/unzip.js';
 export { unzipWith } from './array/unzipWith.js';
+export { windowed } from './array/windowed.js';
 export { without } from './array/without.js';
 export { xor } from './array/xor.js';
 export { xorBy } from './array/xorBy.js';
@@ -60,6 +62,7 @@ export { AbortError } from './error/AbortError.js';
 export { TimeoutError } from './error/TimeoutError.js';
 export { after } from './function/after.js';
 export { ary } from './function/ary.js';
+export { asyncNoop } from './function/asyncNoop.js';
 export { before } from './function/before.js';
 export { curry } from './function/curry.js';
 export { curryRight } from './function/curryRight.js';
@@ -74,6 +77,7 @@ export { once } from './function/once.js';
 export { partial } from './function/partial.js';
 export { partialRight } from './function/partialRight.js';
 export { rest } from './function/rest.js';
+export { retry } from './function/retry.js';
 export { spread } from './function/spread.js';
 export { ThrottledFunction, throttle } from './function/throttle.js';
 export { unary } from './function/unary.js';
@@ -123,6 +127,7 @@ export { isNotNil } from './predicate/isNotNil.js';
 export { isNull } from './predicate/isNull.js';
 export { isPlainObject } from './predicate/isPlainObject.js';
 export { isPrimitive } from './predicate/isPrimitive.js';
+export { isPromise } from './predicate/isPromise.js';
 export { isRegExp } from './predicate/isRegExp.js';
 export { isSet } from './predicate/isSet.js';
 export { isString } from './predicate/isString.js';
@@ -132,6 +137,8 @@ export { isUndefined } from './predicate/isUndefined.js';
 export { isWeakMap } from './predicate/isWeakMap.js';
 export { isWeakSet } from './predicate/isWeakSet.js';
 export { delay } from './promise/delay.js';
+export { Mutex } from './promise/mutex.js';
+export { Semaphore } from './promise/semaphore.js';
 export { timeout } from './promise/timeout.js';
 export { withTimeout } from './promise/withTimeout.js';
 export { camelCase } from './string/camelCase.js';