es-toolkit 1.15.1-dev.425 → 1.15.1-dev.427

package/dist/compat/index.js

@@ -42,57 +42,32 @@ function fill(array, value, start = 0, end = array.length) {
     return initial.fill(array, value, start, end);
 }
 
-function flatten(value, depth = 1) {
-    const result = [];
-    const flooredDepth = Math.floor(depth);
-    if (!Array.isArray(value)) {
-        return result;
-    }
-    const recursive = (arr, currentDepth) => {
-        for (const item of arr) {
-            if (currentDepth < flooredDepth &&
-                (Array.isArray(item) ||
-                    Boolean(item?.[Symbol.isConcatSpreadable]) ||
-                    (item !== null && typeof item === 'object' && Object.prototype.toString.call(item) === '[object Arguments]'))) {
-                if (Array.isArray(item)) {
-                    recursive(item, currentDepth + 1);
-                }
-                else {
-                    recursive(Array.from(item), currentDepth + 1);
-                }
-            }
-            else {
-                result.push(item);
-            }
+const IS_PLAIN = /^\w*$/;
+const IS_DEEP = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
+function isDeepKey(key) {
+    switch (typeof key) {
+        case 'number':
+        case 'symbol': {
+            return false;
         }
-    };
-    recursive(value, 0);
-    return result;
-}
-
-function flattenDeep(value) {
-    return flatten(value, Infinity);
-}
-
-function flattenDepth(value, depth = 1) {
-    return flatten(value, depth);
+        case 'string': {
+            return !IS_PLAIN.test(key) && IS_DEEP.test(key);
+        }
+    }
 }
 
 function isSymbol(value) {
     return typeof value === 'symbol' || (value != null && value instanceof Symbol);
 }
 
-const regexIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
-const regexIsPlainProp = /^\w*$/;
-function isKey(value, object) {
-    if (Array.isArray(value)) {
-        return false;
+function toKey(value) {
+    if (typeof value === 'string' || isSymbol(value)) {
+        return value;
     }
-    if (typeof value === 'number' || typeof value === 'boolean' || value == null || isSymbol(value)) {
-        return true;
+    if (Object.is(value?.valueOf(), -0)) {
+        return '-0';
     }
-    return ((typeof value === 'string' && (regexIsPlainProp.test(value) || !regexIsDeepProp.test(value))) ||
-        (object != null && Object.hasOwn(object, value)));
+    return `${value}`;
 }
 
 function toPath(deepKey) {
@@ -130,10 +105,319 @@ function toPath(deepKey) {
         else {
             lastIndex = PROPERTY_REGEXP.lastIndex;
         }
-    }
+    }
+    return result;
+}
+
+function get(object, path, defaultValue) {
+    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 defaultValue;
+    }
+    let current = object;
+    let index;
+    for (index = 0; index < resolvedPath.length && current != null; index++) {
+        const key = toKey(resolvedPath[index]);
+        current = current[key];
+    }
+    if (current === null && index === resolvedPath.length) {
+        return current;
+    }
+    return current ?? defaultValue;
+}
+
+function property(path) {
+    return function (object) {
+        return get(object, path);
+    };
+}
+
+function isArrayMatch(target, source) {
+    if (source.length === 0) {
+        return true;
+    }
+    if (!Array.isArray(target)) {
+        return false;
+    }
+    const countedIndex = new Set();
+    for (let i = 0; i < source.length; i++) {
+        const sourceItem = source[i];
+        const index = target.findIndex((targetItem, index) => {
+            return isMatch(targetItem, sourceItem) && !countedIndex.has(index);
+        });
+        if (index === -1) {
+            return false;
+        }
+        countedIndex.add(index);
+    }
+    return true;
+}
+
+function isMapMatch(target, source) {
+    if (source.size === 0) {
+        return true;
+    }
+    if (!(target instanceof Map)) {
+        return false;
+    }
+    for (const [key, value] of source.entries()) {
+        if (!isMatch(target.get(key), value)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+function isSetMatch(target, source) {
+    if (source.size === 0) {
+        return true;
+    }
+    if (!(target instanceof Set)) {
+        return false;
+    }
+    return isArrayMatch([...target], [...source]);
+}
+
+function isMatch(target, source) {
+    if (source === target) {
+        return true;
+    }
+    switch (typeof source) {
+        case 'object': {
+            if (source == null) {
+                return true;
+            }
+            const keys = Object.keys(source);
+            if (target == null) {
+                if (keys.length === 0) {
+                    return true;
+                }
+                return false;
+            }
+            if (Array.isArray(source)) {
+                return isArrayMatch(target, source);
+            }
+            if (source instanceof Map) {
+                return isMapMatch(target, source);
+            }
+            if (source instanceof Set) {
+                return isSetMatch(target, source);
+            }
+            for (let i = 0; i < keys.length; i++) {
+                const key = keys[i];
+                if (!isTypedArray$1.isPrimitive(target) && !(key in target)) {
+                    return false;
+                }
+                if (source[key] === undefined && target[key] !== undefined) {
+                    return false;
+                }
+                if (!isMatch(target[key], source[key])) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        case 'function': {
+            if (Object.keys(source).length > 0) {
+                return isMatch(target, { ...source });
+            }
+            return false;
+        }
+        default: {
+            return !source;
+        }
+    }
+}
+
+function matches(source) {
+    source = toMerged.cloneDeep(source);
+    return (target) => {
+        return isMatch(target, source);
+    };
+}
+
+function cloneDeep(obj) {
+    if (typeof obj !== 'object') {
+        return toMerged.cloneDeep(obj);
+    }
+    switch (Object.prototype.toString.call(obj)) {
+        case isFunction.numberTag:
+        case isFunction.stringTag:
+        case isFunction.booleanTag: {
+            const result = new obj.constructor(obj?.valueOf());
+            toMerged.copyProperties(result, obj);
+            return result;
+        }
+        case isFunction.argumentsTag: {
+            const result = {};
+            toMerged.copyProperties(result, obj);
+            result.length = obj.length;
+            result[Symbol.iterator] = obj[Symbol.iterator];
+            return result;
+        }
+        default: {
+            return toMerged.cloneDeep(obj);
+        }
+    }
+}
+
+const IS_UNSIGNED_INTEGER = /^(?:0|[1-9]\d*)$/;
+function isIndex(value) {
+    switch (typeof value) {
+        case 'number': {
+            return Number.isInteger(value) && value >= 0 && value < Number.MAX_SAFE_INTEGER;
+        }
+        case 'symbol': {
+            return false;
+        }
+        case 'string': {
+            return IS_UNSIGNED_INTEGER.test(value);
+        }
+    }
+}
+
+function isArguments(value) {
+    return value !== null && typeof value === 'object' && isFunction.getTag(value) === '[object Arguments]';
+}
+
+function has(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 || !Object.prototype.hasOwnProperty.call(current, key)) {
+            const isSparseIndex = (Array.isArray(current) || isArguments(current)) && isIndex(key) && key < current.length;
+            if (!isSparseIndex) {
+                return false;
+            }
+        }
+        current = current[key];
+    }
+    return true;
+}
+
+function matchesProperty(property, source) {
+    property = Array.isArray(property) ? property : toKey(property);
+    source = cloneDeep(source);
+    return function (target) {
+        const result = get(target, property);
+        if (result === undefined) {
+            return has(target, property);
+        }
+        if (source === undefined) {
+            return result === undefined;
+        }
+        return isMatch(result, source);
+    };
+}
+
+function find(source, doesMatch) {
+    let values = source;
+    if (!Array.isArray(source)) {
+        values = Object.values(source);
+    }
+    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 value;
+                    }
+                }
+                return undefined;
+            }
+            return values.find(doesMatch);
+        }
+        case 'object': {
+            if (Array.isArray(doesMatch) && doesMatch.length === 2) {
+                const key = doesMatch[0];
+                const value = doesMatch[1];
+                return values.find(matchesProperty(key, value));
+            }
+            else {
+                return values.find(matches(doesMatch));
+            }
+        }
+        case 'string': {
+            return values.find(property(doesMatch));
+        }
+    }
+}
+
+function flatten(value, depth = 1) {
+    const result = [];
+    const flooredDepth = Math.floor(depth);
+    if (!Array.isArray(value)) {
+        return result;
+    }
+    const recursive = (arr, currentDepth) => {
+        for (const item of arr) {
+            if (currentDepth < flooredDepth &&
+                (Array.isArray(item) ||
+                    Boolean(item?.[Symbol.isConcatSpreadable]) ||
+                    (item !== null && typeof item === 'object' && Object.prototype.toString.call(item) === '[object Arguments]'))) {
+                if (Array.isArray(item)) {
+                    recursive(item, currentDepth + 1);
+                }
+                else {
+                    recursive(Array.from(item), currentDepth + 1);
+                }
+            }
+            else {
+                result.push(item);
+            }
+        }
+    };
+    recursive(value, 0);
     return result;
 }
 
+function flattenDeep(value) {
+    return flatten(value, Infinity);
+}
+
+function flattenDepth(value, depth = 1) {
+    return flatten(value, depth);
+}
+
+const regexIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
+const regexIsPlainProp = /^\w*$/;
+function isKey(value, object) {
+    if (Array.isArray(value)) {
+        return false;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean' || value == null || isSymbol(value)) {
+        return true;
+    }
+    return ((typeof value === 'string' && (regexIsPlainProp.test(value) || !regexIsDeepProp.test(value))) ||
+        (object != null && Object.hasOwn(object, value)));
+}
+
 function getPath(key, object) {
     if (Array.isArray(key)) {
         const path = [];
@@ -213,21 +497,6 @@ function size(target) {
     return Object.keys(target).length;
 }
 
-const IS_UNSIGNED_INTEGER = /^(?:0|[1-9]\d*)$/;
-function isIndex(value) {
-    switch (typeof value) {
-        case 'number': {
-            return Number.isInteger(value) && value >= 0 && value < Number.MAX_SAFE_INTEGER;
-        }
-        case 'symbol': {
-            return false;
-        }
-        case 'string': {
-            return IS_UNSIGNED_INTEGER.test(value);
-        }
-    }
-}
-
 function set(obj, path, value) {
     const resolvedPath = Array.isArray(path) ? path : typeof path === 'string' ? toPath(path) : [path];
     let current = obj;
@@ -292,94 +561,6 @@ function bind(func, thisObj, ...partialArgs) {
 const bindPlaceholder = Symbol('bind.placeholder');
 bind.placeholder = bindPlaceholder;
 
-const IS_PLAIN = /^\w*$/;
-const IS_DEEP = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
-function isDeepKey(key) {
-    switch (typeof key) {
-        case 'number':
-        case 'symbol': {
-            return false;
-        }
-        case 'string': {
-            return !IS_PLAIN.test(key) && IS_DEEP.test(key);
-        }
-    }
-}
-
-function toKey(value) {
-    if (typeof value === 'string' || isSymbol(value)) {
-        return value;
-    }
-    if (Object.is(value?.valueOf(), -0)) {
-        return '-0';
-    }
-    return `${value}`;
-}
-
-function get(object, path, defaultValue) {
-    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 defaultValue;
-    }
-    let current = object;
-    let index;
-    for (index = 0; index < resolvedPath.length && current != null; index++) {
-        const key = toKey(resolvedPath[index]);
-        current = current[key];
-    }
-    if (current === null && index === resolvedPath.length) {
-        return current;
-    }
-    return current ?? defaultValue;
-}
-
-function isArguments(value) {
-    return value !== null && typeof value === 'object' && isFunction.getTag(value) === '[object Arguments]';
-}
-
-function has(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 || !Object.prototype.hasOwnProperty.call(current, key)) {
-            const isSparseIndex = (Array.isArray(current) || isArguments(current)) && isIndex(key) && key < current.length;
-            if (!isSparseIndex) {
-                return false;
-            }
-        }
-        current = current[key];
-    }
-    return true;
-}
-
-function property(path) {
-    return function (object) {
-        return get(object, path);
-    };
-}
-
 function identity(x) {
     return x;
 }
@@ -446,31 +627,6 @@ function isTypedArray(x) {
     return isTypedArray$1.isTypedArray(x);
 }
 
-function cloneDeep(obj) {
-    if (typeof obj !== 'object') {
-        return toMerged.cloneDeep(obj);
-    }
-    switch (Object.prototype.toString.call(obj)) {
-        case isFunction.numberTag:
-        case isFunction.stringTag:
-        case isFunction.booleanTag: {
-            const result = new obj.constructor(obj?.valueOf());
-            toMerged.copyProperties(result, obj);
-            return result;
-        }
-        case isFunction.argumentsTag: {
-            const result = {};
-            toMerged.copyProperties(result, obj);
-            result.length = obj.length;
-            result[Symbol.iterator] = obj[Symbol.iterator];
-            return result;
-        }
-        default: {
-            return toMerged.cloneDeep(obj);
-        }
-    }
-}
-
 function mergeWith(object, ...otherArgs) {
     const sources = otherArgs.slice(0, -1);
     const merge = otherArgs[otherArgs.length - 1];
@@ -557,110 +713,6 @@ function isBoolean(x) {
     return false;
 }
 
-function isArrayMatch(target, source) {
-    if (source.length === 0) {
-        return true;
-    }
-    if (!Array.isArray(target)) {
-        return false;
-    }
-    const countedIndex = new Set();
-    for (let i = 0; i < source.length; i++) {
-        const sourceItem = source[i];
-        const index = target.findIndex((targetItem, index) => {
-            return isMatch(targetItem, sourceItem) && !countedIndex.has(index);
-        });
-        if (index === -1) {
-            return false;
-        }
-        countedIndex.add(index);
-    }
-    return true;
-}
-
-function isMapMatch(target, source) {
-    if (source.size === 0) {
-        return true;
-    }
-    if (!(target instanceof Map)) {
-        return false;
-    }
-    for (const [key, value] of source.entries()) {
-        if (!isMatch(target.get(key), value)) {
-            return false;
-        }
-    }
-    return true;
-}
-
-function isSetMatch(target, source) {
-    if (source.size === 0) {
-        return true;
-    }
-    if (!(target instanceof Set)) {
-        return false;
-    }
-    return isArrayMatch([...target], [...source]);
-}
-
-function isMatch(target, source) {
-    if (source === target) {
-        return true;
-    }
-    switch (typeof source) {
-        case 'object': {
-            if (source == null) {
-                return true;
-            }
-            const keys = Object.keys(source);
-            if (target == null) {
-                if (keys.length === 0) {
-                    return true;
-                }
-                return false;
-            }
-            if (Array.isArray(source)) {
-                return isArrayMatch(target, source);
-            }
-            if (source instanceof Map) {
-                return isMapMatch(target, source);
-            }
-            if (source instanceof Set) {
-                return isSetMatch(target, source);
-            }
-            for (let i = 0; i < keys.length; i++) {
-                const key = keys[i];
-                if (!isTypedArray$1.isPrimitive(target) && !(key in target)) {
-                    return false;
-                }
-                if (source[key] === undefined && target[key] !== undefined) {
-                    return false;
-                }
-                if (!isMatch(target[key], source[key])) {
-                    return false;
-                }
-            }
-            return true;
-        }
-        case 'function': {
-            if (Object.keys(source).length > 0) {
-                return isMatch(target, { ...source });
-            }
-            return false;
-        }
-        default: {
-            return !source;
-        }
-    }
-}
-
-function matches(source) {
-    source = toMerged.cloneDeep(source);
-    return (target) => {
-        return isMatch(target, source);
-    };
-}
-
 const startsWith = (str, target, position = 0) => {
     return str.startsWith(target, position);
 };
@@ -800,6 +852,7 @@ exports.concat = concat;
 exports.difference = difference;
 exports.endsWith = endsWith;
 exports.fill = fill;
+exports.find = find;
 exports.flatten = flatten;
 exports.flattenDeep = flattenDeep;
 exports.flattenDepth = flattenDepth;
@@ -816,6 +869,7 @@ exports.isTypedArray = isTypedArray;
 exports.mapKeys = mapKeys;
 exports.mapValues = mapValues;
 exports.matches = matches;
+exports.matchesProperty = matchesProperty;
 exports.max = max;
 exports.merge = merge;
 exports.mergeWith = mergeWith;

package/dist/compat/index.mjs

@@ -97,6 +97,7 @@ export { chunk } from './array/chunk.mjs';
 export { concat } from './array/concat.mjs';
 export { difference } from './array/difference.mjs';
 export { fill } from './array/fill.mjs';
+export { find } from './array/find.mjs';
 export { flatten } from './array/flatten.mjs';
 export { flattenDeep } from './array/flattenDeep.mjs';
 export { flattenDepth } from './array/flattenDepth.mjs';
@@ -122,6 +123,7 @@ export { isBoolean } from './predicate/isBoolean.mjs';
 export { isTypedArray } from './predicate/isTypedArray.mjs';
 export { isMatch } from './predicate/isMatch.mjs';
 export { matches } from './predicate/matches.mjs';
+export { matchesProperty } from './predicate/matchesProperty.mjs';
 export { startsWith } from './string/startsWith.mjs';
 export { endsWith } from './string/endsWith.mjs';
 export { padStart } from './string/padStart.mjs';

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

@@ -0,0 +1,28 @@
+/**
+ * Creates a function that checks if a given target object matches a specific property value.
+ *
+ * The returned function takes a target object and determines if the property at the
+ * specified path within the target object is equal to the given value.
+ *
+ * @param {PropertyKey | PropertyKey[]} property - The property path to check within the target object.
+ *     This can be a single property key or an array of property keys.
+ * @param {unknown} source - The value to compare against the property value in the target object.
+ *
+ * @returns {(target: unknown) => boolean} - A function that takes a target object and returns
+ *     `true` if the property value at the given path in the target object matches the provided value,
+ *     otherwise returns `false`.
+ *
+ * @example
+ * // Using a single property key
+ * const checkName = matchesProperty('name', 'Alice');
+ * console.log(checkName({ name: 'Alice' })); // true
+ * console.log(checkName({ name: 'Bob' })); // false
+ *
+ * // Using an array of property keys
+ * const checkNested = matchesProperty(['address', 'city'], 'New York');
+ * console.log(checkNested({ address: { city: 'New York' } })); // true
+ * console.log(checkNested({ address: { city: 'Los Angeles' } })); // false
+ */
+declare function matchesProperty(property: PropertyKey | readonly PropertyKey[], source: unknown): (target?: unknown) => boolean;
+
+export { matchesProperty };