es-toolkit 1.35.0-dev.1198 → 1.35.0-dev.1200

package/dist/compat/index.d.mts

@@ -184,7 +184,10 @@ export { cloneDeepWith } from './object/cloneDeepWith.mjs';
 export { create } from './object/create.mjs';
 export { defaults } from './object/defaults.mjs';
 export { findKey } from './object/findKey.mjs';
+export { forIn } from './object/forIn.mjs';
+export { forInRight } from './object/forInRight.mjs';
 export { forOwn } from './object/forOwn.mjs';
+export { forOwnRight } from './object/forOwnRight.mjs';
 export { fromPairs } from './object/fromPairs.mjs';
 export { functions } from './object/functions.mjs';
 export { functionsIn } from './object/functionsIn.mjs';

package/dist/compat/index.d.ts

@@ -184,7 +184,10 @@ export { cloneDeepWith } from './object/cloneDeepWith.js';
 export { create } from './object/create.js';
 export { defaults } from './object/defaults.js';
 export { findKey } from './object/findKey.js';
+export { forIn } from './object/forIn.js';
+export { forInRight } from './object/forInRight.js';
 export { forOwn } from './object/forOwn.js';
+export { forOwnRight } from './object/forOwnRight.js';
 export { fromPairs } from './object/fromPairs.js';
 export { functions } from './object/functions.js';
 export { functionsIn } from './object/functionsIn.js';

package/dist/compat/index.js

@@ -2679,6 +2679,37 @@ function findKeyImpl(obj, predicate) {
     }
 }
 
