es-toolkit 1.26.1-dev.866 → 1.26.1-dev.868

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

@@ -0,0 +1,60 @@
+/**
+ * Creates a duplicate-free version of an array using a transform function for comparison.
+ *
+ * @template T
+ * @param {ArrayLike<T>} array - The array to inspect.
+ * @param {(value: T) => unknown} iteratee - The transform function.
+ * @returns {T[]} Returns the new duplicate-free array.
+ *
+ * @example
+ * uniqBy([2.1, 1.2, 2.3], Math.floor);
+ * // => [2.1, 1.2]
+ */
+declare function uniqBy<T>(array: ArrayLike<T>, iteratee: (value: T) => unknown): T[];
+/**
+ * Creates a duplicate-free version of an array using a property name for comparison.
+ *
+ * @template T
+ * @param {ArrayLike<T>} array - The array to inspect.
+ * @param {string} path - The property path to get values from.
+ * @returns {T[]} Returns the new duplicate-free array.
+ *
+ * @example
+ * const users = [
+ *   { 'user': 'barney', 'age': 36 },
+ *   { 'user': 'fred',   'age': 40 },
+ *   { 'user': 'barney', 'age': 37 }
+ * ];
+ * uniqBy(users, 'user');
+ * // => [{ 'user': 'barney', 'age': 36 }, { 'user': 'fred', 'age': 40 }]
+ */
+declare function uniqBy<T>(array: ArrayLike<T>, path: string): T[];
+/**
+ * Creates a duplicate-free version of an array using a property index for comparison.
+ *
+ * @template T
+ * @param {ArrayLike<T>} array - The array to inspect.
+ * @param {number} index - The index to get values from.
+ * @returns {T[]} Returns the new duplicate-free array.
+ *
+ * @example
+ * const arrays = [[2], [3], [1], [2], [3], [1]];
+ * uniqBy(arrays, 0);
+ * // => [[2], [3], [1]]
+ */
+declare function uniqBy<T>(array: ArrayLike<T>, index: number): T[];
+/**
+ * Creates a duplicate-free version of an array, combining multiple arrays and using an optional transform function.
+ *
+ * @template T
+ * @param {ArrayLike<T>} array - The array to inspect.
+ * @param {...Array<ArrayLike<T> | ((value: T) => unknown) | string>} values - Additional arrays and/or iteratee.
+ * @returns {T[]} Returns the new duplicate-free array.
+ *
+ * @example
+ * uniqBy([1, 2], [2, 3], [3, 4], Math.floor);
+ * // => [1, 2, 3, 4]
+ */
+declare function uniqBy<T>(array: ArrayLike<T> | null | undefined, ...values: Array<ArrayLike<T> | ((value: T) => unknown) | string>): T[];
+
+export { uniqBy };

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

@@ -0,0 +1,60 @@
+/**
+ * Creates a duplicate-free version of an array using a transform function for comparison.
+ *
+ * @template T
+ * @param {ArrayLike<T>} array - The array to inspect.
+ * @param {(value: T) => unknown} iteratee - The transform function.
+ * @returns {T[]} Returns the new duplicate-free array.
+ *
+ * @example
+ * uniqBy([2.1, 1.2, 2.3], Math.floor);
+ * // => [2.1, 1.2]
+ */
+declare function uniqBy<T>(array: ArrayLike<T>, iteratee: (value: T) => unknown): T[];
+/**
+ * Creates a duplicate-free version of an array using a property name for comparison.
+ *
+ * @template T
+ * @param {ArrayLike<T>} array - The array to inspect.
+ * @param {string} path - The property path to get values from.
+ * @returns {T[]} Returns the new duplicate-free array.
+ *
+ * @example
+ * const users = [
+ *   { 'user': 'barney', 'age': 36 },
+ *   { 'user': 'fred',   'age': 40 },
+ *   { 'user': 'barney', 'age': 37 }
+ * ];
+ * uniqBy(users, 'user');
+ * // => [{ 'user': 'barney', 'age': 36 }, { 'user': 'fred', 'age': 40 }]
+ */
+declare function uniqBy<T>(array: ArrayLike<T>, path: string): T[];
+/**
+ * Creates a duplicate-free version of an array using a property index for comparison.
+ *
+ * @template T
+ * @param {ArrayLike<T>} array - The array to inspect.
+ * @param {number} index - The index to get values from.
+ * @returns {T[]} Returns the new duplicate-free array.
+ *
+ * @example
+ * const arrays = [[2], [3], [1], [2], [3], [1]];
+ * uniqBy(arrays, 0);
+ * // => [[2], [3], [1]]
+ */
+declare function uniqBy<T>(array: ArrayLike<T>, index: number): T[];
+/**
+ * Creates a duplicate-free version of an array, combining multiple arrays and using an optional transform function.
+ *
+ * @template T
+ * @param {ArrayLike<T>} array - The array to inspect.
+ * @param {...Array<ArrayLike<T> | ((value: T) => unknown) | string>} values - Additional arrays and/or iteratee.
+ * @returns {T[]} Returns the new duplicate-free array.
+ *
+ * @example
+ * uniqBy([1, 2], [2, 3], [3, 4], Math.floor);
+ * // => [1, 2, 3, 4]
+ */
+declare function uniqBy<T>(array: ArrayLike<T> | null | undefined, ...values: Array<ArrayLike<T> | ((value: T) => unknown) | string>): T[];
+
+export { uniqBy };

