es-toolkit 1.25.2-dev.810 → 1.25.2-dev.813

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

@@ -0,0 +1,111 @@
+/**
+ * Returns the intersection of multiple arrays after applying the iteratee function to their elements.
+ *
+ * This function takes multiple arrays and an iteratee function (or property key) to
+ * compare the elements after transforming them. It returns a new array containing the elements from
+ * the first array that are present in all subsequent arrays after applying the iteratee to each element.
+ *
+ * @template T1, T2
+ * @param {ArrayLike<T1> | null | undefined} array - The first array to compare.
+ * @param {ArrayLike<T2>} values - The second array to compare.
+ * @param {(value: T1 | T2) => unknown | string} iteratee - The iteratee invoked on each element
+ *  for comparison. It can also be a property key to compare based on that property.
+ * @returns {T1[]} A new array containing the elements from the first array that are present
+ *  in all subsequent arrays after applying the iteratee.
+ *
+ * @example
+ * const array1 = [{ x: 1 }, { x: 2 }, { x: 3 }];
+ * const array2 = [{ x: 2 }, { x: 3 }, { x: 4 }];
+ * const result = intersectionBy(array1, array2, 'x');
+ * // result will be [{ x: 2 }, { x: 3 }] since these elements have the same `x` property.
+ *
+ * const array1 = [{ x: 1 }, { x: 2 }, { x: 3 }];
+ * const array2 = [{ x: 2 }, { x: 3 }, { x: 4 }];
+ * const result = intersectionBy(array1, array2, value => value.x);
+ * // result will be [{ x: 2 }, { x: 3 }] since these elements have the same `x` property.
+ */
+declare function intersectionBy<T1, T2>(array: ArrayLike<T1> | null | undefined, values: ArrayLike<T2>, iteratee: ((value: T1 | T2) => unknown) | string): T1[];
+/**
+ * Returns the intersection of multiple arrays after applying the iteratee function to their elements.
+ *
+ * This function takes multiple arrays and an iteratee function (or property key) to
+ * compare the elements after transforming them. It returns a new array containing the elements from
+ * the first array that are present in all subsequent arrays after applying the iteratee to each element.
+ *
+ * @template T1, T2, T3
+ * @param {ArrayLike<T1> | null | undefined} array - The first array to compare.
+ * @param {ArrayLike<T2>} values1 - The second array to compare.
+ * @param {ArrayLike<T3>} values2 - The third array to compare.
+ * @param {(value: T1 | T2 | T3) => unknown | string} iteratee - The iteratee invoked on each element
+ *  for comparison. It can also be a property key to compare based on that property.
+ * @returns {T1[]} A new array containing the elements from the first array that are present
+ *  in all subsequent arrays after applying the iteratee.
+ *
+ * @example
+ * const array1 = [{ x: 1 }, { x: 2 }, { x: 3 }];
+ * const array2 = [{ x: 2 }, { x: 3 }];
+ * const array3 = [{ x: 3 }];
+ * const result = intersectionBy(array1, array2, array3, 'x');
+ * // result will be [{ x: 3 }] since this element has the same `x` property in all arrays.
+ *
+ * const array1 = [{ x: 1 }, { x: 2 }, { x: 3 }];
+ * const array2 = [{ x: 2 }, { x: 3 }];
+ * const array3 = [{ x: 3 }];
+ * const result = intersectionBy(array1, array2, array3, value => value.x);
+ * // result will be [{ x: 3 }] since this element has the same `x` property in all arrays.
+ */
+declare function intersectionBy<T1, T2, T3>(array: ArrayLike<T1> | null | undefined, values1: ArrayLike<T2>, values2: ArrayLike<T3>, iteratee: ((value: T1 | T2 | T3) => unknown) | string): T1[];
+/**
+ * Returns the intersection of multiple arrays after applying the iteratee function to their elements.
+ *
+ * This function takes multiple arrays and an iteratee function (or property key) to
+ * compare the elements after transforming them. It returns a new array containing the elements from
+ * the first array that are present in all subsequent arrays after applying the iteratee to each element.
+ *
+ * @template T1, T2, T3, T4
+ * @param {ArrayLike<T1> | null | undefined} array - The first array to compare.
+ * @param {ArrayLike<T2>} values1 - The second array to compare.
+ * @param {ArrayLike<T3>} values2 - The third array to compare.
+ * @param {...(ArrayLike<T4> | ((value: T1 | T2 | T3 | T4) => unknown) | string)} values - Additional arrays to compare, or the iteratee function.
+ * @returns {T1[]} A new array containing the elements from the first array that are present
+ *  in all subsequent arrays after applying the iteratee.
+ *
+ * @example
+ * const array1 = [{ x: 1 }, { x: 2 }, { x: 3 }];
+ * const array2 = [{ x: 2 }, { x: 3 }];
+ * const array3 = [{ x: 3 }];
+ * const array4 = [{ x: 3 }, { x: 4 }];
+ * const result = intersectionBy(array1, array2, array3, array4, 'x');
+ * // result will be [{ x: 3 }] since this element has the same `x` property in all arrays.
+ *
+ * const array1 = [{ x: 1 }, { x: 2 }, { x: 3 }];
+ * const array2 = [{ x: 2 }, { x: 3 }];
+ * const array3 = [{ x: 3 }];
+ * const array4 = [{ x: 3 }, { x: 4 }];
+ * const result = intersectionBy(array1, array2, array3, array4, value => value.x);
+ * // result will be [{ x: 3 }] since this element has the same `x` property in all arrays.
+ */
+declare function intersectionBy<T1, T2, T3, T4>(array: ArrayLike<T1> | null | undefined, values1: ArrayLike<T2>, values2: ArrayLike<T3>, ...values: Array<ArrayLike<T4> | ((value: T1 | T2 | T3 | T4) => unknown) | string>): T1[];
+/**
+ * Returns the intersection of multiple arrays after applying the iteratee function to their elements.
+ *
+ * This function takes multiple arrays and an iteratee function (or property key) to
+ * compare the elements after transforming them. It returns a new array containing the elements from
+ * the first array that are present in all subsequent arrays after applying the iteratee to each element.
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} [array] - The first array to compare.
+ * @param {...ArrayLike<T>} values - Additional arrays to compare.
+ * @returns {T[]} A new array containing the elements from the first array that are present
+ *  in all subsequent arrays after applying the iteratee.
+ *
+ * @example
+ * const array1 = [1, 2, 3];
+ * const array2 = [2, 3];
+ * const array3 = [3];
+ * const result = intersectionBy(array1, array2, array3);
+ * // result will be [3] since these all elements have the same value 3.
+ */
+declare function intersectionBy<T>(array?: ArrayLike<T> | null | undefined, ...values: Array<ArrayLike<T>>): T[];
+
+export { intersectionBy };

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