+function forIn(object, iteratee = unary.identity) {
+    if (object == null) {
+        return object;
+    }
+    for (const key in object) {
+        const result = iteratee(object[key], key, object);
+        if (result === false) {
+            break;
+        }
+    }
+    return object;
+}
+
+function forInRight(object, iteratee = unary.identity) {
+    if (object == null) {
+        return object;
+    }
+    const keys = [];
+    for (const key in object) {
+        keys.push(key);
+    }
+    for (let i = keys.length - 1; i >= 0; i--) {
+        const key = keys[i];
+        const result = iteratee(object[key], key, object);
+        if (result === false) {
+            break;
+        }
+    }
+    return object;
+}
+
 function forOwn(object, iteratee = unary.identity) {
     if (object == null) {
         return object;
@@ -2694,6 +2725,21 @@ function forOwn(object, iteratee = unary.identity) {
     return object;
 }
 
+function forOwnRight(object, iteratee = unary.identity) {
+    if (object == null) {
+        return object;
+    }
+    const iterable = Object(object);
+    const keys$1 = keys(object);
+    for (let i = keys$1.length - 1; i >= 0; --i) {
+        const key = keys$1[i];
+        if (iteratee(iterable[key], key, iterable) === false) {
+            break;
+        }
+    }
+    return object;
+}
+
 function fromPairs(pairs) {
     if (!isArrayLike(pairs) && !(pairs instanceof Map)) {
         return {};
@@ -3842,7 +3888,10 @@ exports.floor = floor;
 exports.flow = flow;
 exports.flowRight = flowRight;
 exports.forEach = forEach;
+exports.forIn = forIn;
+exports.forInRight = forInRight;
 exports.forOwn = forOwn;
+exports.forOwnRight = forOwnRight;
 exports.fromPairs = fromPairs;
 exports.functions = functions;
 exports.functionsIn = functionsIn;

package/dist/compat/index.mjs

@@ -186,7 +186,10 @@ export { cloneDeepWith } from './object/cloneDeepWith.mjs';
 export { create } from './object/create.mjs';
 export { defaults } from './object/defaults.mjs';
 export { findKey } from './object/findKey.mjs';
+export { forIn } from './object/forIn.mjs';
+export { forInRight } from './object/forInRight.mjs';
 export { forOwn } from './object/forOwn.mjs';
+export { forOwnRight } from './object/forOwnRight.mjs';
 export { fromPairs } from './object/fromPairs.mjs';
 export { functions } from './object/functions.mjs';
 export { functionsIn } from './object/functionsIn.mjs';

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

@@ -0,0 +1,58 @@
+/**
+ * Iterates over an object and invokes the `iteratee` function for each property.
+ *
+ * Iterates over string keyed properties including inherited properties.
+ *
+ * The iteration is terminated early if the `iteratee` function returns `false`.
+ *
+ * @template T - The type of the object
+ * @param {T} object - The object to iterate over
+ * @param {(value: T[keyof T], key: string, obj: T) => any} iteratee - The function invoked per iteration
+ * @returns {T} Returns the object
+ *
+ * @example
+ * // Iterate over all properties including inherited ones
+ * const obj = { a: 1, b: 2 };
+ * forIn(obj, (value, key) => {
+ *   console.log(key, value);
+ * });
+ * // Output: 'a' 1, 'b' 2
+ *
+ * // Early termination
+ * forIn(obj, (value, key) => {
+ *   console.log(key, value);
+ *   return key !== 'a'; // stop after 'a'
+ * });
+ * // Output: 'a' 1
+ */
+declare function forIn<T>(object: T, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T;
+/**
+ * Iterates over an object and invokes the `iteratee` function for each property.
+ *
+ * Iterates over string keyed properties including inherited properties.
+ *
+ * The iteration is terminated early if the `iteratee` function returns `false`.
+ *
+ * @template T - The type of the object
+ * @param {T | null | undefined} object - The object to iterate over
+ * @param {(value: T[keyof T], key: string, obj: T) => any} iteratee - The function invoked per iteration
+ * @returns {T | null | undefined} Returns the object
+ *
+ * @example
+ * // Iterate over all properties including inherited ones
+ * const obj = { a: 1, b: 2 };
+ * forIn(obj, (value, key) => {
+ *   console.log(key, value);
+ * });
+ * // Output: 'a' 1, 'b' 2
+ *
+ * // Early termination
+ * forIn(obj, (value, key) => {
+ *   console.log(key, value);
+ *   return key !== 'a'; // stop after 'a'
+ * });
+ * // Output: 'a' 1
+ */
+declare function forIn<T>(object: T | null | undefined, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T | null | undefined;
+
+export { forIn };

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

@@ -0,0 +1,58 @@
+/**
+ * Iterates over an object and invokes the `iteratee` function for each property.
+ *
+ * Iterates over string keyed properties including inherited properties.
+ *
+ * The iteration is terminated early if the `iteratee` function returns `false`.
+ *
+ * @template T - The type of the object
+ * @param {T} object - The object to iterate over
+ * @param {(value: T[keyof T], key: string, obj: T) => any} iteratee - The function invoked per iteration
+ * @returns {T} Returns the object
+ *
+ * @example
+ * // Iterate over all properties including inherited ones
+ * const obj = { a: 1, b: 2 };
+ * forIn(obj, (value, key) => {
+ *   console.log(key, value);
+ * });
+ * // Output: 'a' 1, 'b' 2
+ *
+ * // Early termination
+ * forIn(obj, (value, key) => {
+ *   console.log(key, value);
+ *   return key !== 'a'; // stop after 'a'
+ * });
+ * // Output: 'a' 1
+ */
+declare function forIn<T>(object: T, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T;
+/**
+ * Iterates over an object and invokes the `iteratee` function for each property.
+ *
+ * Iterates over string keyed properties including inherited properties.
+ *
+ * The iteration is terminated early if the `iteratee` function returns `false`.
+ *
+ * @template T - The type of the object
+ * @param {T | null | undefined} object - The object to iterate over
+ * @param {(value: T[keyof T], key: string, obj: T) => any} iteratee - The function invoked per iteration
+ * @returns {T | null | undefined} Returns the object
+ *
+ * @example
+ * // Iterate over all properties including inherited ones
+ * const obj = { a: 1, b: 2 };
+ * forIn(obj, (value, key) => {
+ *   console.log(key, value);
+ * });
+ * // Output: 'a' 1, 'b' 2
+ *
+ * // Early termination
+ * forIn(obj, (value, key) => {
+ *   console.log(key, value);
+ *   return key !== 'a'; // stop after 'a'
+ * });
+ * // Output: 'a' 1
+ */
+declare function forIn<T>(object: T | null | undefined, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T | null | undefined;
+
+export { forIn };

package/dist/compat/object/forIn.mjs

@@ -0,0 +1,16 @@
+import { identity } from '../../function/identity.mjs';
+
+function forIn(object, iteratee = identity) {
+    if (object == null) {
+        return object;
+    }
+    for (const key in object) {
+        const result = iteratee(object[key], key, object);
+        if (result === false) {
+            break;
+        }
+    }
+    return object;
+}
+
+export { forIn };

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

@@ -0,0 +1,58 @@
+/**
+ * Iterates over an object in reverse order and invokes the `iteratee` function for each property.
+ *
+ * Iterates over string keyed properties including inherited properties in reverse order.
+ *
+ * The iteration is terminated early if the `iteratee` function returns `false`.
+ *
+ * @template T - The type of the object
+ * @param {T} object - The object to iterate over
+ * @param {(value: T[keyof T], key: string, collection: T) => any} iteratee - The function invoked per iteration
+ * @returns {T} Returns the object
+ *
+ * @example
+ * // Iterate over all properties including inherited ones
+ * const obj = { a: 1, b: 2 };
+ * forInRight(obj, (value, key) => {
+ *   console.log(key, value);
+ * });
+ * // Output: 'b' 2, 'a' 1
+ *
+ * // Early termination
+ * forInRight(obj, (value, key) => {
+ *   console.log(key, value);
+ *   return key !== 'a'; // stop after 'a'
+ * });
+ * // Output: 'b' 2
+ */
+declare function forInRight<T>(object: T, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T;
+/**
+ * Iterates over an object in reverse order and invokes the `iteratee` function for each property.
+ *
+ * Iterates over string keyed properties including inherited properties in reverse order.
+ *
+ * The iteration is terminated early if the `iteratee` function returns `false`.
+ *
+ * @template T - The type of the object
+ * @param {T | null | undefined} object - The object to iterate over
+ * @param {(value: T[keyof T], key: string, obj: T) => any} iteratee - The function invoked per iteration
+ * @returns {T | null | undefined} Returns the object
+ *
+ * @example
+ * // Iterate over all properties including inherited ones
+ * const obj = { a: 1, b: 2 };
+ * forInRight(obj, (value, key) => {
+ *   console.log(key, value);
+ * });
+ * // Output: 'b' 2, 'a' 1
+ *
+ * // Early termination
+ * forInRight(obj, (value, key) => {
+ *   console.log(key, value);
+ *   return key !== 'a'; // stop after 'a'
+ * });
+ * // Output: 'b' 2
+ */
+declare function forInRight<T>(object: T | null | undefined, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T | null | undefined;
+
+export { forInRight };

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

@@ -0,0 +1,58 @@
+/**
+ * Iterates over an object in reverse order and invokes the `iteratee` function for each property.
+ *
+ * Iterates over string keyed properties including inherited properties in reverse order.
+ *
+ * The iteration is terminated early if the `iteratee` function returns `false`.
+ *
+ * @template T - The type of the object
+ * @param {T} object - The object to iterate over
+ * @param {(value: T[keyof T], key: string, collection: T) => any} iteratee - The function invoked per iteration
+ * @returns {T} Returns the object
+ *
+ * @example
+ * // Iterate over all properties including inherited ones
+ * const obj = { a: 1, b: 2 };
+ * forInRight(obj, (value, key) => {
+ *   console.log(key, value);
+ * });
+ * // Output: 'b' 2, 'a' 1
+ *
+ * // Early termination
+ * forInRight(obj, (value, key) => {
+ *   console.log(key, value);
+ *   return key !== 'a'; // stop after 'a'
+ * });
+ * // Output: 'b' 2
+ */
+declare function forInRight<T>(object: T, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T;
+/**
+ * Iterates over an object in reverse order and invokes the `iteratee` function for each property.
+ *
+ * Iterates over string keyed properties including inherited properties in reverse order.
+ *
+ * The iteration is terminated early if the `iteratee` function returns `false`.
+ *
+ * @template T - The type of the object
+ * @param {T | null | undefined} object - The object to iterate over
+ * @param {(value: T[keyof T], key: string, obj: T) => any} iteratee - The function invoked per iteration
+ * @returns {T | null | undefined} Returns the object
+ *
+ * @example
+ * // Iterate over all properties including inherited ones
+ * const obj = { a: 1, b: 2 };
+ * forInRight(obj, (value, key) => {
+ *   console.log(key, value);
+ * });
+ * // Output: 'b' 2, 'a' 1
+ *
+ * // Early termination
+ * forInRight(obj, (value, key) => {
+ *   console.log(key, value);
+ *   return key !== 'a'; // stop after 'a'
+ * });
+ * // Output: 'b' 2
+ */
+declare function forInRight<T>(object: T | null | undefined, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T | null | undefined;
+
+export { forInRight };

package/dist/compat/object/forInRight.mjs

@@ -0,0 +1,21 @@
+import { identity } from '../../function/identity.mjs';
+
+function forInRight(object, iteratee = identity) {
+    if (object == null) {
+        return object;
+    }
+    const keys = [];
+    for (const key in object) {
+        keys.push(key);
+    }
+    for (let i = keys.length - 1; i >= 0; i--) {
+        const key = keys[i];
+        const result = iteratee(object[key], key, object);
+        if (result === false) {
+            break;
+        }
+    }
+    return object;
+}
+
+export { forInRight };

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

@@ -0,0 +1,54 @@
+/**
+ * Iterates over an object's properties in reverse order and calls the `iteratee` function for each property.
+ *
+ * It only iterates over the object's own properties, not including inherited properties or properties with `Symbol` keys.
+ *
+ * The `iteratee` function can terminate the iteration early by returning `false`.
+ *
+ * @template T - The type of the object.
+ * @param {T} object The object to iterate over.
+ * @param {(value: T[keyof T], key: string, collection: T) => any} [iteratee=identity] The function invoked per iteration. If not provided, the identity function will be used.
+ * @return {T} Returns object.
+ *
+ * @example
+ * function Foo() {
+ *   this.a = 1;
+ *   this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * forOwnRight(new Foo(), function(value, key) {
+ *   console.log(key);
+ * });
+ * // => Logs 'b' then 'a' (iteration order is not guaranteed).
+ */
+declare function forOwnRight<T>(object: T, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T;
+/**
+ * Iterates over an object's properties in reverse order and calls the `iteratee` function for each property.
+ *
+ * It only iterates over the object's own properties, not including inherited properties or properties with `Symbol` keys.
+ *
+ * The `iteratee` function can terminate the iteration early by returning `false`.
+ *
+ * @template T - The type of the object.
+ * @param {T | null | undefined} object The object to iterate over.
+ * @param {(value: T[keyof T], key: string, collection: T) => any} [iteratee=identity] The function invoked per iteration. If not provided, the identity function will be used.
+ * @return {T | null | undefined} Returns object.
+ *
+ * @example
+ * function Foo() {
+ *   this.a = 1;
+ *   this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * forOwnRight(new Foo(), function(value, key) {
+ *   console.log(key);
+ * });
+ * // => Logs 'b' then 'a' (iteration order is not guaranteed).
+ */
+declare function forOwnRight<T>(object: T | null | undefined, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T | null | undefined;
+
+export { forOwnRight };

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

@@ -0,0 +1,54 @@
+/**
+ * Iterates over an object's properties in reverse order and calls the `iteratee` function for each property.
+ *
+ * It only iterates over the object's own properties, not including inherited properties or properties with `Symbol` keys.
+ *
+ * The `iteratee` function can terminate the iteration early by returning `false`.
+ *
+ * @template T - The type of the object.
+ * @param {T} object The object to iterate over.
+ * @param {(value: T[keyof T], key: string, collection: T) => any} [iteratee=identity] The function invoked per iteration. If not provided, the identity function will be used.
+ * @return {T} Returns object.
+ *
+ * @example
+ * function Foo() {
+ *   this.a = 1;
+ *   this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * forOwnRight(new Foo(), function(value, key) {
+ *   console.log(key);
+ * });
+ * // => Logs 'b' then 'a' (iteration order is not guaranteed).
+ */
+declare function forOwnRight<T>(object: T, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T;
+/**
+ * Iterates over an object's properties in reverse order and calls the `iteratee` function for each property.
+ *
+ * It only iterates over the object's own properties, not including inherited properties or properties with `Symbol` keys.
+ *
+ * The `iteratee` function can terminate the iteration early by returning `false`.
+ *
+ * @template T - The type of the object.
+ * @param {T | null | undefined} object The object to iterate over.
+ * @param {(value: T[keyof T], key: string, collection: T) => any} [iteratee=identity] The function invoked per iteration. If not provided, the identity function will be used.
+ * @return {T | null | undefined} Returns object.
+ *
+ * @example
+ * function Foo() {
+ *   this.a = 1;
+ *   this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * forOwnRight(new Foo(), function(value, key) {
+ *   console.log(key);
+ * });
+ * // => Logs 'b' then 'a' (iteration order is not guaranteed).
+ */
+declare function forOwnRight<T>(object: T | null | undefined, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T | null | undefined;
+
+export { forOwnRight };

package/dist/compat/object/forOwnRight.mjs

@@ -0,0 +1,19 @@
+import { keys } from './keys.mjs';
+import { identity } from '../../function/identity.mjs';
+
+function forOwnRight(object, iteratee = identity) {
+    if (object == null) {
+        return object;
+    }
+    const iterable = Object(object);
+    const keys$1 = keys(object);
+    for (let i = keys$1.length - 1; i >= 0; --i) {
+        const key = keys$1[i];
+        if (iteratee(iterable[key], key, iterable) === false) {
+            break;
+        }
+    }
+    return object;
+}
+
+export { forOwnRight };

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.1198+ef135315",
+  "version": "1.35.0-dev.1200+f49fd5b4",
   "homepage": "https://es-toolkit.slash.page",
   "bugs": "https://github.com/toss/es-toolkit/issues",
   "repository": {