es-toolkit 1.35.0-dev.1174 → 1.35.0-dev.1176

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

@@ -1,121 +1,65 @@
 /**
  * Creates an array of elements split into two groups, the first of which contains elements
  * `predicate` returns truthy for, the second of which contains elements
- * `predicate` returns falsy for.
+ * `predicate` returns falsy for. The predicate is invoked with one argument: (value).
  *
  * @template T
- * @param {ArrayLike<T> | null | undefined} arr - The array to iterate over.
- * @param {(item: T, index: number, arr: readonly T[]) => unknown} doesMatch - The function invoked per iteration.
- * @returns {[T[], T[]]} - Returns the array of grouped elements.
+ * @template U
+ * @param {ArrayLike<T> | T | null | undefined} source - The array or object to iterate over.
+ * @param {(value: T) => value is U} predicate - The function invoked per iteration.
+ * @returns {[U[], Array<Exclude<T, U>>]} - Returns the array of grouped elements.
  *
  * @example
- * partition([1, 2, 3], n => n % 2 === 0)
- * // => [[2], [1, 3]]
- */
-declare function partition<T>(arr: ArrayLike<T> | null | undefined, doesMatch?: (item: T, index: number, arr: readonly T[]) => unknown): [T[], T[]];
-/**
- * Creates an array of elements split into two groups based on the properties of the given partial object.
+ * partition([1, 2, 3, 4], n => n % 2 === 0);
+ * // => [[2, 4], [1, 3]]
  *
- * @template T
- * @param {ArrayLike<T> | null | undefined} arr - The array to iterate over.
- * @param {Partial<T>} doesMatch - A partial object that specifies the properties to match.
- * @returns {[T[], T[]]} - Returns the array of grouped elements.
+ * partition([1, 2, 3, 4], 'a');
+ * // => [[2, 4], [1, 3]]
  *
- * @example
- * const arr = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
- * partition(arr, { name: 'Bob' });
- * // => [[{ id: 2, name: 'Bob' }], [{ id: 1, name: 'Alice' }]]
+ * partition([1, 2, 3, 4], ['a', 2]);
  */
-declare function partition<T>(arr: ArrayLike<T> | null | undefined, doesMatch: Partial<T>): [T[], T[]];
-/**
- * Creates an array of elements split into two groups based on the given key-value pair.
- *
- * @template T
- * @param {ArrayLike<T> | null | undefined} arr - The array to iterate over.
- * @param {[keyof T, unknown]} doesMatchProperty - The key-value pair to match.
- * @returns {[T[], T[]]} - Returns the array of grouped elements.
- *
- * @example
- * const arr = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
- * partition(arr, ['name', 'Alice']);
- * // => [[{ id: 1, name: 'Alice' }], [{ id: 2, name: 'Bob' }]]
- */
-declare function partition<T>(arr: ArrayLike<T> | null | undefined, doesMatchProperty: [keyof T, unknown]): [T[], T[]];
+declare function partition<T, U extends T>(source: ArrayLike<T> | null | undefined, predicate: (value: T) => value is U): [U[], Array<Exclude<T, U>>];
 /**
  * Creates an array of elements split into two groups, the first of which contains elements
- * that have the given property name, the second of which contains elements that don't.
- *
- * @template T
- * @param {ArrayLike<T> | null | undefined} arr - The array to iterate over.
- * @param {PropertyKey} propertyToCheck - The property name to check.
- * @returns {[T[], T[]]} - Returns the array of grouped elements.
- *
- * @example
- * const arr = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }, { id: 3, age: 28 }];
- * partition(arr, 'name');
- * // => [[{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }], [{ id: 3, age: 28 }]]
- */
-declare function partition<T>(arr: ArrayLike<T> | null | undefined, propertyToCheck: PropertyKey): [T[], T[]];
-/**
- * Creates an array of elements split into two groups based on the predicate function.
+ * `predicate` returns truthy for, the second of which contains elements
+ * `predicate` returns falsy for. The predicate is invoked with one argument: (value).
  *
  * @template T
- * @param {T | null | undefined} object - The object to iterate over.
- * @param {(value: T[keyof T], key: keyof T, object: T) => unknown} doesMatch - The function invoked per iteration.
+ * @param {ArrayLike<T> | T | null | undefined} source - The array or object to iterate over.
+ * @param {((item: T, index: number, arr: any) => unknown) | Partial<T> | [keyof T, unknown] | PropertyKey} [predicate=identity] - The function invoked per iteration.
  * @returns {[T[], T[]]} - Returns the array of grouped elements.
  *
  * @example
- * const obj = { item1: { a: 0 }, item2: { a: 1 }, item3: { a: 0 } }
- * partition(obj, value => value.a)
- * // => [[{ a: 1 }], [{ a: 0 }, { a: 0 }]]
- *
- * const obj = { a: 1, b: 2, c: 3 };
- * partition(obj, value => value > 2)
- * // => [[3], [1, 2]]
- */
-declare function partition<T extends Record<string, unknown>>(object: T | null | undefined, doesMatch: (value: T[keyof T], key: keyof T, object: T) => unknown): [T[], T[]];
-/**
- * Creates an array of elements split into two groups based on the properties of the given partial object.
+ * partition([1, 2, 3, 4], n => n % 2 === 0);
+ * // => [[2, 4], [1, 3]]
  *
- * @template T
- * @param {T | null | undefined} object - The object to iterate over.
- * @param {Partial<T[keyof T]>} doesMatch - The partial object to match
- * @returns {[T[], T[]]} - Returns the array of grouped elements.
+ * partition([1, 2, 3, 4], 'a');
+ * // => [[2, 4], [1, 3]]
  *
- * @example
- * const obj = { a: { id: 1, name: 'Alice' }, b: { id: 2, name: 'Bob' } };
- * partition(obj, { name: 'Bob' });
- * // => [[{ id: 2, name: 'Bob' }], [{ id: 1, name: 'Alice' }]]
+ * partition([1, 2, 3, 4], ['a', 2]);
+ * // => [[2], [1, 3, 4]]
  */
