es-toolkit 1.35.0 → 1.36.0-dev.1217

package/dist/compat/object/hasIn.d.mts

@@ -0,0 +1,40 @@
+/**
+ * Checks if a given path exists in an object, **including inherited properties**.
+ *
+ * You can provide the path as a single property key, an array of property keys,
+ * or a string representing a deep path.
+ *
+ * Unlike `has`, which only checks for own properties, `hasIn` also checks for properties
+ * in the prototype chain.
+ *
+ * If the path is an index and the object is an array or an arguments object, the function will verify
+ * if the index is valid and within the bounds of the array or arguments object, even if the array or
+ * arguments object is sparse (i.e., not all indexes are defined).
+ *
+ * @param {object} object - The object to query.
+ * @param {PropertyKey | PropertyKey[]} path - The path to check. This can be a single property key,
+ *        an array of property keys, or a string representing a deep path.
+ * @returns {boolean} Returns `true` if the path exists (own or inherited), `false` otherwise.
+ *
+ * @example
+ *
+ * const obj = { a: { b: { c: 3 } } };
+ *
+ * hasIn(obj, 'a'); // true
+ * hasIn(obj, ['a', 'b']); // true
+ * hasIn(obj, ['a', 'b', 'c']); // true
+ * hasIn(obj, 'a.b.c'); // true
+ * hasIn(obj, 'a.b.d'); // false
+ * hasIn(obj, ['a', 'b', 'c', 'd']); // false
+ *
+ * // Example with inherited properties:
+ * function Rectangle() {}
+ * Rectangle.prototype.area = function() {};
+ *
+ * const rect = new Rectangle();
+ * hasIn(rect, 'area'); // true
+ * has(rect, 'area'); // false - has only checks own properties
+ */
+declare function hasIn(object: unknown, path: PropertyKey | readonly PropertyKey[]): boolean;
+
+export { hasIn };

package/dist/compat/object/hasIn.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Checks if a given path exists in an object, **including inherited properties**.
+ *
+ * You can provide the path as a single property key, an array of property keys,
+ * or a string representing a deep path.
+ *
+ * Unlike `has`, which only checks for own properties, `hasIn` also checks for properties
+ * in the prototype chain.
+ *
+ * If the path is an index and the object is an array or an arguments object, the function will verify
+ * if the index is valid and within the bounds of the array or arguments object, even if the array or
+ * arguments object is sparse (i.e., not all indexes are defined).
+ *
+ * @param {object} object - The object to query.
+ * @param {PropertyKey | PropertyKey[]} path - The path to check. This can be a single property key,
+ *        an array of property keys, or a string representing a deep path.
+ * @returns {boolean} Returns `true` if the path exists (own or inherited), `false` otherwise.
+ *
+ * @example
+ *
+ * const obj = { a: { b: { c: 3 } } };
+ *
+ * hasIn(obj, 'a'); // true
+ * hasIn(obj, ['a', 'b']); // true
+ * hasIn(obj, ['a', 'b', 'c']); // true
+ * hasIn(obj, 'a.b.c'); // true
+ * hasIn(obj, 'a.b.d'); // false
+ * hasIn(obj, ['a', 'b', 'c', 'd']); // false
+ *
+ * // Example with inherited properties:
+ * function Rectangle() {}
+ * Rectangle.prototype.area = function() {};
+ *
+ * const rect = new Rectangle();
+ * hasIn(rect, 'area'); // true
+ * has(rect, 'area'); // false - has only checks own properties
+ */
+declare function hasIn(object: unknown, path: PropertyKey | readonly PropertyKey[]): boolean;
+
+export { hasIn };

package/dist/compat/object/hasIn.mjs

