es-toolkit 1.27.0-dev.888 → 1.27.0-dev.889

package/dist/array/differenceBy.d.mts

@@ -10,8 +10,8 @@
  *
  * @template T, U
  * @param {T[]} firstArr - The primary array from which to derive the difference.
- * @param {T[]} secondArr - The array containing elements to be excluded from the first array.
- * @param {(value: T) => U} mapper - The function to map the elements of both arrays. This function
+ * @param {U[]} secondArr - The array containing elements to be excluded from the first array.
+ * @param {(value: T | U) => unknown} mapper - The function to map the elements of both arrays. This function
  * is applied to each element in both arrays, and the comparison is made based on the mapped values.
  * @returns {T[]} A new array containing the elements from the first array that do not have a corresponding
  * mapped identity in the second array.
@@ -22,7 +22,14 @@
  * const mapper = item => item.id;
  * const result = differenceBy(array1, array2, mapper);
  * // result will be [{ id: 1 }, { id: 3 }] since the elements with id 2 are in both arrays and are excluded from the result.
+ *
+ * @example
+ * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const array2 = [2, 4];
+ * const mapper = item => (typeof item === 'object' ? item.id : item);
+ * const result = differenceBy(array1, array2, mapper);
+ * // result will be [{ id: 1 }, { id: 3 }] since 2 is present in both arrays after mapping, and is excluded from the result.
  */
-declare function differenceBy<T, U>(firstArr: readonly T[], secondArr: readonly T[], mapper: (value: T) => U): T[];
+declare function differenceBy<T, U>(firstArr: readonly T[], secondArr: readonly U[], mapper: (value: T | U) => unknown): T[];
 
 export { differenceBy };

package/dist/array/differenceBy.d.ts

@@ -10,8 +10,8 @@
  *
  * @template T, U
  * @param {T[]} firstArr - The primary array from which to derive the difference.
- * @param {T[]} secondArr - The array containing elements to be excluded from the first array.
- * @param {(value: T) => U} mapper - The function to map the elements of both arrays. This function
+ * @param {U[]} secondArr - The array containing elements to be excluded from the first array.
+ * @param {(value: T | U) => unknown} mapper - The function to map the elements of both arrays. This function
  * is applied to each element in both arrays, and the comparison is made based on the mapped values.
  * @returns {T[]} A new array containing the elements from the first array that do not have a corresponding
  * mapped identity in the second array.
@@ -22,7 +22,14 @@
  * const mapper = item => item.id;
  * const result = differenceBy(array1, array2, mapper);
  * // result will be [{ id: 1 }, { id: 3 }] since the elements with id 2 are in both arrays and are excluded from the result.
+ *
+ * @example
+ * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const array2 = [2, 4];
+ * const mapper = item => (typeof item === 'object' ? item.id : item);
+ * const result = differenceBy(array1, array2, mapper);
+ * // result will be [{ id: 1 }, { id: 3 }] since 2 is present in both arrays after mapping, and is excluded from the result.
  */
-declare function differenceBy<T, U>(firstArr: readonly T[], secondArr: readonly T[], mapper: (value: T) => U): T[];
+declare function differenceBy<T, U>(firstArr: readonly T[], secondArr: readonly U[], mapper: (value: T | U) => unknown): T[];
 
 export { differenceBy };

package/dist/array/differenceWith.d.mts

@@ -5,10 +5,10 @@
  * the elements that are present in the first array but not in the second array. The comparison to determine
  * if elements are equal is made using the provided custom function.
  *
- * @template T
+ * @template T, U
  * @param {T[]} firstArr - The array from which to get the difference.
- * @param {T[]} secondArr - The array containing elements to exclude from the first array.
- * @param {(x: T, y: T) => boolean} areItemsEqual - A function to determine if two items are equal.
+ * @param {U[]} secondArr - The array containing elements to exclude from the first array.
+ * @param {(x: T, y: U) => boolean} areItemsEqual - A function to determine if two items are equal.
  * @returns {T[]} A new array containing the elements from the first array that do not match any elements in the second array
  * according to the custom equality function.
  *
@@ -18,7 +18,14 @@
  * const areItemsEqual = (a, b) => a.id === b.id;
  * const result = differenceWith(array1, array2, areItemsEqual);
  * // result will be [{ id: 1 }, { id: 3 }] since the elements with id 2 are considered equal and are excluded from the result.
+ *
+ * @example
+ * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const array2 = [2, 4];
+ * const areItemsEqual = (a, b) => a.id === b;
+ * const result = differenceWith(array1, array2, areItemsEqual);
+ * // result will be [{ id: 1 }, { id: 3 }] since the element with id 2 is considered equal to the second array's element and is excluded from the result.
  */
-declare function differenceWith<T>(firstArr: readonly T[], secondArr: readonly T[], areItemsEqual: (x: T, y: T) => boolean): T[];
+declare function differenceWith<T, U>(firstArr: readonly T[], secondArr: readonly U[], areItemsEqual: (x: T, y: U) => boolean): T[];
 
 export { differenceWith };

package/dist/array/differenceWith.d.ts

@@ -5,10 +5,10 @@
  * the elements that are present in the first array but not in the second array. The comparison to determine
  * if elements are equal is made using the provided custom function.
  *