package/dist/compat/array/uniqBy.mjs

@@ -0,0 +1,25 @@
+import { flatten } from './flatten.mjs';
+import { last } from './last.mjs';
+import { uniq } from '../../array/uniq.mjs';
+import { uniqBy as uniqBy$1 } from '../../array/uniqBy.mjs';
+import { isArrayLikeObject } from '../predicate/isArrayLikeObject.mjs';
+import { iteratee } from '../util/iteratee.mjs';
+
+function uniqBy(arr, ...values) {
+    if (!isArrayLikeObject(arr)) {
+        return [];
+    }
+    const iteratee$1 = last(values);
+    if (iteratee$1 === undefined) {
+        return Array.from(arr);
+    }
+    const validArrays = values.slice(0, -1).filter(isArrayLikeObject);
+    const flattenedArrays = flatten(validArrays);
+    const allValues = [...Array.from(arr), ...flattenedArrays];
+    if (isArrayLikeObject(iteratee$1)) {
+        return uniq(allValues);
+    }
+    return uniqBy$1(allValues, iteratee(iteratee$1));
+}
+
+export { uniqBy };

package/dist/compat/index.d.mts

@@ -21,7 +21,6 @@ export { takeWhile } from '../array/takeWhile.mjs';
 export { toFilled } from '../array/toFilled.mjs';
 export { unionBy } from '../array/unionBy.mjs';
 export { unionWith } from '../array/unionWith.mjs';
-export { uniqBy } from '../array/uniqBy.mjs';
 export { uniqWith } from '../array/uniqWith.mjs';
 export { unzipWith } from '../array/unzipWith.mjs';
 export { xor } from '../array/xor.mjs';
@@ -114,6 +113,7 @@ export { take } from './array/take.mjs';
 export { takeRight } from './array/takeRight.mjs';
 export { union } from './array/union.mjs';
 export { uniq } from './array/uniq.mjs';
+export { uniqBy } from './array/uniqBy.mjs';
 export { unzip } from './array/unzip.mjs';
 export { without } from './array/without.mjs';
 export { zip } from './array/zip.mjs';

package/dist/compat/index.d.ts

@@ -21,7 +21,6 @@ export { takeWhile } from '../array/takeWhile.js';
 export { toFilled } from '../array/toFilled.js';
 export { unionBy } from '../array/unionBy.js';
 export { unionWith } from '../array/unionWith.js';
-export { uniqBy } from '../array/uniqBy.js';
 export { uniqWith } from '../array/uniqWith.js';
 export { unzipWith } from '../array/unzipWith.js';
 export { xor } from '../array/xor.js';
@@ -114,6 +113,7 @@ export { take } from './array/take.js';
 export { takeRight } from './array/takeRight.js';
 export { union } from './array/union.js';
 export { uniq } from './array/uniq.js';
+export { uniqBy } from './array/uniqBy.js';
 export { unzip } from './array/unzip.js';
 export { without } from './array/without.js';
 export { zip } from './array/zip.js';

package/dist/compat/index.js

@@ -1214,6 +1214,23 @@ function uniq(arr) {
     return zipWith.uniq(Array.from(arr));
 }
 
+function uniqBy(arr, ...values) {
+    if (!isArrayLikeObject(arr)) {
+        return [];
+    }
+    const iteratee$1 = last(values);
+    if (iteratee$1 === undefined) {
+        return Array.from(arr);
+    }
+    const validArrays = values.slice(0, -1).filter(isArrayLikeObject);
+    const flattenedArrays = flatten(validArrays);
+    const allValues = [...Array.from(arr), ...flattenedArrays];
+    if (isArrayLikeObject(iteratee$1)) {
+        return zipWith.uniq(allValues);
+    }
+    return zipWith.uniqBy(allValues, iteratee(iteratee$1));
+}
+
 function unzip(array) {
     if (!isArrayLikeObject(array) || !array.length) {
         return [];
@@ -2172,11 +2189,10 @@ function isEmpty(value) {
             return value.size === 0;
         }
         const keys = Object.keys(value);
-        const symbols = isPlainObject$1.getSymbols(value);
         if (isPrototype(value)) {
-            return keys.filter(x => x !== 'constructor').length === 0 && symbols.length === 0;
+            return keys.filter(x => x !== 'constructor').length === 0;
         }
-        return keys.length === 0 && symbols.length === 0;
+        return keys.length === 0;
     }
     return true;
 }