-declare function partition<T extends Record<string, unknown>>(object: T | null | undefined, doesMatch: Partial<T[keyof T]>): [T[], T[]];
+declare function partition<T>(source: ArrayLike<T> | null | undefined, predicate?: ((value: T) => unknown) | PropertyKey | [PropertyKey, any] | Partial<T>): [T[], T[]];
 /**
- * Creates an array of elements split into two groups based on the given key-value pair.
+ * Creates an array of elements split into two groups, the first of which contains elements
+ * `predicate` returns truthy for, the second of which contains elements
+ * `predicate` returns falsy for. The predicate is invoked with one argument: (value).
  *
  * @template T
  * @param {T | null | undefined} object - The object to iterate over.
- * @param {[keyof T[keyof T], unknown]} doesMatchProperty - The key-value pair to match.
- * @returns {[T[], T[]]} - Returns the array of grouped elements.
+ * @param {((item: T[keyof T], key: keyof T) => unknown) | Partial<T[keyof T]> | [keyof T, unknown] | PropertyKey} [predicate=identity] - The function invoked per iteration.
+ * @returns {[T[keyof T][], T[keyof T][]]} - Returns the array of grouped elements.
  *
  * @example
- * const obj = { alice: { id: 1, name: 'Alice' }, bob: { id: 2, name: 'Bob' } };
- * partition(obj, ['name', 'Alice']);
- * // => [[{ id: 1, name: 'Alice' }], [{ id: 2, name: 'Bob' }]]
- */
-declare function partition<T extends Record<string, unknown>>(object: T | null | undefined, doesMatchProperty: [keyof T[keyof T], unknown]): [T[], T[]];
-/**
- * Creates an array of elements split into two groups, the first of which contains elements
- * that have the given property name, the second of which contains elements that don't.
+ * partition({ a: 1, b: 2, c: 3 }, n => n % 2 === 0);
+ * // => [[2], [1, 3]]
  *
- * @template T
- * @param {T | null | undefined} object - The object to iterate over.
- * @param {PropertyKey} propertyToCheck - The property name to check.
- * @returns {[T[], T[]]} - Returns the array of grouped elements.
+ * partition({ a: 1, b: 2, c: 3 }, 'a');
+ * // => [[1], [2, 3]]
  *
- * @example
- * const obj = { a: { id: 1, name: 'Alice' }, b: { id: 2, name: 'Bob' }, c: { id: 3, age: 28 } };
- * partition(obj, 'name');
- * // => [[{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }], [{ id: 3, age: 28 }]]
+ * partition({ a: 1, b: 2, c: 3 }, ['a', 1]);
+ * // => [[1], [2, 3]]
  */