@@ -0,0 +1,111 @@
+/**
+ * Returns the intersection of multiple arrays after applying the iteratee function to their elements.
+ *
+ * This function takes multiple arrays and an iteratee function (or property key) to
+ * compare the elements after transforming them. It returns a new array containing the elements from
+ * the first array that are present in all subsequent arrays after applying the iteratee to each element.
+ *
+ * @template T1, T2
+ * @param {ArrayLike<T1> | null | undefined} array - The first array to compare.
+ * @param {ArrayLike<T2>} values - The second array to compare.
+ * @param {(value: T1 | T2) => unknown | string} iteratee - The iteratee invoked on each element
+ *  for comparison. It can also be a property key to compare based on that property.
+ * @returns {T1[]} A new array containing the elements from the first array that are present
+ *  in all subsequent arrays after applying the iteratee.
+ *
+ * @example
+ * const array1 = [{ x: 1 }, { x: 2 }, { x: 3 }];
+ * const array2 = [{ x: 2 }, { x: 3 }, { x: 4 }];
+ * const result = intersectionBy(array1, array2, 'x');
+ * // result will be [{ x: 2 }, { x: 3 }] since these elements have the same `x` property.
+ *
+ * const array1 = [{ x: 1 }, { x: 2 }, { x: 3 }];
+ * const array2 = [{ x: 2 }, { x: 3 }, { x: 4 }];
+ * const result = intersectionBy(array1, array2, value => value.x);
+ * // result will be [{ x: 2 }, { x: 3 }] since these elements have the same `x` property.
+ */
+declare function intersectionBy<T1, T2>(array: ArrayLike<T1> | null | undefined, values: ArrayLike<T2>, iteratee: ((value: T1 | T2) => unknown) | string): T1[];
+/**
+ * Returns the intersection of multiple arrays after applying the iteratee function to their elements.
+ *
+ * This function takes multiple arrays and an iteratee function (or property key) to
+ * compare the elements after transforming them. It returns a new array containing the elements from
+ * the first array that are present in all subsequent arrays after applying the iteratee to each element.
+ *
+ * @template T1, T2, T3
+ * @param {ArrayLike<T1> | null | undefined} array - The first array to compare.
+ * @param {ArrayLike<T2>} values1 - The second array to compare.
+ * @param {ArrayLike<T3>} values2 - The third array to compare.
+ * @param {(value: T1 | T2 | T3) => unknown | string} iteratee - The iteratee invoked on each element
+ *  for comparison. It can also be a property key to compare based on that property.
+ * @returns {T1[]} A new array containing the elements from the first array that are present
+ *  in all subsequent arrays after applying the iteratee.
+ *
+ * @example
+ * const array1 = [{ x: 1 }, { x: 2 }, { x: 3 }];
+ * const array2 = [{ x: 2 }, { x: 3 }];
+ * const array3 = [{ x: 3 }];
+ * const result = intersectionBy(array1, array2, array3, 'x');
+ * // result will be [{ x: 3 }] since this element has the same `x` property in all arrays.
+ *
+ * const array1 = [{ x: 1 }, { x: 2 }, { x: 3 }];
+ * const array2 = [{ x: 2 }, { x: 3 }];
+ * const array3 = [{ x: 3 }];
+ * const result = intersectionBy(array1, array2, array3, value => value.x);
+ * // result will be [{ x: 3 }] since this element has the same `x` property in all arrays.
+ */
+declare function intersectionBy<T1, T2, T3>(array: ArrayLike<T1> | null | undefined, values1: ArrayLike<T2>, values2: ArrayLike<T3>, iteratee: ((value: T1 | T2 | T3) => unknown) | string): T1[];
+/**
+ * Returns the intersection of multiple arrays after applying the iteratee function to their elements.
+ *
+ * This function takes multiple arrays and an iteratee function (or property key) to
+ * compare the elements after transforming them. It returns a new array containing the elements from
+ * the first array that are present in all subsequent arrays after applying the iteratee to each element.
+ *
+ * @template T1, T2, T3, T4
+ * @param {ArrayLike<T1> | null | undefined} array - The first array to compare.
+ * @param {ArrayLike<T2>} values1 - The second array to compare.
+ * @param {ArrayLike<T3>} values2 - The third array to compare.
+ * @param {...(ArrayLike<T4> | ((value: T1 | T2 | T3 | T4) => unknown) | string)} values - Additional arrays to compare, or the iteratee function.
+ * @returns {T1[]} A new array containing the elements from the first array that are present
+ *  in all subsequent arrays after applying the iteratee.
+ *
+ * @example
+ * const array1 = [{ x: 1 }, { x: 2 }, { x: 3 }];
+ * const array2 = [{ x: 2 }, { x: 3 }];
+ * const array3 = [{ x: 3 }];
+ * const array4 = [{ x: 3 }, { x: 4 }];
+ * const result = intersectionBy(array1, array2, array3, array4, 'x');
+ * // result will be [{ x: 3 }] since this element has the same `x` property in all arrays.
+ *
+ * const array1 = [{ x: 1 }, { x: 2 }, { x: 3 }];
+ * const array2 = [{ x: 2 }, { x: 3 }];
+ * const array3 = [{ x: 3 }];
+ * const array4 = [{ x: 3 }, { x: 4 }];
+ * const result = intersectionBy(array1, array2, array3, array4, value => value.x);
+ * // result will be [{ x: 3 }] since this element has the same `x` property in all arrays.
+ */
+declare function intersectionBy<T1, T2, T3, T4>(array: ArrayLike<T1> | null | undefined, values1: ArrayLike<T2>, values2: ArrayLike<T3>, ...values: Array<ArrayLike<T4> | ((value: T1 | T2 | T3 | T4) => unknown) | string>): T1[];
+/**
+ * Returns the intersection of multiple arrays after applying the iteratee function to their elements.
+ *
+ * This function takes multiple arrays and an iteratee function (or property key) to
+ * compare the elements after transforming them. It returns a new array containing the elements from
+ * the first array that are present in all subsequent arrays after applying the iteratee to each element.
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} [array] - The first array to compare.
+ * @param {...ArrayLike<T>} values - Additional arrays to compare.
+ * @returns {T[]} A new array containing the elements from the first array that are present
+ *  in all subsequent arrays after applying the iteratee.
+ *
+ * @example
+ * const array1 = [1, 2, 3];
+ * const array2 = [2, 3];
+ * const array3 = [3];
+ * const result = intersectionBy(array1, array2, array3);
+ * // result will be [3] since these all elements have the same value 3.
+ */
+declare function intersectionBy<T>(array?: ArrayLike<T> | null | undefined, ...values: Array<ArrayLike<T>>): T[];
+
+export { intersectionBy };

