es-toolkit 1.35.0-dev.1184 → 1.35.0-dev.1185

package/dist/compat/index.d.mts

@@ -190,6 +190,7 @@ export { functions } from './object/functions.mjs';
 export { functionsIn } from './object/functionsIn.mjs';
 export { get } from './object/get.mjs';
 export { has } from './object/has.mjs';
+export { hasIn } from './object/hasIn.mjs';
 export { invertBy } from './object/invertBy.mjs';
 export { keys } from './object/keys.mjs';
 export { keysIn } from './object/keysIn.mjs';

package/dist/compat/index.d.ts

@@ -190,6 +190,7 @@ export { functions } from './object/functions.js';
 export { functionsIn } from './object/functionsIn.js';
 export { get } from './object/get.js';
 export { has } from './object/has.js';
+export { hasIn } from './object/hasIn.js';
 export { invertBy } from './object/invertBy.js';
 export { keys } from './object/keys.js';
 export { keysIn } from './object/keysIn.js';

package/dist/compat/index.js

@@ -2726,6 +2726,34 @@ function functionsIn(object) {
     return result;
 }
 
+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;
+}
+
 function invertBy(object, iteratee) {
     const result = {};
     if (isPromise.isNil(object)) {
@@ -3803,6 +3831,7 @@ exports.get = get;
 exports.gt = gt;
 exports.gte = gte;
 exports.has = has;
+exports.hasIn = hasIn;
 exports.head = head;
 exports.inRange = inRange;
 exports.includes = includes;

package/dist/compat/index.mjs

@@ -192,6 +192,7 @@ export { functions } from './object/functions.mjs';
 export { functionsIn } from './object/functionsIn.mjs';
 export { get } from './object/get.mjs';
 export { has } from './object/has.mjs';
+export { hasIn } from './object/hasIn.mjs';
 export { invertBy } from './object/invertBy.mjs';
 export { keys } from './object/keys.mjs';
 export { keysIn } from './object/keysIn.mjs';

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/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.35.0-dev.1184+470acc29",
+  "version": "1.35.0-dev.1185+b4f5e529",
   "homepage": "https://es-toolkit.slash.page",
   "bugs": "https://github.com/toss/es-toolkit/issues",
   "repository": {