es-toolkit 1.27.0 → 1.28.0-dev.910

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # es-toolkit Changelog
 
+## Version v1.28.0
+
+Released on November 30th, 2024.
+
+- Added compatibility functions for [gt](https://es-toolkit.slash.page/reference/compat/util/gt.html), [gte](https://es-toolkit.slash.page/reference/compat/util/gte.html), [toArray](https://es-toolkit.slash.page/reference/compat/util/toArray.html), [toUpper](https://es-toolkit.slash.page/reference/compat/string/toUpper.html), [add](https://es-toolkit.slash.page/reference/compat/math/add.html), [assignIn](https://es-toolkit.slash.page/reference/compat/object/assignIn.html) ([extend](https://es-toolkit.slash.page/reference/compat/object/extend.html)), and [isElement](https://es-toolkit.slash.page/reference/compat/predicate/isElement.html).
+- Introduced new compatibility types for `DebouncedFunc`.
+- Enhanced our function types to accept `PropertyKey` instead of just `string` for property keys.
+- Corrected [flatMap](https://es-toolkit.slash.page/reference/array/flatMap.html) to accurately infer return types when the `depth` parameter is omitted.
+- Resolved issues with incorrect types for [partial](https://es-toolkit.slash.page/reference/function/partial.html) and [partialRight](https://es-toolkit.slash.page/reference/function/partialRight.html).
+- Fixed [intersectionBy](https://es-toolkit.slash.page/reference/array/intersectionBy.html), [differenceBy](https://es-toolkit.slash.page/reference/array/differenceBy.html), and [differenceWith](https://es-toolkit.slash.page/reference/array/differenceWith.html) to properly calculate differences between various element types.
+- Ensured that [words](https://es-toolkit.slash.page/reference/string/words.html) is now correctly exported in our compatibility library.
+
+We sincerely thank @D-Sketon, @mass2527, @1eeminhyeong, @chhw130, @DONG-8, @filipsobol, @kim-dongho, @nnnnoel, @pbstar, and @jsparkdev for their contributions. We appreciate your great efforts!
+
 ## Version v1.27.0
 
 Released on November 10th, 2024.

package/dist/_chunk/{isWeakSet-D8h8bS.js → isWeakSet-CvIdTA.js}

@@ -14,6 +14,10 @@ function isBlob(x) {
     return x instanceof Blob;
 }
 
+function isBuffer(x) {
+    return typeof Buffer !== 'undefined' && Buffer.isBuffer(x);
+}
+
 function isDate(value) {
     return value instanceof Date;
 }
@@ -334,6 +338,7 @@ exports.eq = eq;
 exports.getTag = getTag;
 exports.isArrayBuffer = isArrayBuffer;
 exports.isBlob = isBlob;
+exports.isBuffer = isBuffer;
 exports.isDate = isDate;
 exports.isEqual = isEqual;
 exports.isEqualWith = isEqualWith;

package/dist/_chunk/{toMerged-CPY8Ug.js → toMerged-AV73JV.js}

@@ -43,115 +43,126 @@ function clone(obj) {
     return obj;
 }
 
-function cloneDeep(obj) {
-    return cloneDeepImpl(obj);
+function cloneDeepWith(obj, cloneValue) {
+    return cloneDeepWithImpl(obj, undefined, obj, new Map(), cloneValue);
 }
-function cloneDeepImpl(obj, stack = new Map()) {
-    if (isPlainObject.isPrimitive(obj)) {
-        return obj;
+function cloneDeepWithImpl(valueToClone, keyToClone, objectToClone, stack = new Map(), cloneValue = undefined) {
+    const cloned = cloneValue?.(valueToClone, keyToClone, objectToClone, stack);
+    if (cloned != null) {
+        return cloned;
+    }
+    if (isPlainObject.isPrimitive(valueToClone)) {
+        return valueToClone;
     }
-    if (stack.has(obj)) {
-        return stack.get(obj);
+    if (stack.has(valueToClone)) {
+        return stack.get(valueToClone);
     }
-    if (Array.isArray(obj)) {
-        const result = new Array(obj.length);
-        stack.set(obj, result);
-        for (let i = 0; i < obj.length; i++) {
-            result[i] = cloneDeepImpl(obj[i], stack);
+    if (Array.isArray(valueToClone)) {
+        const result = new Array(valueToClone.length);
+        stack.set(valueToClone, result);
+        for (let i = 0; i < valueToClone.length; i++) {
+            result[i] = cloneDeepWithImpl(valueToClone[i], i, objectToClone, stack, cloneValue);
         }
-        if (Object.hasOwn(obj, 'index')) {
-            result.index = obj.index;
+        if (Object.hasOwn(valueToClone, 'index')) {
+            result.index = valueToClone.index;
         }
-        if (Object.hasOwn(obj, 'input')) {
-            result.input = obj.input;
+        if (Object.hasOwn(valueToClone, 'input')) {
+            result.input = valueToClone.input;
         }
         return result;
     }
-    if (obj instanceof Date) {
-        return new Date(obj.getTime());
+    if (valueToClone instanceof Date) {
+        return new Date(valueToClone.getTime());
     }
-    if (obj instanceof RegExp) {
-        const result = new RegExp(obj.source, obj.flags);
-        result.lastIndex = obj.lastIndex;
+    if (valueToClone instanceof RegExp) {
+        const result = new RegExp(valueToClone.source, valueToClone.flags);
+        result.lastIndex = valueToClone.lastIndex;
         return result;
     }
-    if (obj instanceof Map) {
+    if (valueToClone instanceof Map) {
         const result = new Map();
-        stack.set(obj, result);
-        for (const [key, value] of obj) {
-            result.set(key, cloneDeepImpl(value, stack));
+        stack.set(valueToClone, result);
+        for (const [key, value] of valueToClone) {
+            result.set(key, cloneDeepWithImpl(value, key, objectToClone, stack, cloneValue));
         }
         return result;
     }
-    if (obj instanceof Set) {
+    if (valueToClone instanceof Set) {
         const result = new Set();
-        stack.set(obj, result);
-        for (const value of obj) {
-            result.add(cloneDeepImpl(value, stack));
+        stack.set(valueToClone, result);
+        for (const value of valueToClone) {
+            result.add(cloneDeepWithImpl(value, undefined, objectToClone, stack, cloneValue));
         }
         return result;
     }
-    if (typeof Buffer !== 'undefined' && Buffer.isBuffer(obj)) {
-        return obj.subarray();
+    if (typeof Buffer !== 'undefined' && Buffer.isBuffer(valueToClone)) {
+        return valueToClone.subarray();
     }
-    if (isPlainObject.isTypedArray(obj)) {
-        const result = new (Object.getPrototypeOf(obj).constructor)(obj.length);
-        stack.set(obj, result);
-        for (let i = 0; i < obj.length; i++) {
-            result[i] = cloneDeepImpl(obj[i], stack);
+    if (isPlainObject.isTypedArray(valueToClone)) {
+        const result = new (Object.getPrototypeOf(valueToClone).constructor)(valueToClone.length);
+        stack.set(valueToClone, result);
+        for (let i = 0; i < valueToClone.length; i++) {
+            result[i] = cloneDeepWithImpl(valueToClone[i], i, objectToClone, stack, cloneValue);
         }
         return result;
     }
-    if (obj instanceof ArrayBuffer || (typeof SharedArrayBuffer !== 'undefined' && obj instanceof SharedArrayBuffer)) {
-        return obj.slice(0);
+    if (valueToClone instanceof ArrayBuffer ||
+        (typeof SharedArrayBuffer !== 'undefined' && valueToClone instanceof SharedArrayBuffer)) {
+        return valueToClone.slice(0);
     }
-    if (obj instanceof DataView) {
-        const result = new DataView(obj.buffer.slice(0), obj.byteOffset, obj.byteLength);
-        stack.set(obj, result);
-        copyProperties(result, obj, stack);
+    if (valueToClone instanceof DataView) {
+        const result = new DataView(valueToClone.buffer.slice(0), valueToClone.byteOffset, valueToClone.byteLength);
+        stack.set(valueToClone, result);
+        copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
         return result;
     }
-    if (typeof File !== 'undefined' && obj instanceof File) {
-        const result = new File([obj], obj.name, { type: obj.type });
-        stack.set(obj, result);
-        copyProperties(result, obj, stack);
+    if (typeof File !== 'undefined' && valueToClone instanceof File) {
+        const result = new File([valueToClone], valueToClone.name, {
+            type: valueToClone.type,
+        });
+        stack.set(valueToClone, result);
+        copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
         return result;
     }
-    if (obj instanceof Blob) {
-        const result = new Blob([obj], { type: obj.type });
-        stack.set(obj, result);
-        copyProperties(result, obj, stack);
+    if (valueToClone instanceof Blob) {
+        const result = new Blob([valueToClone], { type: valueToClone.type });
+        stack.set(valueToClone, result);
+        copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
         return result;
     }
-    if (obj instanceof Error) {
-        const result = new obj.constructor();
-        stack.set(obj, result);
-        result.message = obj.message;
-        result.name = obj.name;
-        result.stack = obj.stack;
-        result.cause = obj.cause;
-        copyProperties(result, obj, stack);
+    if (valueToClone instanceof Error) {
+        const result = new valueToClone.constructor();
+        stack.set(valueToClone, result);
+        result.message = valueToClone.message;
+        result.name = valueToClone.name;
+        result.stack = valueToClone.stack;
+        result.cause = valueToClone.cause;
+        copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
         return result;
     }
-    if (typeof obj === 'object' && obj !== null) {
-        const result = Object.create(Object.getPrototypeOf(obj));
-        stack.set(obj, result);
-        copyProperties(result, obj, stack);
+    if (typeof valueToClone === 'object' && valueToClone !== null) {
+        const result = Object.create(Object.getPrototypeOf(valueToClone));
+        stack.set(valueToClone, result);
+        copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
         return result;
     }
-    return obj;
+    return valueToClone;
 }
-function copyProperties(target, source, stack) {
+function copyProperties(target, source, objectToClone = target, stack, cloneValue) {
     const keys = [...Object.keys(source), ...isPlainObject.getSymbols(source)];
     for (let i = 0; i < keys.length; i++) {
         const key = keys[i];
         const descriptor = Object.getOwnPropertyDescriptor(target, key);
         if (descriptor == null || descriptor.writable) {
-            target[key] = cloneDeepImpl(source[key], stack);
+            target[key] = cloneDeepWithImpl(source[key], key, objectToClone, stack, cloneValue);
         }
     }
 }
 
+function cloneDeep(obj) {
+    return cloneDeepWithImpl(obj, undefined, obj, new Map(), undefined);
+}
+
 function findKey(obj, predicate) {
     const keys = Object.keys(obj);
     return keys.find(key => predicate(obj[key], key, obj));
@@ -280,6 +291,7 @@ function toMerged(target, source) {
 
 exports.clone = clone;
 exports.cloneDeep = cloneDeep;
+exports.cloneDeepWith = cloneDeepWith;
 exports.copyProperties = copyProperties;
 exports.findKey = findKey;
 exports.flattenObject = flattenObject;

package/dist/_chunk/{upperFirst-DK_rTF.js → upperFirst-CorAVn.js}

@@ -186,6 +186,7 @@ function upperFirst(str) {
     return str.substring(0, 1).toUpperCase() + str.substring(1);
 }
 
+exports.CASE_SPLIT_PATTERN = CASE_SPLIT_PATTERN;
 exports.camelCase = camelCase;
 exports.capitalize = capitalize;
 exports.constantCase = constantCase;

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/flatMap.d.mts

@@ -18,6 +18,6 @@
  * flatMap(arr, (item: number) => [[item, item]], 2);
  * // [1, 1, 2, 2, 3, 3]
  */
-declare function flatMap<T, U, D extends number>(arr: readonly T[], iteratee: (item: T) => U, depth?: D): Array<FlatArray<U[], D>>;
+declare function flatMap<T, U, D extends number = 1>(arr: readonly T[], iteratee: (item: T) => U, depth?: D): Array<FlatArray<U[], D>>;
 
 export { flatMap };

package/dist/array/flatMap.d.ts

@@ -18,6 +18,6 @@
  * flatMap(arr, (item: number) => [[item, item]], 2);
  * // [1, 1, 2, 2, 3, 3]
  */
-declare function flatMap<T, U, D extends number>(arr: readonly T[], iteratee: (item: T) => U, depth?: D): Array<FlatArray<U[], D>>;
+declare function flatMap<T, U, D extends number = 1>(arr: readonly T[], iteratee: (item: T) => U, depth?: D): Array<FlatArray<U[], D>>;
 
 export { flatMap };

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 };

package/dist/array/intersectionWith.d.mts

@@ -6,10 +6,11 @@
  * by the custom equality function. It effectively filters out any elements from the first array that
  * do not have corresponding matches in the second array according to the equality function.
  *
- * @template T - The type of elements in the array.
+ * @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 {(x: T, y: T) => boolean} areItemsEqual - A custom function to determine if two elements are equal.
+ * @param {U[]} secondArr - The second array to compare.
+ * @param {(x: T, y: U) => boolean} areItemsEqual - A custom function to determine if two elements are equal.
  * This function takes two arguments, one from each array, and returns `true` if the elements are considered equal, and `false` otherwise.
  * @returns {T[]} A new array containing the elements from the first array that have corresponding matches in the second array according to the custom equality function.
  *
@@ -19,7 +20,18 @@
  * const areItemsEqual = (a, b) => a.id === b.id;
  * const result = intersectionWith(array1, array2, areItemsEqual);
  * // result will be [{ id: 2 }] since 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 areItemsEqual = (a, b) => a.id === b;
+ * const result = intersectionWith(array1, array2, areItemsEqual);
+ * // result will be [{ id: 2, name: 'amy' }] since this element has a matching id that is equal to seconds array's element.
  */
-declare function intersectionWith<T>(firstArr: readonly T[], secondArr: readonly T[], areItemsEqual: (x: T, y: T) => boolean): T[];
+declare function intersectionWith<T, U>(firstArr: readonly T[], secondArr: readonly U[], areItemsEqual: (x: T, y: U) => boolean): T[];
 
 export { intersectionWith };

package/dist/array/intersectionWith.d.ts

@@ -6,10 +6,11 @@
  * by the custom equality function. It effectively filters out any elements from the first array that
  * do not have corresponding matches in the second array according to the equality function.
  *
- * @template T - The type of elements in the array.
+ * @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 {(x: T, y: T) => boolean} areItemsEqual - A custom function to determine if two elements are equal.
+ * @param {U[]} secondArr - The second array to compare.
+ * @param {(x: T, y: U) => boolean} areItemsEqual - A custom function to determine if two elements are equal.
  * This function takes two arguments, one from each array, and returns `true` if the elements are considered equal, and `false` otherwise.
  * @returns {T[]} A new array containing the elements from the first array that have corresponding matches in the second array according to the custom equality function.
  *
@@ -19,7 +20,18 @@
  * const areItemsEqual = (a, b) => a.id === b.id;
  * const result = intersectionWith(array1, array2, areItemsEqual);
  * // result will be [{ id: 2 }] since 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 areItemsEqual = (a, b) => a.id === b;
+ * const result = intersectionWith(array1, array2, areItemsEqual);
+ * // result will be [{ id: 2, name: 'amy' }] since this element has a matching id that is equal to seconds array's element.
  */
-declare function intersectionWith<T>(firstArr: readonly T[], secondArr: readonly T[], areItemsEqual: (x: T, y: T) => boolean): T[];
+declare function intersectionWith<T, U>(firstArr: readonly T[], secondArr: readonly U[], areItemsEqual: (x: T, y: U) => boolean): T[];
 
 export { intersectionWith };