- * @template T
+ * @template T, U
  * @param {T[]} firstArr - The array from which to get the difference.
- * @param {T[]} secondArr - The array containing elements to exclude from the first array.
- * @param {(x: T, y: T) => boolean} areItemsEqual - A function to determine if two items are equal.
+ * @param {U[]} secondArr - The array containing elements to exclude from the first array.
+ * @param {(x: T, y: U) => boolean} areItemsEqual - A function to determine if two items are equal.
  * @returns {T[]} A new array containing the elements from the first array that do not match any elements in the second array
  * according to the custom equality function.
  *
@@ -18,7 +18,14 @@
  * const areItemsEqual = (a, b) => a.id === b.id;
  * const result = differenceWith(array1, array2, areItemsEqual);
  * // result will be [{ id: 1 }, { id: 3 }] since the elements with id 2 are considered equal and are excluded from the result.
+ *
+ * @example
+ * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const array2 = [2, 4];
+ * const areItemsEqual = (a, b) => a.id === b;
+ * const result = differenceWith(array1, array2, areItemsEqual);
+ * // result will be [{ id: 1 }, { id: 3 }] since the element with id 2 is considered equal to the second array's element and is excluded from the result.
  */
-declare function differenceWith<T>(firstArr: readonly T[], secondArr: readonly T[], areItemsEqual: (x: T, y: T) => boolean): T[];
+declare function differenceWith<T, U>(firstArr: readonly T[], secondArr: readonly U[], areItemsEqual: (x: T, y: U) => boolean): T[];
 
 export { differenceWith };

package/dist/array/intersectionBy.d.mts

@@ -6,11 +6,11 @@
  * mapped elements in the second array. It effectively filters out any elements from the first array
  * that do not have corresponding mapped values in the second array.
  *
- * @template T - The type of elements in the array.
- * @template U - The type of mapped elements.
+ * @template T - The type of elements in the first array.
+ * @template U - The type of elements in the second array.
  * @param {T[]} firstArr - The first array to compare.
- * @param {T[]} secondArr - The second array to compare.
- * @param {(item: T) => U} mapper - A function to map the elements of both arrays for comparison.
+ * @param {U[]} secondArr - The second array to compare.
+ * @param {(item: T | U) => unknown} mapper - A function to map the elements of both arrays for comparison.
  * @returns {T[]} A new array containing the elements from the first array that have corresponding mapped values in the second array.
  *
  * @example
@@ -19,7 +19,18 @@
  * const mapper = item => item.id;
  * const result = intersectionBy(array1, array2, mapper);
  * // result will be [{ id: 2 }] since only this element has a matching id in both arrays.
+ *
+ * @example
+ * const array1 = [
+ *   { id: 1, name: 'jane' },
+ *   { id: 2, name: 'amy' },
+ *   { id: 3, name: 'michael' },
+ * ];
+ * const array2 = [2, 4];
+ * const mapper = item => (typeof item === 'object' ? item.id : item);
+ * const result = intersectionBy(array1, array2, mapper);
+ * // result will be [{ id: 2, name: 'amy' }] since only this element has a matching id that is equal to seconds array's element.
  */
-declare function intersectionBy<T, U>(firstArr: readonly T[], secondArr: readonly T[], mapper: (item: T) => U): T[];
+declare function intersectionBy<T, U>(firstArr: readonly T[], secondArr: readonly U[], mapper: (item: T | U) => unknown): T[];
 
 export { intersectionBy };

package/dist/array/intersectionBy.d.ts

@@ -6,11 +6,11 @@
  * mapped elements in the second array. It effectively filters out any elements from the first array
  * that do not have corresponding mapped values in the second array.
  *
- * @template T - The type of elements in the array.
- * @template U - The type of mapped elements.
+ * @template T - The type of elements in the first array.
+ * @template U - The type of elements in the second array.
  * @param {T[]} firstArr - The first array to compare.
- * @param {T[]} secondArr - The second array to compare.
- * @param {(item: T) => U} mapper - A function to map the elements of both arrays for comparison.
+ * @param {U[]} secondArr - The second array to compare.
+ * @param {(item: T | U) => unknown} mapper - A function to map the elements of both arrays for comparison.
  * @returns {T[]} A new array containing the elements from the first array that have corresponding mapped values in the second array.
  *
  * @example
@@ -19,7 +19,18 @@
  * const mapper = item => item.id;
  * const result = intersectionBy(array1, array2, mapper);
  * // result will be [{ id: 2 }] since only this element has a matching id in both arrays.
+ *
+ * @example
+ * const array1 = [
+ *   { id: 1, name: 'jane' },
+ *   { id: 2, name: 'amy' },
+ *   { id: 3, name: 'michael' },
+ * ];
+ * const array2 = [2, 4];
+ * const mapper = item => (typeof item === 'object' ? item.id : item);
+ * const result = intersectionBy(array1, array2, mapper);
+ * // result will be [{ id: 2, name: 'amy' }] since only this element has a matching id that is equal to seconds array's element.
  */
-declare function intersectionBy<T, U>(firstArr: readonly T[], secondArr: readonly T[], mapper: (item: T) => U): T[];
+declare function intersectionBy<T, U>(firstArr: readonly T[], secondArr: readonly U[], mapper: (item: T | U) => unknown): T[];
 
 export { intersectionBy };