@@ -2554,7 +2570,6 @@ exports.takeWhile = zipWith.takeWhile;
 exports.toFilled = zipWith.toFilled;
 exports.unionBy = zipWith.unionBy;
 exports.unionWith = zipWith.unionWith;
-exports.uniqBy = zipWith.uniqBy;
 exports.uniqWith = zipWith.uniqWith;
 exports.unzipWith = zipWith.unzipWith;
 exports.xor = zipWith.xor;
@@ -2755,6 +2770,7 @@ exports.trimEnd = trimEnd;
 exports.trimStart = trimStart;
 exports.union = union;
 exports.uniq = uniq;
+exports.uniqBy = uniqBy;
 exports.uniqueId = uniqueId;
 exports.unset = unset;
 exports.unzip = unzip;

package/dist/compat/index.mjs

@@ -21,7 +21,6 @@ export { takeWhile } from '../array/takeWhile.mjs';
 export { toFilled } from '../array/toFilled.mjs';
 export { unionBy } from '../array/unionBy.mjs';
 export { unionWith } from '../array/unionWith.mjs';
-export { uniqBy } from '../array/uniqBy.mjs';
 export { uniqWith } from '../array/uniqWith.mjs';
 export { unzipWith } from '../array/unzipWith.mjs';
 export { xor } from '../array/xor.mjs';
@@ -116,6 +115,7 @@ export { take } from './array/take.mjs';
 export { takeRight } from './array/takeRight.mjs';
 export { union } from './array/union.mjs';
 export { uniq } from './array/uniq.mjs';
+export { uniqBy } from './array/uniqBy.mjs';
 export { unzip } from './array/unzip.mjs';
 export { without } from './array/without.mjs';
 export { zip } from './array/zip.mjs';

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

@@ -43,14 +43,14 @@ declare function isEmpty(value: Set<any>): boolean;
 /**
  * Checks if a given array is empty.
  *
- * @param {Array<any>} value - The array to check.
+ * @param {any[]} value - The array to check.
  * @returns {boolean} `true` if the array is empty, `false` otherwise.
  *
  * @example
  * isEmpty([]); // true
  * isEmpty([1, 2, 3]); // false
  */
-declare function isEmpty(value: Array<any>): value is [];
+declare function isEmpty(value: any[]): value is [];
 /**
  * Checks if a given object is empty.
  *

package/dist/compat/predicate/isEmpty.d.ts

@@ -43,14 +43,14 @@ declare function isEmpty(value: Set<any>): boolean;
 /**
  * Checks if a given array is empty.
  *
- * @param {Array<any>} value - The array to check.
+ * @param {any[]} value - The array to check.
  * @returns {boolean} `true` if the array is empty, `false` otherwise.
  *
  * @example
  * isEmpty([]); // true
  * isEmpty([1, 2, 3]); // false
  */
-declare function isEmpty(value: Array<any>): value is [];
+declare function isEmpty(value: any[]): value is [];
 /**
  * Checks if a given object is empty.
  *

package/dist/compat/predicate/isEmpty.mjs

@@ -1,7 +1,6 @@
 import { isArguments } from './isArguments.mjs';
 import { isArrayLike } from './isArrayLike.mjs';
 import { isTypedArray } from './isTypedArray.mjs';
-import { getSymbols } from '../_internal/getSymbols.mjs';
 import { isPrototype } from '../_internal/isPrototype.mjs';
 
 function isEmpty(value) {
@@ -23,11 +22,10 @@ function isEmpty(value) {
             return value.size === 0;
         }
         const keys = Object.keys(value);
-        const symbols = getSymbols(value);
         if (isPrototype(value)) {
-            return keys.filter(x => x !== 'constructor').length === 0 && symbols.length === 0;
+            return keys.filter(x => x !== 'constructor').length === 0;
         }
-        return keys.length === 0 && symbols.length === 0;
+        return keys.length === 0;
     }
     return true;
 }

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.26.1-dev.866+5053b7f0",
+  "version": "1.26.1-dev.868+b4cd2551",
   "homepage": "https://es-toolkit.slash.page",
   "bugs": "https://github.com/toss/es-toolkit/issues",
   "repository": {