es-toolkit 1.21.0 → 1.22.0-dev.690

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

@@ -0,0 +1,40 @@
+/**
+ * Drops elements from the beginning of an array while the predicate function returns truthy.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} arr - The array from which to drop elements.
+ * @param {(item: T, index: number, arr: T[]) => unknown} canContinueDropping - A predicate function that determines
+ * whether to continue dropping elements. The function is called with each element, index, and array, and dropping
+ * continues as long as it returns true.
+ * @returns {T[]} A new array with the elements remaining after the predicate returns false.
+ */
+declare function dropWhile<T>(arr: readonly T[], canContinueDropping: (item: T, index: number, arr: readonly T[]) => unknown): T[];
+/**
+ * Drops elements from the beginning of an array while the specified object properties match.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} arr - The array from which to drop elements.
+ * @param {Partial<T>} objectToDrop - An object specifying the properties to match for dropping elements.
+ * @returns {T[]} A new array with the elements remaining after the predicate returns false.
+ */
+declare function dropWhile<T>(arr: readonly T[], objectToDrop: Partial<T>): T[];
+/**
+ * Drops elements from the beginning of an array while the specified property matches a given value.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} arr - The array from which to drop elements.
+ * @param {[keyof T, unknown]} propertyToDrop - A tuple containing the property key and the value to match for dropping elements.
+ * @returns {T[]} A new array with the elements remaining after the predicate returns false.
+ */
+declare function dropWhile<T>(arr: readonly T[], propertyToDrop: [keyof T, unknown]): T[];
+/**
+ * Drops elements from the beginning of an array while the specified property name matches.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} arr - The array from which to drop elements.
+ * @param {string} propertyToDrop - The name of the property to match for dropping elements.
+ * @returns {T[]} A new array with the elements remaining after the predicate returns false.
+ */
+declare function dropWhile<T>(arr: readonly T[], propertyToDrop: string): T[];
+
+export { dropWhile };

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

@@ -0,0 +1,40 @@
+/**
+ * Drops elements from the beginning of an array while the predicate function returns truthy.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} arr - The array from which to drop elements.
+ * @param {(item: T, index: number, arr: T[]) => unknown} canContinueDropping - A predicate function that determines
+ * whether to continue dropping elements. The function is called with each element, index, and array, and dropping
+ * continues as long as it returns true.
+ * @returns {T[]} A new array with the elements remaining after the predicate returns false.
+ */
+declare function dropWhile<T>(arr: readonly T[], canContinueDropping: (item: T, index: number, arr: readonly T[]) => unknown): T[];
+/**
+ * Drops elements from the beginning of an array while the specified object properties match.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} arr - The array from which to drop elements.
+ * @param {Partial<T>} objectToDrop - An object specifying the properties to match for dropping elements.
+ * @returns {T[]} A new array with the elements remaining after the predicate returns false.
+ */
+declare function dropWhile<T>(arr: readonly T[], objectToDrop: Partial<T>): T[];
+/**
+ * Drops elements from the beginning of an array while the specified property matches a given value.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} arr - The array from which to drop elements.
+ * @param {[keyof T, unknown]} propertyToDrop - A tuple containing the property key and the value to match for dropping elements.
+ * @returns {T[]} A new array with the elements remaining after the predicate returns false.
+ */
+declare function dropWhile<T>(arr: readonly T[], propertyToDrop: [keyof T, unknown]): T[];
+/**
+ * Drops elements from the beginning of an array while the specified property name matches.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} arr - The array from which to drop elements.
+ * @param {string} propertyToDrop - The name of the property to match for dropping elements.
+ * @returns {T[]} A new array with the elements remaining after the predicate returns false.
+ */
+declare function dropWhile<T>(arr: readonly T[], propertyToDrop: string): T[];
+
+export { dropWhile };

package/dist/compat/array/dropWhile.mjs