-declare function partition<T extends Record<string, unknown>>(object: T | null | undefined, propertyToCheck: PropertyKey): [T[], T[]];
+declare function partition<T extends object>(object: T | null | undefined, predicate?: ((value: T[keyof T]) => unknown) | PropertyKey | [PropertyKey, any] | Partial<T[keyof T]>): [Array<T[keyof T]>, Array<T[keyof T]>];
 
 export { partition };

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

@@ -1,121 +1,65 @@
 /**
  * Creates an array of elements split into two groups, the first of which contains elements
  * `predicate` returns truthy for, the second of which contains elements
- * `predicate` returns falsy for.
+ * `predicate` returns falsy for. The predicate is invoked with one argument: (value).
  *
  * @template T
- * @param {ArrayLike<T> | null | undefined} arr - The array to iterate over.
- * @param {(item: T, index: number, arr: readonly T[]) => unknown} doesMatch - The function invoked per iteration.
- * @returns {[T[], T[]]} - Returns the array of grouped elements.
+ * @template U
+ * @param {ArrayLike<T> | T | null | undefined} source - The array or object to iterate over.
+ * @param {(value: T) => value is U} predicate - The function invoked per iteration.
+ * @returns {[U[], Array<Exclude<T, U>>]} - Returns the array of grouped elements.
  *
  * @example
- * partition([1, 2, 3], n => n % 2 === 0)
- * // => [[2], [1, 3]]
- */
-declare function partition<T>(arr: ArrayLike<T> | null | undefined, doesMatch?: (item: T, index: number, arr: readonly T[]) => unknown): [T[], T[]];
-/**
- * Creates an array of elements split into two groups based on the properties of the given partial object.
+ * partition([1, 2, 3, 4], n => n % 2 === 0);
+ * // => [[2, 4], [1, 3]]
  *
- * @template T
- * @param {ArrayLike<T> | null | undefined} arr - The array to iterate over.
- * @param {Partial<T>} doesMatch - A partial object that specifies the properties to match.
- * @returns {[T[], T[]]} - Returns the array of grouped elements.
+ * partition([1, 2, 3, 4], 'a');
+ * // => [[2, 4], [1, 3]]
  *
- * @example
- * const arr = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
- * partition(arr, { name: 'Bob' });
- * // => [[{ id: 2, name: 'Bob' }], [{ id: 1, name: 'Alice' }]]
+ * partition([1, 2, 3, 4], ['a', 2]);
  */