package/dist/compat/array/intersectionBy.mjs

@@ -0,0 +1,36 @@
+import { intersectionBy as intersectionBy$1 } from '../../array/intersectionBy.mjs';
+import { last } from '../../array/last.mjs';
+import { uniq } from '../../array/uniq.mjs';
+import { identity } from '../_internal/identity.mjs';
+import { property } from '../object/property.mjs';
+import { isArrayLikeObject } from '../predicate/isArrayLikeObject.mjs';
+
+function intersectionBy(array, ...values) {
+    if (!isArrayLikeObject(array)) {
+        return [];
+    }
+    const lastValue = last(values);
+    if (lastValue === undefined) {
+        return Array.from(array);
+    }
+    let result = uniq(Array.from(array));
+    const count = isArrayLikeObject(lastValue) ? values.length : values.length - 1;
+    for (let i = 0; i < count; ++i) {
+        const value = values[i];
+        if (!isArrayLikeObject(value)) {
+            return [];
+        }
+        if (isArrayLikeObject(lastValue)) {
+            result = intersectionBy$1(result, Array.from(value), identity);
+        }
+        else if (typeof lastValue === 'function') {
+            result = intersectionBy$1(result, Array.from(value), value => lastValue(value));
+        }
+        else if (typeof lastValue === 'string') {
+            result = intersectionBy$1(result, Array.from(value), property(lastValue));
+        }
+    }
+    return result;
+}
+
+export { intersectionBy };