@@ -0,0 +1,34 @@
+import { isDeepKey } from '../_internal/isDeepKey.mjs';
+import { isIndex } from '../_internal/isIndex.mjs';
+import { isArguments } from '../predicate/isArguments.mjs';
+import { toPath } from '../util/toPath.mjs';
+
+function hasIn(object, path) {
+    let resolvedPath;
+    if (Array.isArray(path)) {
+        resolvedPath = path;
+    }
+    else if (typeof path === 'string' && isDeepKey(path) && object?.[path] == null) {
+        resolvedPath = toPath(path);
+    }
+    else {
+        resolvedPath = [path];
+    }
+    if (resolvedPath.length === 0) {
+        return false;
+    }
+    let current = object;
+    for (let i = 0; i < resolvedPath.length; i++) {
+        const key = resolvedPath[i];
+        if (current == null || !(key in Object(current))) {
+            const isSparseIndex = (Array.isArray(current) || isArguments(current)) && isIndex(key) && key < current.length;
+            if (!isSparseIndex) {
+                return false;
+            }
+        }
+        current = current[key];
+    }
+    return true;
+}
+
+export { hasIn };

package/dist/compat/object/toPairs.mjs

@@ -1,8 +1,13 @@
 import { keys } from './keys.mjs';
+import { mapToEntries } from '../_internal/mapToEntries.mjs';
+import { setToEntries } from '../_internal/setToEntries.mjs';
 
 function toPairs(object) {
-    if (object instanceof Set || object instanceof Map) {
-        return Array.from(object.entries());
+    if (object instanceof Set) {
+        return setToEntries(object);
+    }
+    if (object instanceof Map) {
+        return mapToEntries(object);
     }
     const keys$1 = keys(object);
     const result = new Array(keys$1.length);

package/dist/compat/object/toPairsIn.mjs

@@ -1,8 +1,13 @@
 import { keysIn } from './keysIn.mjs';
+import { mapToEntries } from '../_internal/mapToEntries.mjs';
+import { setToEntries } from '../_internal/setToEntries.mjs';
 
 function toPairsIn(object) {
-    if (object instanceof Set || object instanceof Map) {
-        return Array.from(object.entries());
+    if (object instanceof Set) {
+        return setToEntries(object);
+    }
+    if (object instanceof Map) {
+        return mapToEntries(object);
     }
     const keys = keysIn(object);
     const result = new Array(keys.length);

package/dist/compat/string/repeat.d.mts

@@ -12,6 +12,6 @@
  * repeat('abc', 0); // ''
  * repeat('abc', 2); // 'abcabc'
  */
-declare function repeat(str: string, n: number): string;
+declare function repeat(str: string, n?: number, guard?: unknown): string;
 
 export { repeat };

package/dist/compat/string/repeat.d.ts

@@ -12,6 +12,6 @@
  * repeat('abc', 0); // ''
  * repeat('abc', 2); // 'abcabc'
  */
-declare function repeat(str: string, n: number): string;
+declare function repeat(str: string, n?: number, guard?: unknown): string;
 
 export { repeat };

package/dist/compat/string/repeat.mjs

@@ -1,5 +1,15 @@
-function repeat(str, n) {
-    return str.repeat(n);
+import { isIterateeCall } from '../_internal/isIterateeCall.mjs';
+import { toInteger } from '../util/toInteger.mjs';
+import { toString } from '../util/toString.mjs';
+
+function repeat(str, n, guard) {
+    if (guard ? isIterateeCall(str, n, guard) : n === undefined) {
+        n = 1;
+    }
+    else {
+        n = toInteger(n);
+    }
+    return toString(str).repeat(n);
 }
 
 export { repeat };

package/dist/compat/string/words.d.mts

@@ -10,6 +10,6 @@
  * // => ['fred', 'barney', 'pebbles']
  *
  */
-declare function words(str?: string | object, pattern?: RegExp | string): string[];
+declare function words(str?: string | object, pattern?: RegExp | string, guard?: unknown): string[];
 
 export { words };

package/dist/compat/string/words.d.ts

@@ -10,6 +10,6 @@
  * // => ['fred', 'barney', 'pebbles']
  *
  */
-declare function words(str?: string | object, pattern?: RegExp | string): string[];
+declare function words(str?: string | object, pattern?: RegExp | string, guard?: unknown): string[];
 
 export { words };

package/dist/compat/string/words.mjs

@@ -1,8 +1,9 @@
 import { CASE_SPLIT_PATTERN } from '../../string/words.mjs';
 import { toString } from '../util/toString.mjs';
 
-function words(str, pattern = CASE_SPLIT_PATTERN) {
+function words(str, pattern = CASE_SPLIT_PATTERN, guard) {
     const input = toString(str);
+    pattern = guard ? CASE_SPLIT_PATTERN : pattern;
     const words = Array.from(input.match(pattern) ?? []);
     return words.filter(x => x !== '');
 }

package/dist/compat/toolkit.d.mts

@@ -0,0 +1,9 @@
+import * as compat from './compat.mjs';
+
+type ToolkitFn = (value: any) => any;
+type Compat = typeof compat;
+interface Toolkit extends ToolkitFn, Compat {
+}
+declare const toolkit: Toolkit;
+
+export { toolkit };

package/dist/compat/toolkit.d.ts

@@ -0,0 +1,9 @@
+import * as compat from './compat.js';
+
+type ToolkitFn = (value: any) => any;
+type Compat = typeof compat;
+interface Toolkit extends ToolkitFn, Compat {
+}
+declare const toolkit: Toolkit;
+
+export { toolkit };

package/dist/compat/toolkit.mjs

@@ -0,0 +1,10 @@
+import * as compat from './compat.mjs';
+
+const toolkit = ((value) => {
+    return value;
+});
+Object.assign(toolkit, compat);
+toolkit.partial.placeholder = toolkit;
+toolkit.partialRight.placeholder = toolkit;
+
+export { toolkit };

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

@@ -0,0 +1,67 @@
+/**
+ * Creates a predicate function that checks if a value satisfies all of the given predicates.
+ *
+ * @template T - The type of the value to be checked.
+ * @template U - The first possible type that the value could match.
+ * @template V - The second possible type that the value could match.
+ *
+ * @param {(value: T) => value is U} predicate1 - A function that checks if the value matches type `U`.
+ * @param {(value: T) => value is V} predicate2 - A function that checks if the value matches type `V`.
+ *
+ * @returns {(value: T) => value is U & V} A function that takes a value and returns `true` if all predicates return truthy.
+ *
+ * @example
+ * const func = overEvery(
+ *   (value) => typeof value === 'string',
+ *   (value) => value === 'hello'
+ * );
+ *
+ * func("hello"); // true
+ * func("world"); // false
+ * func(42); // false
+ */
+declare function overEvery<T, U extends T, V extends T>(predicate1: (value: T) => value is U, predicate2: (value: T) => value is V): (value: T) => value is U & V;
+/**
+ * Creates a function that checks if all of the given predicates return truthy for the provided values.
+ *
+ * @template T - The type of the values to be checked.
+ *
+ * @param {...Array<((...values: T[]) => boolean) | ReadonlyArray<(...values: T[]) => boolean>>} predicates -
+ *   A list of predicates or arrays of predicates. Each predicate is a function that takes one or more values of
+ *   type `T` and returns a boolean indicating whether the condition is satisfied for those values.
+ *
+ * @returns {(...values: T[]) => boolean} A function that takes a list of values and returns `true` if all of the
+ *   predicates return truthy for the provided values, and `false` otherwise.
+ *
+ * @example
+ * const func = overEvery(
+ *   (value) => typeof value === 'string',
+ *   (value) => value.length > 3
+ * );
+ *
+ * func("hello"); // true
+ * func("hi"); // false
+ * func(42); // false
+ *
+ * @example
+ * const func = overEvery([
+ *   (value) => value.a > 0,
+ *   (value) => value.b > 0
+ * ]);
+ *
+ * func({ a: 1, b: 2 }); // true
+ * func({ a: 0, b: 2 }); // false
+ *
+ * @example
+ * const func = overEvery(
+ *   (a, b) => typeof a === 'string' && typeof b === 'string',
+ *   (a, b) => a.length > 3 && b.length > 3
+ * );
+ *
+ * func("hello", "world"); // true
+ * func("hi", "world"); // false
+ * func(1, 10); // false
+ */
+declare function overEvery<T>(...predicates: Array<((...args: T[]) => boolean) | ReadonlyArray<(...args: T[]) => boolean>>): (...args: T[]) => boolean;
+
+export { overEvery };

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

@@ -0,0 +1,67 @@
+/**
+ * Creates a predicate function that checks if a value satisfies all of the given predicates.
+ *
+ * @template T - The type of the value to be checked.
+ * @template U - The first possible type that the value could match.
+ * @template V - The second possible type that the value could match.
+ *
+ * @param {(value: T) => value is U} predicate1 - A function that checks if the value matches type `U`.
+ * @param {(value: T) => value is V} predicate2 - A function that checks if the value matches type `V`.
+ *
+ * @returns {(value: T) => value is U & V} A function that takes a value and returns `true` if all predicates return truthy.
+ *
+ * @example
+ * const func = overEvery(
+ *   (value) => typeof value === 'string',
+ *   (value) => value === 'hello'
+ * );
+ *
+ * func("hello"); // true
+ * func("world"); // false
+ * func(42); // false
+ */
+declare function overEvery<T, U extends T, V extends T>(predicate1: (value: T) => value is U, predicate2: (value: T) => value is V): (value: T) => value is U & V;
+/**
+ * Creates a function that checks if all of the given predicates return truthy for the provided values.
+ *
+ * @template T - The type of the values to be checked.
+ *
+ * @param {...Array<((...values: T[]) => boolean) | ReadonlyArray<(...values: T[]) => boolean>>} predicates -
+ *   A list of predicates or arrays of predicates. Each predicate is a function that takes one or more values of
+ *   type `T` and returns a boolean indicating whether the condition is satisfied for those values.
+ *
+ * @returns {(...values: T[]) => boolean} A function that takes a list of values and returns `true` if all of the
+ *   predicates return truthy for the provided values, and `false` otherwise.
+ *
+ * @example
+ * const func = overEvery(
+ *   (value) => typeof value === 'string',
+ *   (value) => value.length > 3
+ * );
+ *
+ * func("hello"); // true
+ * func("hi"); // false
+ * func(42); // false
+ *
+ * @example
+ * const func = overEvery([
+ *   (value) => value.a > 0,
+ *   (value) => value.b > 0
+ * ]);
+ *
+ * func({ a: 1, b: 2 }); // true
+ * func({ a: 0, b: 2 }); // false
+ *
+ * @example
+ * const func = overEvery(
+ *   (a, b) => typeof a === 'string' && typeof b === 'string',
+ *   (a, b) => a.length > 3 && b.length > 3
+ * );
+ *
+ * func("hello", "world"); // true
+ * func("hi", "world"); // false
+ * func(1, 10); // false
+ */
+declare function overEvery<T>(...predicates: Array<((...args: T[]) => boolean) | ReadonlyArray<(...args: T[]) => boolean>>): (...args: T[]) => boolean;
+
+export { overEvery };

package/dist/compat/util/overEvery.mjs

@@ -0,0 +1,23 @@
+import { iteratee } from './iteratee.mjs';
+
+function overEvery(...predicates) {
+    return function (...values) {
+        for (let i = 0; i < predicates.length; ++i) {
+            const predicate = predicates[i];
+            if (!Array.isArray(predicate)) {
+                if (!iteratee(predicate).apply(this, values)) {
+                    return false;
+                }
+                continue;
+            }
+            for (let j = 0; j < predicate.length; ++j) {
+                if (!iteratee(predicate[j]).apply(this, values)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    };
+}
+
+export { overEvery };

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

@@ -0,0 +1,69 @@
+/**
+ * Creates a predicate function that checks if a value satisfies at least one of the given predicates.
+ *
+ * @template T - The type of the value to be checked.
+ * @template U - The first possible type that the value could match.
+ * @template V - The second possible type that the value could match.
+ *
+ * @param {(value: T) => value is U} predicate1 - A function that checks if the value matches type `U`.
+ * @param {(value: T) => value is V} predicate2 - A function that checks if the value matches type `V`.
+ *
+ * @returns {(value: T) => value is U | V} A function that takes a value and returns `true` if any predicates return truthy.
+ *
+ * @example
+ * const func = overSome(
+ *   (value) => typeof value === 'string',
+ *   (value) => typeof value === 'number'
+ * );
+ *
+ * func("hello"); // true
+ * func(42); // true
+ * func([]); // false
+ */
+declare function overSome<T, U extends T, V extends T>(predicate1: (value: T) => value is U, predicate2: (value: T) => value is V): (value: T) => value is U | V;
+/**
+ * Creates a function that checks if any of the given predicates return truthy for the provided values.
+ *
+ * @template T - The type of the values to be checked.
+ *
+ * @param {...Array<((...values: T[]) => boolean) | ReadonlyArray<(...values: T[]) => boolean>>} predicates -
+ *   A list of predicates or arrays of predicates. Each predicate is a function that takes one or more values of
+ *   type `T` and returns a boolean indicating whether the condition is satisfied for those values.
+ *
+ * @returns {(...values: T[]) => boolean} A function that takes a list of values and returns `true` if any of the
+ *   predicates return truthy for the provided values, and `false` otherwise.
+ *
+ * @example
+ * const func = overSome(
+ *   (value) => typeof value === 'string',
+ *   (value) => typeof value === 'number',
+ *   (value) => typeof value === 'symbol'
+ * );
+ *
+ * func("hello"); // true
+ * func(42); // true
+ * func(Symbol()); // true
+ * func([]); // false
+ *
+ * @example
+ * const func = overSome([
+ *   (value) => value.a > 0,
+ *   (value) => value.b > 0
+ * ]);
+ *
+ * func({ a: 0, b: 2 }); // true
+ * func({ a: 0, b: 0 }); // false
+ *
+ * @example
+ * const func = overSome(
+ *   (a, b) => typeof a === 'string' && typeof b === 'string',
+ *   (a, b) => a > 0 && b > 0
+ * );
+ *
+ * func("hello", "world"); // true
+ * func(1, 10); // true
+ * func(0, 2); // false
+ */
+declare function overSome<T>(...predicates: Array<((...values: T[]) => boolean) | ReadonlyArray<(...values: T[]) => boolean>>): (...values: T[]) => boolean;
+
+export { overSome };

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

@@ -0,0 +1,69 @@
+/**
+ * Creates a predicate function that checks if a value satisfies at least one of the given predicates.
+ *
+ * @template T - The type of the value to be checked.
+ * @template U - The first possible type that the value could match.
+ * @template V - The second possible type that the value could match.
+ *
+ * @param {(value: T) => value is U} predicate1 - A function that checks if the value matches type `U`.
+ * @param {(value: T) => value is V} predicate2 - A function that checks if the value matches type `V`.
+ *
+ * @returns {(value: T) => value is U | V} A function that takes a value and returns `true` if any predicates return truthy.
+ *
+ * @example
+ * const func = overSome(
+ *   (value) => typeof value === 'string',
+ *   (value) => typeof value === 'number'
+ * );
+ *
+ * func("hello"); // true
+ * func(42); // true
+ * func([]); // false
+ */
+declare function overSome<T, U extends T, V extends T>(predicate1: (value: T) => value is U, predicate2: (value: T) => value is V): (value: T) => value is U | V;
+/**
+ * Creates a function that checks if any of the given predicates return truthy for the provided values.
+ *
+ * @template T - The type of the values to be checked.
+ *
+ * @param {...Array<((...values: T[]) => boolean) | ReadonlyArray<(...values: T[]) => boolean>>} predicates -
+ *   A list of predicates or arrays of predicates. Each predicate is a function that takes one or more values of
+ *   type `T` and returns a boolean indicating whether the condition is satisfied for those values.
+ *
+ * @returns {(...values: T[]) => boolean} A function that takes a list of values and returns `true` if any of the
+ *   predicates return truthy for the provided values, and `false` otherwise.
+ *
+ * @example
+ * const func = overSome(
+ *   (value) => typeof value === 'string',
+ *   (value) => typeof value === 'number',
+ *   (value) => typeof value === 'symbol'
+ * );
+ *
+ * func("hello"); // true
+ * func(42); // true
+ * func(Symbol()); // true
+ * func([]); // false
+ *
+ * @example
+ * const func = overSome([
+ *   (value) => value.a > 0,
+ *   (value) => value.b > 0
+ * ]);
+ *
+ * func({ a: 0, b: 2 }); // true
+ * func({ a: 0, b: 0 }); // false
+ *
+ * @example
+ * const func = overSome(
+ *   (a, b) => typeof a === 'string' && typeof b === 'string',
+ *   (a, b) => a > 0 && b > 0
+ * );
+ *
+ * func("hello", "world"); // true
+ * func(1, 10); // true
+ * func(0, 2); // false
+ */
+declare function overSome<T>(...predicates: Array<((...values: T[]) => boolean) | ReadonlyArray<(...values: T[]) => boolean>>): (...values: T[]) => boolean;
+
+export { overSome };

package/dist/compat/util/overSome.mjs

@@ -0,0 +1,23 @@
+import { iteratee } from './iteratee.mjs';
+
+function overSome(...predicates) {
+    return function (...values) {
+        for (let i = 0; i < predicates.length; ++i) {
+            const predicate = predicates[i];
+            if (!Array.isArray(predicate)) {
+                if (iteratee(predicate).apply(this, values)) {
+                    return true;
+                }
+                continue;
+            }
+            for (let j = 0; j < predicate.length; ++j) {
+                if (iteratee(predicate[j]).apply(this, values)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    };
+}
+
+export { overSome };

package/dist/function/index.js

@@ -2,9 +2,8 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const unary = require('../_chunk/unary-BsNWRM.js');
+const unary = require('../_chunk/unary-EIEhcF.js');
 const noop = require('../_chunk/noop-2IwLUk.js');
-const partialRight = require('../_chunk/partialRight-B0_CSB.js');
 
 function before(n, func) {
     if (!Number.isInteger(n) || n < 0) {
@@ -76,7 +75,6 @@ function throttle(func, throttleMs, { signal, edges = ['leading', 'trailing'] }
             if (Date.now() - pendingAt >= throttleMs) {
                 pendingAt = Date.now();
                 debounced.cancel();
-                debounced(...args);
             }
         }
         debounced(...args);
@@ -96,12 +94,12 @@ exports.identity = unary.identity;
 exports.memoize = unary.memoize;
 exports.negate = unary.negate;
 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.partial = partialRight.partial;
-exports.partialRight = partialRight.partialRight;
 exports.before = before;
 exports.curry = curry;
 exports.curryRight = curryRight;

package/dist/function/partial.d.mts

@@ -1,4 +1,3 @@
-type Placeholder = typeof partialPlaceholder;
 /**
  * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding.
  *
@@ -544,8 +543,9 @@ declare function partial<TS extends any[], T1, T2, T3, T4, R>(func: (t1: T1, arg
  */
 declare function partial<F extends (...args: any[]) => any>(func: F, ...partialArgs: any[]): (...args: any[]) => ReturnType<F>;
 declare namespace partial {
-    var placeholder: typeof partialPlaceholder;
+    var placeholder: typeof placeholderSymbol;
 }
-declare const partialPlaceholder: unique symbol;
+declare const placeholderSymbol: unique symbol;
+type Placeholder = typeof placeholderSymbol;
 
 export { partial };

package/dist/function/partial.d.ts

@@ -1,4 +1,3 @@
-type Placeholder = typeof partialPlaceholder;
 /**
  * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding.
  *
@@ -544,8 +543,9 @@ declare function partial<TS extends any[], T1, T2, T3, T4, R>(func: (t1: T1, arg
  */
 declare function partial<F extends (...args: any[]) => any>(func: F, ...partialArgs: any[]): (...args: any[]) => ReturnType<F>;
 declare namespace partial {
-    var placeholder: typeof partialPlaceholder;
+    var placeholder: typeof placeholderSymbol;
 }
-declare const partialPlaceholder: unique symbol;
+declare const placeholderSymbol: unique symbol;
+type Placeholder = typeof placeholderSymbol;
 
 export { partial };