-declare function partition<T>(arr: ArrayLike<T> | null | undefined, doesMatch: Partial<T>): [T[], T[]];
-/**
- * Creates an array of elements split into two groups based on the given key-value pair.
- *
- * @template T
- * @param {ArrayLike<T> | null | undefined} arr - The array to iterate over.
- * @param {[keyof T, unknown]} doesMatchProperty - The key-value pair to match.
- * @returns {[T[], T[]]} - Returns the array of grouped elements.
- *
- * @example
- * const arr = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
- * partition(arr, ['name', 'Alice']);
- * // => [[{ id: 1, name: 'Alice' }], [{ id: 2, name: 'Bob' }]]
- */
-declare function partition<T>(arr: ArrayLike<T> | null | undefined, doesMatchProperty: [keyof T, unknown]): [T[], T[]];
+declare function partition<T, U extends T>(source: ArrayLike<T> | null | undefined, predicate: (value: T) => value is U): [U[], Array<Exclude<T, U>>];
 /**
  * Creates an array of elements split into two groups, the first of which contains elements
- * that have the given property name, the second of which contains elements that don't.
- *
- * @template T
- * @param {ArrayLike<T> | null | undefined} arr - The array to iterate over.
- * @param {PropertyKey} propertyToCheck - The property name to check.
- * @returns {[T[], T[]]} - Returns the array of grouped elements.
- *
- * @example
- * const arr = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }, { id: 3, age: 28 }];
- * partition(arr, 'name');
- * // => [[{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }], [{ id: 3, age: 28 }]]
- */
-declare function partition<T>(arr: ArrayLike<T> | null | undefined, propertyToCheck: PropertyKey): [T[], T[]];
-/**
- * Creates an array of elements split into two groups based on the predicate function.
+ * `predicate` returns truthy for, the second of which contains elements
+ * `predicate` returns falsy for. The predicate is invoked with one argument: (value).
  *
  * @template T
- * @param {T | null | undefined} object - The object to iterate over.
- * @param {(value: T[keyof T], key: keyof T, object: T) => unknown} doesMatch - The function invoked per iteration.
+ * @param {ArrayLike<T> | T | null | undefined} source - The array or object to iterate over.
+ * @param {((item: T, index: number, arr: any) => unknown) | Partial<T> | [keyof T, unknown] | PropertyKey} [predicate=identity] - The function invoked per iteration.
  * @returns {[T[], T[]]} - Returns the array of grouped elements.
  *
  * @example
- * const obj = { item1: { a: 0 }, item2: { a: 1 }, item3: { a: 0 } }
- * partition(obj, value => value.a)
- * // => [[{ a: 1 }], [{ a: 0 }, { a: 0 }]]
- *
- * const obj = { a: 1, b: 2, c: 3 };
- * partition(obj, value => value > 2)
- * // => [[3], [1, 2]]
- */
-declare function partition<T extends Record<string, unknown>>(object: T | null | undefined, doesMatch: (value: T[keyof T], key: keyof T, object: T) => unknown): [T[], T[]];
-/**
- * Creates an array of elements split into two groups based on the properties of the given partial object.
+ * partition([1, 2, 3, 4], n => n % 2 === 0);
+ * // => [[2, 4], [1, 3]]
  *
- * @template T
- * @param {T | null | undefined} object - The object to iterate over.
- * @param {Partial<T[keyof T]>} doesMatch - The partial object to match
- * @returns {[T[], T[]]} - Returns the array of grouped elements.
+ * partition([1, 2, 3, 4], 'a');
+ * // => [[2, 4], [1, 3]]
  *
- * @example
- * const obj = { a: { id: 1, name: 'Alice' }, b: { id: 2, name: 'Bob' } };
- * partition(obj, { name: 'Bob' });
- * // => [[{ id: 2, name: 'Bob' }], [{ id: 1, name: 'Alice' }]]
+ * partition([1, 2, 3, 4], ['a', 2]);
+ * // => [[2], [1, 3, 4]]
  */
-declare function partition<T extends Record<string, unknown>>(object: T | null | undefined, doesMatch: Partial<T[keyof T]>): [T[], T[]];
+declare function partition<T>(source: ArrayLike<T> | null | undefined, predicate?: ((value: T) => unknown) | PropertyKey | [PropertyKey, any] | Partial<T>): [T[], T[]];
 /**
- * Creates an array of elements split into two groups based on the given key-value pair.
+ * Creates an array of elements split into two groups, the first of which contains elements
+ * `predicate` returns truthy for, the second of which contains elements
+ * `predicate` returns falsy for. The predicate is invoked with one argument: (value).
  *
  * @template T
  * @param {T | null | undefined} object - The object to iterate over.
- * @param {[keyof T[keyof T], unknown]} doesMatchProperty - The key-value pair to match.
- * @returns {[T[], T[]]} - Returns the array of grouped elements.
+ * @param {((item: T[keyof T], key: keyof T) => unknown) | Partial<T[keyof T]> | [keyof T, unknown] | PropertyKey} [predicate=identity] - The function invoked per iteration.
+ * @returns {[T[keyof T][], T[keyof T][]]} - Returns the array of grouped elements.
  *
  * @example
- * const obj = { alice: { id: 1, name: 'Alice' }, bob: { id: 2, name: 'Bob' } };
- * partition(obj, ['name', 'Alice']);
- * // => [[{ id: 1, name: 'Alice' }], [{ id: 2, name: 'Bob' }]]
- */
-declare function partition<T extends Record<string, unknown>>(object: T | null | undefined, doesMatchProperty: [keyof T[keyof T], unknown]): [T[], T[]];
-/**
- * Creates an array of elements split into two groups, the first of which contains elements
- * that have the given property name, the second of which contains elements that don't.
+ * partition({ a: 1, b: 2, c: 3 }, n => n % 2 === 0);
+ * // => [[2], [1, 3]]
  *
- * @template T
- * @param {T | null | undefined} object - The object to iterate over.
- * @param {PropertyKey} propertyToCheck - The property name to check.
- * @returns {[T[], T[]]} - Returns the array of grouped elements.
+ * partition({ a: 1, b: 2, c: 3 }, 'a');
+ * // => [[1], [2, 3]]
  *
- * @example
- * const obj = { a: { id: 1, name: 'Alice' }, b: { id: 2, name: 'Bob' }, c: { id: 3, age: 28 } };
- * partition(obj, 'name');
- * // => [[{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }], [{ id: 3, age: 28 }]]
+ * partition({ a: 1, b: 2, c: 3 }, ['a', 1]);
+ * // => [[1], [2, 3]]
  */