package/dist/compat/index.d.mts

@@ -7,7 +7,6 @@ export { flatMapDeep } from '../array/flatMapDeep.mjs';
 export { forEachRight } from '../array/forEachRight.mjs';
 export { groupBy } from '../array/groupBy.mjs';
 export { initial } from '../array/initial.mjs';
-export { intersectionBy } from '../array/intersectionBy.mjs';
 export { intersectionWith } from '../array/intersectionWith.mjs';
 export { isSubset } from '../array/isSubset.mjs';
 export { keyBy } from '../array/keyBy.mjs';
@@ -101,6 +100,7 @@ export { head as first, head } from './array/head.mjs';
 export { includes } from './array/includes.mjs';
 export { indexOf } from './array/indexOf.mjs';
 export { intersection } from './array/intersection.mjs';
+export { intersectionBy } from './array/intersectionBy.mjs';
 export { join } from './array/join.mjs';
 export { last } from './array/last.mjs';
 export { orderBy } from './array/orderBy.mjs';

package/dist/compat/index.d.ts

@@ -7,7 +7,6 @@ export { flatMapDeep } from '../array/flatMapDeep.js';
 export { forEachRight } from '../array/forEachRight.js';
 export { groupBy } from '../array/groupBy.js';
 export { initial } from '../array/initial.js';
