es-toolkit 1.21.0-dev.677 → 1.21.0-dev.679

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/find.d.mts

@@ -72,7 +72,7 @@ declare function find<T>(arr: readonly T[], propertyToCheck: string): T | undefi
  * const result = find(obj, (item) => item > 2);
  * console.log(result); // 3
  */
-declare function find<T extends Record<string, unknown>>(object: T, doesMatch: (item: T[keyof T], index: number, object: T) => unknown): T | undefined;
+declare function find<T extends Record<string, unknown>>(object: T, doesMatch: (item: T[keyof T], index: keyof T, object: T) => unknown): T | undefined;
 /**
  * Finds the first item in an object that matches the given partial value.
  *

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

@@ -72,7 +72,7 @@ declare function find<T>(arr: readonly T[], propertyToCheck: string): T | undefi
  * const result = find(obj, (item) => item > 2);
  * console.log(result); // 3
  */
-declare function find<T extends Record<string, unknown>>(object: T, doesMatch: (item: T[keyof T], index: number, object: T) => unknown): T | undefined;
+declare function find<T extends Record<string, unknown>>(object: T, doesMatch: (item: T[keyof T], index: keyof T, object: T) => unknown): T | undefined;
 /**
  * Finds the first item in an object that matches the given partial value.
  *

package/dist/compat/index.d.mts

@@ -97,6 +97,7 @@ export { concat } from './array/concat.mjs';
 export { difference } from './array/difference.mjs';
 export { drop } from './array/drop.mjs';
 export { dropWhile } from './array/dropWhile.mjs';
+export { every } from './array/every.mjs';
 export { fill } from './array/fill.mjs';
 export { find } from './array/find.mjs';
 export { findIndex } from './array/findIndex.mjs';

package/dist/compat/index.d.ts

@@ -97,6 +97,7 @@ export { concat } from './array/concat.js';
 export { difference } from './array/difference.js';
 export { drop } from './array/drop.js';
 export { dropWhile } from './array/dropWhile.js';
+export { every } from './array/every.js';
 export { fill } from './array/fill.js';
 export { find } from './array/find.js';
 export { findIndex } from './array/findIndex.js';

package/dist/compat/index.js

@@ -389,6 +389,53 @@ function dropWhile(arr, predicate) {
     }
 }
 
+function identity(x) {
+    return x;
+}
+
+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));
+        }
+    }
+}
+
 function fill(array, value, start = 0, end = array.length) {
     start = Math.floor(start);
     end = Math.floor(end);
@@ -682,10 +729,6 @@ function size(target) {
     return Object.keys(target).length;
 }
 
-function identity(x) {
-    return x;
-}
-
 function some(arr, predicate, guard) {
     if (guard != null) {
         predicate = undefined;
@@ -1784,6 +1827,7 @@ exports.difference = difference;
 exports.drop = drop;
 exports.dropWhile = dropWhile;
 exports.endsWith = endsWith;
+exports.every = every;
 exports.fill = fill;
 exports.find = find;
 exports.findIndex = findIndex;

package/dist/compat/index.mjs

@@ -98,6 +98,7 @@ export { concat } from './array/concat.mjs';
 export { difference } from './array/difference.mjs';
 export { drop } from './array/drop.mjs';
 export { dropWhile } from './array/dropWhile.mjs';
+export { every } from './array/every.mjs';
 export { fill } from './array/fill.mjs';
 export { find } from './array/find.mjs';
 export { findIndex } from './array/findIndex.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.677+819d64ec",
+  "version": "1.21.0-dev.679+efe79322",
   "homepage": "https://es-toolkit.slash.page",
   "bugs": "https://github.com/toss/es-toolkit/issues",
   "repository": {