-declare function partition<T extends Record<string, unknown>>(object: T | null | undefined, propertyToCheck: PropertyKey): [T[], T[]];
+declare function partition<T extends object>(object: T | null | undefined, predicate?: ((value: T[keyof T]) => unknown) | PropertyKey | [PropertyKey, any] | Partial<T[keyof T]>): [Array<T[keyof T]>, Array<T[keyof T]>];
 
 export { partition };

package/dist/compat/array/partition.mjs

@@ -1,4 +1,3 @@
-import { isArray } from '../predicate/isArray.mjs';
 import { isArrayLike } from '../predicate/isArrayLike.mjs';
 import { iteratee } from '../util/iteratee.mjs';
 
@@ -6,28 +5,13 @@ function partition(source, predicate) {
     if (!source) {
         return [[], []];
     }
-    const collection = isArray(source) ? source : Object.values(source);
+    const collection = isArrayLike(source) ? source : Object.values(source);
     predicate = iteratee(predicate);
     const matched = [];
     const unmatched = [];
-    if (!isArray(source)) {
-        const keys = Object.keys(source);
-        const length = isArrayLike(source) ? source.length : keys.length;
-        for (let i = 0; i < length; i++) {
-            const key = keys[i];
-            const value = source[key];
-            if (predicate(value, key, source)) {
-                matched.push(value);
-            }
-            else {
-                unmatched.push(value);
-            }
-        }
-        return [matched, unmatched];
-    }
     for (let i = 0; i < collection.length; i++) {
         const value = collection[i];
-        if (predicate(value, i, source)) {
+        if (predicate(value)) {
             matched.push(value);
         }
         else {

package/dist/compat/index.js

@@ -1220,28 +1220,13 @@ function partition(source, predicate) {
     if (!source) {
         return [[], []];
     }
-    const collection = toSnakeCaseKeys.isArray(source) ? source : Object.values(source);
+    const collection = isArrayLike(source) ? source : Object.values(source);
     predicate = iteratee(predicate);
     const matched = [];
     const unmatched = [];
-    if (!toSnakeCaseKeys.isArray(source)) {
-        const keys = Object.keys(source);
-        const length = isArrayLike(source) ? source.length : keys.length;
-        for (let i = 0; i < length; i++) {
-            const key = keys[i];
-            const value = source[key];
-            if (predicate(value, key, source)) {
-                matched.push(value);
-            }
-            else {
-                unmatched.push(value);
-            }
-        }
-        return [matched, unmatched];
-    }
     for (let i = 0; i < collection.length; i++) {
         const value = collection[i];
-        if (predicate(value, i, source)) {
+        if (predicate(value)) {
             matched.push(value);
         }
         else {

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.1174+b82b79e5",
+  "version": "1.35.0-dev.1176+c74c4b39",
   "homepage": "https://es-toolkit.slash.page",
   "bugs": "https://github.com/toss/es-toolkit/issues",
   "repository": {