@@ -0,0 +1,27 @@
+import { dropWhile as dropWhile$1 } from '../../array/dropWhile.mjs';
+import { property } from '../object/property.mjs';
+import { matches } from '../predicate/matches.mjs';
+import { matchesProperty } from '../predicate/matchesProperty.mjs';
+
+function dropWhile(arr, predicate) {
+    switch (typeof predicate) {
+        case 'function': {
+            return dropWhile$1(arr, (item, index, arr) => Boolean(predicate(item, index, arr)));
+        }
+        case 'object': {
+            if (Array.isArray(predicate) && predicate.length === 2) {
+                const key = predicate[0];
+                const value = predicate[1];
+                return dropWhile$1(arr, matchesProperty(key, value));
+            }
+            else {
+                return dropWhile$1(arr, matches(predicate));
+            }
+        }
+        case 'string': {
+            return dropWhile$1(arr, property(predicate));
+        }
+    }
+}
+
+export { dropWhile };

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

@@ -0,0 +1,139 @@
+/**
+ * Checks if all elements in an array are truthy.
+ *
+ * @template T
+ * @param {T[]} arr - The array to check through.
+ * @returns {boolean} - `true` if all elements are truthy, or `false` if at least one element is falsy.
+ *
+ * @example
+ * const items = [1, 2, 3, 4];
+ * const result = every(items);
+ * console.log(result); // true
+ *
+ * const itemsWithFalsy = [1, 0, 3, 4];
+ * const resultWithFalsy = every(itemsWithFalsy);
+ * console.log(resultWithFalsy); // false
+ */
+declare function every<T>(arr: readonly T[]): boolean;
+/**
+ * Checks if every item in an array matches the given predicate function.
+ *
+ * @template T
+ * @param {T[]} arr - The array to check through.
+ * @param {(item: T, index: number, arr: T[]) => unknown} doesMatch - A function that takes an item, its index, and the array, and returns a truthy value if the item matches the criteria.
+ * @returns {boolean} - `true` if every item matches the predicate, or `false` if at least one item does not match.
+ *
+ * @example
+ * // Using a predicate function
+ * const items = [1, 2, 3, 4, 5];
+ * const result = every(items, (item) => item > 0);
+ * console.log(result); // true
+ */
+declare function every<T>(arr: readonly T[], doesMatch: (item: T, index: number, arr: readonly T[]) => unknown): boolean;
+/**
+ * Checks if every item in an array matches the given partial object.
+ *
+ * @template T
+ * @param {T[]} arr - The array to check through.
+ * @param {Partial<T>} doesMatch - A partial object that specifies the properties to match.
+ * @returns {boolean} - `true` if every item matches the partial object, or `false` if at least one item does not match.
+ *
+ * @example
+ * // Using a partial object
+ * const items = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
+ * const result = every(items, { name: 'Bob' });
+ * console.log(result); // false
+ */
+declare function every<T>(arr: readonly T[], doesMatch: Partial<T>): boolean;
+/**
+ * Checks if every item in an array matches a property with a specific value.
+ *
+ * @template T
+ * @param {readonly T[]} arr - The array to check through.
+ * @param {[keyof T, unknown]} doesMatchProperty - An array where the first element is the property key and the second element is the value to match.
+ * @returns {boolean} - `true` if every item has the specified property value, or `false` if at least one item does not match.
+ *
+ * @example
+ * // Using a property-value pair
+ * const items = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
+ * const result = every(items, ['name', 'Alice']);
+ * console.log(result); // false
+ */
+declare function every<T>(arr: readonly T[], doesMatchProperty: [keyof T, unknown]): boolean;
+/**
+ * Checks if every item in an array has a specific property, where the property name is provided as a string.
+ *
+ * @template T
+ * @param {readonly T[]} arr - The array to check through.
+ * @param {string} propertyToCheck - The property name to check.
+ * @returns {boolean} - `true` if every item has the specified property, or `false` if at least one item does not match.
+ *
+ * @example
+ * // Using a property name
+ * const items = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
+ * const result = every(items, 'name');
+ * console.log(result); // true
+ */
+declare function every<T>(arr: readonly T[], propertyToCheck: string): boolean;
+/**
+ * Checks if every item in an object matches the given predicate function.
+ *
+ * @template T
+ * @param {T extends Record<string, unknown> ? T : never} object - The object to check through.
+ * @param {(item: T[keyof T], index: keyof T, arr: T) => unknown} doesMatch - A function that takes an item, its key, and the object, and returns a truthy value if the item matches the criteria.
+ * @returns {boolean} - `true` if every property value matches the predicate, or `false` if at least one does not match.
+ *
+ * @example
+ * // Using a predicate function
+ * const obj = { a: 1, b: 2, c: 3 };
+ * const result = every(obj, (item) => item > 0);
+ * console.log(result); // true
+ */
+declare function every<T extends Record<string, unknown>>(object: T, doesMatch: (item: T[keyof T], index: keyof T, object: T) => unknown): boolean;
+/**
+ * Checks if every item in an object matches the given partial value.
+ *
+ * @template T
+ * @param {T extends Record<string, unknown> ? T : never} object - The object to check through.
+ * @param {Partial<T[keyof T]>} doesMatch - A partial value to match against the values of the object.
+ * @returns {boolean} - `true` if every property value matches the partial value, or `false` if at least one does not match.
+ *
+ * @example
+ * // Using a partial value
+ * const obj = { a: { id: 1, name: 'Alice' }, b: { id: 2, name: 'Bob' } };
+ * const result = every(obj, { name: 'Bob' });
+ * console.log(result); // false
+ */
+declare function every<T extends Record<string, unknown>>(object: T, doesMatch: Partial<T[keyof T]>): boolean;
+/**
+ * Checks if every item in an object matches a property with a specific value.
+ *
+ * @template T
+ * @param {readonly T[]} object - The object to check through.
+ * @param {[keyof T, unknown]} doesMatchProperty - An array where the first element is the property key and the second element is the value to match.
+ * @returns {boolean} - `true` if every item has the specified property value, or `false` if at least one item does not match.
+ *
+ * @example
+ * // Using a property-value pair
+ * const items = { alice: { id: 1, name: 'Alice' }, bob: { id: 2, name: 'Bob' } };
+ * const result = every(items, ['name', 'Alice']);
+ * console.log(result); // false
+ */
+declare function every<T extends Record<string, unknown>>(object: T, doesMatchProperty: [keyof T, unknown]): boolean;
+/**
+ * Checks if every item in an object has a specific property, where the property name is provided as a string.
+ *
+ * @template T
+ * @param {T extends Record<string, unknown> ? T : never} object - The object to check through.
+ * @param {string} propertyToCheck - The property name to check.
+ * @returns {boolean} - `true` if every property value has the specified property, or `false` if at least one does not match.
+ *
+ * @example
+ * // Using a property name
+ * const obj = { a: { id: 1, name: 'Alice' }, b: { id: 2, name: 'Bob' } };
+ * const result = every(obj, 'name');
+ * console.log(result); // true
+ */
+declare function every<T extends Record<string, unknown>>(object: T, propertyToCheck: string): boolean;
+
+export { every };

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