-export { intersectionBy } from '../array/intersectionBy.js';
 export { intersectionWith } from '../array/intersectionWith.js';
 export { isSubset } from '../array/isSubset.js';
 export { keyBy } from '../array/keyBy.js';
@@ -101,6 +100,7 @@ export { head as first, head } from './array/head.js';
 export { includes } from './array/includes.js';
 export { indexOf } from './array/indexOf.js';
 export { intersection } from './array/intersection.js';
+export { intersectionBy } from './array/intersectionBy.js';
 export { join } from './array/join.js';
 export { last } from './array/last.js';
 export { orderBy } from './array/orderBy.js';

package/dist/compat/index.js

@@ -824,6 +824,34 @@ function intersection(...arrays) {
     return result;
 }
 
+function intersectionBy(array, ...values) {
+    if (!isArrayLikeObject(array)) {
+        return [];
+    }
+    const lastValue = zipWith.last(values);
+    if (lastValue === undefined) {
+        return Array.from(array);
+    }
+    let result = zipWith.uniq(Array.from(array));
+    const count = isArrayLikeObject(lastValue) ? values.length : values.length - 1;
+    for (let i = 0; i < count; ++i) {
+        const value = values[i];
+        if (!isArrayLikeObject(value)) {
+            return [];
+        }
+        if (isArrayLikeObject(lastValue)) {
+            result = zipWith.intersectionBy(result, Array.from(value), identity);
+        }
+        else if (typeof lastValue === 'function') {
+            result = zipWith.intersectionBy(result, Array.from(value), value => lastValue(value));
+        }
+        else if (typeof lastValue === 'string') {
+            result = zipWith.intersectionBy(result, Array.from(value), property(lastValue));
+        }
+    }
+    return result;
+}
+
 function join(array, separator = ',') {
     if (!isArrayLike(array)) {
         return '';
@@ -2257,7 +2285,6 @@ exports.flatMapDeep = zipWith.flatMapDeep;
 exports.forEachRight = zipWith.forEachRight;
 exports.groupBy = zipWith.groupBy;
 exports.initial = zipWith.initial;
-exports.intersectionBy = zipWith.intersectionBy;
 exports.intersectionWith = zipWith.intersectionWith;
 exports.isSubset = zipWith.isSubset;
 exports.keyBy = zipWith.keyBy;
@@ -2384,6 +2411,7 @@ exports.inRange = inRange;
 exports.includes = includes;
 exports.indexOf = indexOf;
 exports.intersection = intersection;
+exports.intersectionBy = intersectionBy;
 exports.invertBy = invertBy;
 exports.isArguments = isArguments;
 exports.isArray = isArray;

package/dist/compat/index.mjs

@@ -7,7 +7,6 @@ export { flatMapDeep } from '../array/flatMapDeep.mjs';
 export { forEachRight } from '../array/forEachRight.mjs';
 export { groupBy } from '../array/groupBy.mjs';
 export { initial } from '../array/initial.mjs';
-export { intersectionBy } from '../array/intersectionBy.mjs';
 export { intersectionWith } from '../array/intersectionWith.mjs';
 export { isSubset } from '../array/isSubset.mjs';
 export { keyBy } from '../array/keyBy.mjs';
@@ -103,6 +102,7 @@ export { head as first, head } from './array/head.mjs';
 export { includes } from './array/includes.mjs';
 export { indexOf } from './array/indexOf.mjs';
 export { intersection } from './array/intersection.mjs';
+export { intersectionBy } from './array/intersectionBy.mjs';
 export { join } from './array/join.mjs';
 export { last } from './array/last.mjs';
 export { orderBy } from './array/orderBy.mjs';

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.25.2-dev.810+4a8ea44e",
+  "version": "1.25.2-dev.813+d22c156d",
   "homepage": "https://es-toolkit.slash.page",
   "bugs": "https://github.com/toss/es-toolkit/issues",
   "repository": {