@@ -0,0 +1,139 @@
+/**
+ * Checks if all elements in an array are truthy.
+ *
+ * @template T
+ * @param {T[]} arr - The array to check through.
+ * @returns {boolean} - `true` if all elements are truthy, or `false` if at least one element is falsy.
+ *
+ * @example
+ * const items = [1, 2, 3, 4];
+ * const result = every(items);
+ * console.log(result); // true
+ *
+ * const itemsWithFalsy = [1, 0, 3, 4];
+ * const resultWithFalsy = every(itemsWithFalsy);
+ * console.log(resultWithFalsy); // false
+ */
+declare function every<T>(arr: readonly T[]): boolean;
+/**
+ * Checks if every item in an array matches the given predicate function.
+ *
+ * @template T
+ * @param {T[]} arr - The array to check through.
+ * @param {(item: T, index: number, arr: T[]) => unknown} doesMatch - A function that takes an item, its index, and the array, and returns a truthy value if the item matches the criteria.
+ * @returns {boolean} - `true` if every item matches the predicate, or `false` if at least one item does not match.
+ *
+ * @example
+ * // Using a predicate function
+ * const items = [1, 2, 3, 4, 5];
+ * const result = every(items, (item) => item > 0);
+ * console.log(result); // true
+ */
+declare function every<T>(arr: readonly T[], doesMatch: (item: T, index: number, arr: readonly T[]) => unknown): boolean;
+/**
+ * Checks if every item in an array matches the given partial object.
+ *
+ * @template T
+ * @param {T[]} arr - The array to check through.
+ * @param {Partial<T>} doesMatch - A partial object that specifies the properties to match.
+ * @returns {boolean} - `true` if every item matches the partial object, or `false` if at least one item does not match.
+ *
+ * @example
+ * // Using a partial object
+ * const items = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
+ * const result = every(items, { name: 'Bob' });
+ * console.log(result); // false
+ */
+declare function every<T>(arr: readonly T[], doesMatch: Partial<T>): boolean;
+/**
+ * Checks if every item in an array matches a property with a specific value.
+ *
+ * @template T
+ * @param {readonly T[]} arr - The array to check through.
+ * @param {[keyof T, unknown]} doesMatchProperty - An array where the first element is the property key and the second element is the value to match.
+ * @returns {boolean} - `true` if every item has the specified property value, or `false` if at least one item does not match.
+ *
+ * @example
+ * // Using a property-value pair
+ * const items = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
+ * const result = every(items, ['name', 'Alice']);
+ * console.log(result); // false
+ */
+declare function every<T>(arr: readonly T[], doesMatchProperty: [keyof T, unknown]): boolean;
+/**
+ * Checks if every item in an array has a specific property, where the property name is provided as a string.
+ *
+ * @template T
+ * @param {readonly T[]} arr - The array to check through.
+ * @param {string} propertyToCheck - The property name to check.
+ * @returns {boolean} - `true` if every item has the specified property, or `false` if at least one item does not match.
+ *
+ * @example
+ * // Using a property name
+ * const items = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
+ * const result = every(items, 'name');
+ * console.log(result); // true
+ */
+declare function every<T>(arr: readonly T[], propertyToCheck: string): boolean;
+/**
+ * Checks if every item in an object matches the given predicate function.
+ *
+ * @template T
+ * @param {T extends Record<string, unknown> ? T : never} object - The object to check through.
+ * @param {(item: T[keyof T], index: keyof T, arr: T) => unknown} doesMatch - A function that takes an item, its key, and the object, and returns a truthy value if the item matches the criteria.
+ * @returns {boolean} - `true` if every property value matches the predicate, or `false` if at least one does not match.
+ *
+ * @example
+ * // Using a predicate function
+ * const obj = { a: 1, b: 2, c: 3 };
+ * const result = every(obj, (item) => item > 0);
+ * console.log(result); // true
+ */
+declare function every<T extends Record<string, unknown>>(object: T, doesMatch: (item: T[keyof T], index: keyof T, object: T) => unknown): boolean;
+/**
+ * Checks if every item in an object matches the given partial value.
+ *
+ * @template T
+ * @param {T extends Record<string, unknown> ? T : never} object - The object to check through.
+ * @param {Partial<T[keyof T]>} doesMatch - A partial value to match against the values of the object.
+ * @returns {boolean} - `true` if every property value matches the partial value, or `false` if at least one does not match.
+ *
+ * @example
+ * // Using a partial value
+ * const obj = { a: { id: 1, name: 'Alice' }, b: { id: 2, name: 'Bob' } };
+ * const result = every(obj, { name: 'Bob' });
+ * console.log(result); // false
+ */
+declare function every<T extends Record<string, unknown>>(object: T, doesMatch: Partial<T[keyof T]>): boolean;
+/**
+ * Checks if every item in an object matches a property with a specific value.
+ *
+ * @template T
+ * @param {readonly T[]} object - The object to check through.
+ * @param {[keyof T, unknown]} doesMatchProperty - An array where the first element is the property key and the second element is the value to match.
+ * @returns {boolean} - `true` if every item has the specified property value, or `false` if at least one item does not match.
+ *
+ * @example
+ * // Using a property-value pair
+ * const items = { alice: { id: 1, name: 'Alice' }, bob: { id: 2, name: 'Bob' } };
+ * const result = every(items, ['name', 'Alice']);
+ * console.log(result); // false
+ */
+declare function every<T extends Record<string, unknown>>(object: T, doesMatchProperty: [keyof T, unknown]): boolean;
+/**
+ * Checks if every item in an object has a specific property, where the property name is provided as a string.
+ *
+ * @template T
+ * @param {T extends Record<string, unknown> ? T : never} object - The object to check through.
+ * @param {string} propertyToCheck - The property name to check.
+ * @returns {boolean} - `true` if every property value has the specified property, or `false` if at least one does not match.
+ *
+ * @example
+ * // Using a property name
+ * const obj = { a: { id: 1, name: 'Alice' }, b: { id: 2, name: 'Bob' } };
+ * const result = every(obj, 'name');
+ * console.log(result); // true
+ */
+declare function every<T extends Record<string, unknown>>(object: T, propertyToCheck: string): boolean;
+
+export { every };

package/dist/compat/array/every.mjs

@@ -0,0 +1,49 @@
+import { identity } from '../_internal/identity.mjs';
+import { property } from '../object/property.mjs';
+import { matches } from '../predicate/matches.mjs';
+import { matchesProperty } from '../predicate/matchesProperty.mjs';
+
+function every(source, doesMatch) {
+    if (!source) {
+        source = [];
+    }
+    let values = source;
+    if (!Array.isArray(source)) {
+        values = Object.values(source);
+    }
+    if (!doesMatch) {
+        doesMatch = identity;
+    }
+    switch (typeof doesMatch) {
+        case 'function': {
+            if (!Array.isArray(source)) {
+                const entries = Object.entries(source);
+                for (let i = 0; i < entries.length; i++) {
+                    const entry = entries[i];
+                    const key = entry[0];
+                    const value = entry[1];
+                    if (!doesMatch(value, key, source)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            return values.every(doesMatch);
+        }
+        case 'object': {
+            if (Array.isArray(doesMatch) && doesMatch.length === 2) {
+                const key = doesMatch[0];
+                const value = doesMatch[1];
+                return values.every(matchesProperty(key, value));
+            }
+            else {
+                return values.every(matches(doesMatch));
+            }
+        }
+        case 'string': {
+            return values.every(property(doesMatch));
+        }
+    }
+}
+
+export { every };

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

@@ -0,0 +1,118 @@
+/**
+ * Filters items from a array and returns an array of elements.
+ *
+ * @template T
+ * @param {T[]} arr - The array to iterate over.
+ * @param {(item: T, index: number, arr: T[]) => unknown} doesMatch - The function invoked per iteration.
+ * @returns {T[]} - Returns a new array of elements that satisfy the given doesMatch function.
+
+ *
+ * @example
+ * filter([1, 2, 3], n => n % 2 === 0)
+ * // => [2]
+ */
+declare function filter<T>(arr: readonly T[], doesMatch?: (item: T, index: number, arr: readonly T[]) => unknown): T[];
+/**
+ * Filters elements in a arr that match the properties of the given partial object.
+ *
+ * @template T
+ * @param {T[]} arr - The array to iterate over.
+ * @param {Partial<T>} doesMatch - A partial object that specifies the properties to match.
+ * @returns {T[]} - Returns a new array of elements that match the given properties.
+ *
+ * @example
+ * const arr = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
+ * filter(arr, { name: 'Bob' });
+ * // => [{ id: 2, name: 'Bob' }]
+ */
+declare function filter<T>(arr: readonly T[], doesMatch: Partial<T>): T[];
+/**
+ * Filters elements in a arr that match the given key-value pair.
+ *
+ * @template T
+ * @param {readonly T[]} arr - The array to iterate over.
+ * @param {[keyof T, unknown]} doesMatchProperty - The key-value pair to match.
+ * @returns {T[]} - Returns a new array of elements that match the given key-value pair.
+ *
+ * @example
+ * const arr = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
+ * filter(arr, ['name', 'Alice']);
+ * // => [{ id: 1, name: 'Alice' }]
+ */
+declare function filter<T>(arr: readonly T[], doesMatchProperty: [keyof T, unknown]): T[];
+/**
+ * Filters the arr, returning elements that contain the given property name.
+ *
+ * @template T
+ * @param {readonly T[]} arr - The array to iterate over.
+ * @param {string} propertyToCheck - The property name to check.
+ * @returns {T[]} - Returns a new array of elements that match the given property name.
+ *
+ * @example
+ * const arr = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }, { id: 3, age: 28 }];
+ * filter(arr, 'name');
+ * // => [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]
+ */
+declare function filter<T>(arr: readonly T[], propertyToCheck: string): T[];
+/**
+ * Filters items from a object and returns an array of elements that match the given predicate function.
+ *
+ * @template T
+ * @param {T extends Record<string, unknown> ? T : never} object - The object to iterate over.
+ * @param {(item: T[keyof T], index: number, arr: T) => unknown} doesMatch - The function invoked per iteration.
+ * @returns {T[]} - Returns a new array of elements that satisfy the given predicate function.
+ *
+ * @example
+ * const obj = { item1: { a: 0 }, item2: { a: 1 }, item3: { a: 0 } }
+ * filter(obj, items => items.a)
+ * // => [{ a: 1 }]
+ *
+ * const obj = { a: 1, b: 2, c: 3 };
+ * filter(obj, item => item > 2)
+ * // => [3]
+ */
+declare function filter<T extends Record<string, unknown>>(object: T, doesMatch: (item: T[keyof T], index: number, object: T) => unknown): T[];
+/**
+ * Filters elements in a object that match the properties of the given partial object.
+ *
+ * @template T
+ * @param {T extends Record<string, unknown> ? T : never} object - The object to iterate over.
+ * @param {Partial<T[keyof T]>} doesMatch - The partial object to match
+ * @returns {T[]} - Returns a new array of elements that match the given properties.pair.
+ *
+ * @example
+ * const obj = { a: { id: 1, name: 'Alice' }, b: { id: 2, name: 'Bob' } };
+ * filter(obj, { name: 'Bob' });
+ * // => [{ id: 2, name: 'Bob' }]
+ */
+declare function filter<T extends Record<string, unknown>>(object: T, doesMatch: Partial<T[keyof T]>): T[];
+/**
+ * Filters elements in a arr that match the given key-value pair.
+ *
+ * @template T
+ * @param {T extends Record<string, unknown> ? T : never} object - The object to iterate over.
+ * @param {[keyof T, unknown]} doesMatchProperty - The key-value pair to match.
+ * @returns {T[]} - Returns a new array of elements that match the given key-value pair.
+ *
+ * @example
+ * const obj = { alice: { id: 1, name: 'Alice' }, bob: { id: 2, name: 'Bob' } };
+ * filter(obj, ['name', 'Alice']);
+ * // => [{ id: 1, name: 'Alice' }]
+ */
+declare function filter<T extends Record<string, unknown>>(object: T, doesMatchProperty: [keyof T, unknown]): T[];
+/**
+ * Filters the object, returning elements that contain the given property name.
+ *
+ * @template T
+ * @param {T extends Record<string, unknown> ? T : never} object - The object to iterate over.
+ * @param {string} propertyToCheck - The property name to check.
+ * @returns {T[]} - Returns a new array of elements that match the given property name.
+ *
+ * @example
+ * const obj = { a: { id: 1, name: 'Alice' }, b: { id: 2, name: 'Bob' }, c: { id: 3, age: 28 } };
+ * filter(obj, 'name');
+ * // => [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]
+ */
+declare function filter<T extends Record<string, unknown>>(object: T, propertyToCheck: string): T[];
+
+export { filter };

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

@@ -0,0 +1,118 @@
+/**
+ * Filters items from a array and returns an array of elements.
+ *
+ * @template T
+ * @param {T[]} arr - The array to iterate over.
+ * @param {(item: T, index: number, arr: T[]) => unknown} doesMatch - The function invoked per iteration.
+ * @returns {T[]} - Returns a new array of elements that satisfy the given doesMatch function.
+
+ *
+ * @example
+ * filter([1, 2, 3], n => n % 2 === 0)
+ * // => [2]
+ */
+declare function filter<T>(arr: readonly T[], doesMatch?: (item: T, index: number, arr: readonly T[]) => unknown): T[];
+/**
+ * Filters elements in a arr that match the properties of the given partial object.
+ *
+ * @template T
+ * @param {T[]} arr - The array to iterate over.
+ * @param {Partial<T>} doesMatch - A partial object that specifies the properties to match.
+ * @returns {T[]} - Returns a new array of elements that match the given properties.
+ *
+ * @example
+ * const arr = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
+ * filter(arr, { name: 'Bob' });
+ * // => [{ id: 2, name: 'Bob' }]
+ */
+declare function filter<T>(arr: readonly T[], doesMatch: Partial<T>): T[];
+/**
+ * Filters elements in a arr that match the given key-value pair.
+ *
+ * @template T
+ * @param {readonly T[]} arr - The array to iterate over.
+ * @param {[keyof T, unknown]} doesMatchProperty - The key-value pair to match.
+ * @returns {T[]} - Returns a new array of elements that match the given key-value pair.
+ *
+ * @example
+ * const arr = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
+ * filter(arr, ['name', 'Alice']);
+ * // => [{ id: 1, name: 'Alice' }]
+ */
+declare function filter<T>(arr: readonly T[], doesMatchProperty: [keyof T, unknown]): T[];
+/**
+ * Filters the arr, returning elements that contain the given property name.
+ *
+ * @template T
+ * @param {readonly T[]} arr - The array to iterate over.
+ * @param {string} propertyToCheck - The property name to check.
+ * @returns {T[]} - Returns a new array of elements that match the given property name.
+ *
+ * @example
+ * const arr = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }, { id: 3, age: 28 }];
+ * filter(arr, 'name');
+ * // => [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]
+ */
+declare function filter<T>(arr: readonly T[], propertyToCheck: string): T[];
+/**
+ * Filters items from a object and returns an array of elements that match the given predicate function.
+ *
+ * @template T
+ * @param {T extends Record<string, unknown> ? T : never} object - The object to iterate over.
+ * @param {(item: T[keyof T], index: number, arr: T) => unknown} doesMatch - The function invoked per iteration.
+ * @returns {T[]} - Returns a new array of elements that satisfy the given predicate function.
+ *
+ * @example
+ * const obj = { item1: { a: 0 }, item2: { a: 1 }, item3: { a: 0 } }
+ * filter(obj, items => items.a)
+ * // => [{ a: 1 }]
+ *
+ * const obj = { a: 1, b: 2, c: 3 };
+ * filter(obj, item => item > 2)
+ * // => [3]
+ */
+declare function filter<T extends Record<string, unknown>>(object: T, doesMatch: (item: T[keyof T], index: number, object: T) => unknown): T[];
+/**
+ * Filters elements in a object that match the properties of the given partial object.
+ *
+ * @template T
+ * @param {T extends Record<string, unknown> ? T : never} object - The object to iterate over.
+ * @param {Partial<T[keyof T]>} doesMatch - The partial object to match
+ * @returns {T[]} - Returns a new array of elements that match the given properties.pair.
+ *
+ * @example
+ * const obj = { a: { id: 1, name: 'Alice' }, b: { id: 2, name: 'Bob' } };
+ * filter(obj, { name: 'Bob' });
+ * // => [{ id: 2, name: 'Bob' }]
+ */
+declare function filter<T extends Record<string, unknown>>(object: T, doesMatch: Partial<T[keyof T]>): T[];
+/**
+ * Filters elements in a arr that match the given key-value pair.
+ *
+ * @template T
+ * @param {T extends Record<string, unknown> ? T : never} object - The object to iterate over.
+ * @param {[keyof T, unknown]} doesMatchProperty - The key-value pair to match.
+ * @returns {T[]} - Returns a new array of elements that match the given key-value pair.
+ *
+ * @example
+ * const obj = { alice: { id: 1, name: 'Alice' }, bob: { id: 2, name: 'Bob' } };
+ * filter(obj, ['name', 'Alice']);
+ * // => [{ id: 1, name: 'Alice' }]
+ */
+declare function filter<T extends Record<string, unknown>>(object: T, doesMatchProperty: [keyof T, unknown]): T[];
+/**
+ * Filters the object, returning elements that contain the given property name.
+ *
+ * @template T
+ * @param {T extends Record<string, unknown> ? T : never} object - The object to iterate over.
+ * @param {string} propertyToCheck - The property name to check.
+ * @returns {T[]} - Returns a new array of elements that match the given property name.
+ *
+ * @example
+ * const obj = { a: { id: 1, name: 'Alice' }, b: { id: 2, name: 'Bob' }, c: { id: 3, age: 28 } };
+ * filter(obj, 'name');
+ * // => [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]
+ */
+declare function filter<T extends Record<string, unknown>>(object: T, propertyToCheck: string): T[];
+
+export { filter };