es-toolkit 1.29.0-dev.932 → 1.29.0-dev.933

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

@@ -0,0 +1,91 @@
+/**
+ * Computes the difference between the primary array and another array using a comparator function.
+ *
+ * @template T1, T2
+ * @param {ArrayLike<T1> | null | undefined} array - The primary array to compare elements against.
+ * @param {ArrayLike<T2>} values - The array containing elements to compare with the primary array.
+ * @param {(a: T1, b: T2) => boolean} comparator - A function to determine if two elements are considered equal.
+ * @returns {T1[]} A new array containing the elements from the primary array that do not match any elements in `values` based on the comparator.
+ *
+ * @example
+ * const array = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const values = [{ id: 2 }];
+ * const comparator = (a, b) => a.id === b.id;
+ *
+ * const result = differenceWith(array, values, comparator);
+ * // result will be [{ id: 1 }, { id: 3 }]
+ */
+declare function differenceWith<T1, T2>(array: ArrayLike<T1> | null | undefined, values: ArrayLike<T2>, comparator: (a: T1, b: T2) => boolean): T1[];
+/**
+ * Computes the difference between the primary array and two arrays using a comparator function.
+ *
+ * @template T1, T2, T3
+ * @param {ArrayLike<T1> | null | undefined} array - The primary array to compare elements against.
+ * @param {ArrayLike<T2>} values1 - The first array containing elements to compare with the primary array.
+ * @param {ArrayLike<T3>} values2 - The second array containing elements to compare with the primary array.
+ * @param {(a: T1, b: T2 | T3) => boolean} comparator - A function to determine if two elements are considered equal.
+ * @returns {T1[]} A new array containing the elements from the primary array that do not match any elements in `values1` or `values2` based on the comparator.
+ *
+ * @example
+ * const array = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const values1 = [{ id: 2 }];
+ * const values2 = [{ id: 3 }];
+ * const comparator = (a, b) => a.id === b.id;
+ *
+ * const result = differenceWith(array, values1, values2, comparator);
+ * // result will be [{ id: 1 }]
+ */
+declare function differenceWith<T1, T2, T3>(array: ArrayLike<T1> | null | undefined, values1: ArrayLike<T2>, values2: ArrayLike<T3>, comparator: (a: T1, b: T2 | T3) => boolean): T1[];
+/**
+ * Computes the difference between the primary array and multiple arrays using a comparator function.
+ *
+ * @template T1, T2, T3, T4
+ * @param {ArrayLike<T1> | null | undefined} array - The primary array to compare elements against.
+ * @param {ArrayLike<T2>} values1 - The first array containing elements to compare with the primary array.
+ * @param {ArrayLike<T3>} values2 - The second array containing elements to compare with the primary array.
+ * @param {...Array<ArrayLike<T4> | ((a: T1, b: T2 | T3 | T4) => boolean)>} values - Additional arrays and an optional comparator function to determine if two elements are considered equal.
+ * @returns {T1[]} A new array containing the elements from the primary array that do not match any elements
+ * in `values1`, `values2`, or subsequent arrays. If a comparator function is provided, it will be used to compare elements;
+ * otherwise, [SameValueZero](https://tc39.es/ecma262/multipage/abstract-operations.html#sec-samevaluezero) algorithm will be used.
+ *
+ * @example
+ * // Example with comparator function
+ * const array = [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }];
+ * const values1 = [{ id: 2 }];
+ * const values2 = [{ id: 3 }];
+ * const values3 = [{ id: 4 }];
+ * const comparator = (a, b) => a.id === b.id;
+ *
+ * const result = differenceWith(array, values1, values2, values3, comparator);
+ * // result will be [{ id: 1 }]
+ *
+ * @example
+ * // Example without comparator function (behaves like `difference`)
+ * const array = [1, 2, 3, 4];
+ * const values1 = [2];
+ * const values2 = [3];
+ * const values3 = [4];
+ *
+ * const result = differenceWith(array, values1, values2, values3);
+ * // result will be [1]
+ */
+declare function differenceWith<T1, T2, T3, T4>(array: ArrayLike<T1> | null | undefined, values1: ArrayLike<T2>, values2: ArrayLike<T3>, ...values: Array<ArrayLike<T4> | ((a: T1, b: T2 | T3 | T4) => boolean)>): T1[];
+/**
+ * Computes the difference between the primary array and one or more arrays without using a comparator function.
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} array - The primary array to compare elements against.
+ * @param {...Array<ArrayLike<T>>} values - One or more arrays containing elements to compare with the primary array.
+ * @returns {T[]} A new array containing the elements from the primary array that do not match any elements in the provided arrays.
+ *
+ * @example
+ * const array = [1, 2, 3];
+ * const values1 = [2];
+ * const values2 = [3];
+ *
+ * const result = differenceWith(array, values1, values2);
+ * // result will be [1]
+ */
+declare function differenceWith<T>(array: ArrayLike<T> | null | undefined, ...values: Array<ArrayLike<T>>): T[];
+
+export { differenceWith };

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

@@ -0,0 +1,91 @@
+/**
+ * Computes the difference between the primary array and another array using a comparator function.
+ *
+ * @template T1, T2
+ * @param {ArrayLike<T1> | null | undefined} array - The primary array to compare elements against.
+ * @param {ArrayLike<T2>} values - The array containing elements to compare with the primary array.
+ * @param {(a: T1, b: T2) => boolean} comparator - A function to determine if two elements are considered equal.
+ * @returns {T1[]} A new array containing the elements from the primary array that do not match any elements in `values` based on the comparator.
+ *
+ * @example
+ * const array = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const values = [{ id: 2 }];
+ * const comparator = (a, b) => a.id === b.id;
+ *
+ * const result = differenceWith(array, values, comparator);
+ * // result will be [{ id: 1 }, { id: 3 }]
+ */
+declare function differenceWith<T1, T2>(array: ArrayLike<T1> | null | undefined, values: ArrayLike<T2>, comparator: (a: T1, b: T2) => boolean): T1[];
+/**
+ * Computes the difference between the primary array and two arrays using a comparator function.
+ *
+ * @template T1, T2, T3
+ * @param {ArrayLike<T1> | null | undefined} array - The primary array to compare elements against.
+ * @param {ArrayLike<T2>} values1 - The first array containing elements to compare with the primary array.
+ * @param {ArrayLike<T3>} values2 - The second array containing elements to compare with the primary array.
+ * @param {(a: T1, b: T2 | T3) => boolean} comparator - A function to determine if two elements are considered equal.
+ * @returns {T1[]} A new array containing the elements from the primary array that do not match any elements in `values1` or `values2` based on the comparator.
+ *
+ * @example
+ * const array = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const values1 = [{ id: 2 }];
+ * const values2 = [{ id: 3 }];
+ * const comparator = (a, b) => a.id === b.id;
+ *
+ * const result = differenceWith(array, values1, values2, comparator);
+ * // result will be [{ id: 1 }]
+ */
+declare function differenceWith<T1, T2, T3>(array: ArrayLike<T1> | null | undefined, values1: ArrayLike<T2>, values2: ArrayLike<T3>, comparator: (a: T1, b: T2 | T3) => boolean): T1[];
+/**
+ * Computes the difference between the primary array and multiple arrays using a comparator function.
+ *
+ * @template T1, T2, T3, T4
+ * @param {ArrayLike<T1> | null | undefined} array - The primary array to compare elements against.
+ * @param {ArrayLike<T2>} values1 - The first array containing elements to compare with the primary array.
+ * @param {ArrayLike<T3>} values2 - The second array containing elements to compare with the primary array.
+ * @param {...Array<ArrayLike<T4> | ((a: T1, b: T2 | T3 | T4) => boolean)>} values - Additional arrays and an optional comparator function to determine if two elements are considered equal.
+ * @returns {T1[]} A new array containing the elements from the primary array that do not match any elements
+ * in `values1`, `values2`, or subsequent arrays. If a comparator function is provided, it will be used to compare elements;
+ * otherwise, [SameValueZero](https://tc39.es/ecma262/multipage/abstract-operations.html#sec-samevaluezero) algorithm will be used.
+ *
+ * @example
+ * // Example with comparator function
+ * const array = [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }];
+ * const values1 = [{ id: 2 }];
+ * const values2 = [{ id: 3 }];
+ * const values3 = [{ id: 4 }];
+ * const comparator = (a, b) => a.id === b.id;
+ *
+ * const result = differenceWith(array, values1, values2, values3, comparator);
+ * // result will be [{ id: 1 }]
+ *
+ * @example
+ * // Example without comparator function (behaves like `difference`)
+ * const array = [1, 2, 3, 4];
+ * const values1 = [2];
+ * const values2 = [3];
+ * const values3 = [4];
+ *
+ * const result = differenceWith(array, values1, values2, values3);
+ * // result will be [1]
+ */
+declare function differenceWith<T1, T2, T3, T4>(array: ArrayLike<T1> | null | undefined, values1: ArrayLike<T2>, values2: ArrayLike<T3>, ...values: Array<ArrayLike<T4> | ((a: T1, b: T2 | T3 | T4) => boolean)>): T1[];
+/**
+ * Computes the difference between the primary array and one or more arrays without using a comparator function.
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} array - The primary array to compare elements against.
+ * @param {...Array<ArrayLike<T>>} values - One or more arrays containing elements to compare with the primary array.
+ * @returns {T[]} A new array containing the elements from the primary array that do not match any elements in the provided arrays.
+ *
+ * @example
+ * const array = [1, 2, 3];
+ * const values1 = [2];
+ * const values2 = [3];
+ *
+ * const result = differenceWith(array, values1, values2);
+ * // result will be [1]
+ */
+declare function differenceWith<T>(array: ArrayLike<T> | null | undefined, ...values: Array<ArrayLike<T>>): T[];
+
+export { differenceWith };

package/dist/compat/array/differenceWith.mjs

@@ -0,0 +1,19 @@
+import { last } from './last.mjs';
+import { difference } from '../../array/difference.mjs';
+import { differenceWith as differenceWith$1 } from '../../array/differenceWith.mjs';
+import { flattenArrayLike } from '../_internal/flattenArrayLike.mjs';
+import { isArrayLikeObject } from '../predicate/isArrayLikeObject.mjs';
+
+function differenceWith(array, ...values) {
+    if (!isArrayLikeObject(array)) {
+        return [];
+    }
+    const comparator = last(values);
+    const flattenedValues = flattenArrayLike(values);
+    if (typeof comparator === 'function') {
+        return differenceWith$1(Array.from(array), flattenedValues, comparator);
+    }
+    return difference(Array.from(array), flattenedValues);
+}
+
+export { differenceWith };

package/dist/compat/index.d.mts

@@ -1,6 +1,5 @@
 export { at } from '../array/at.mjs';
 export { countBy } from '../array/countBy.mjs';
-export { differenceWith } from '../array/differenceWith.mjs';
 export { flatMap } from '../array/flatMap.mjs';
 export { flatMapDeep } from '../array/flatMapDeep.mjs';
 export { forEachRight } from '../array/forEachRight.mjs';
@@ -82,6 +81,7 @@ export { compact } from './array/compact.mjs';
 export { concat } from './array/concat.mjs';
 export { difference } from './array/difference.mjs';
 export { differenceBy } from './array/differenceBy.mjs';
+export { differenceWith } from './array/differenceWith.mjs';
 export { drop } from './array/drop.mjs';
 export { dropRight } from './array/dropRight.mjs';
 export { dropRightWhile } from './array/dropRightWhile.mjs';

package/dist/compat/index.d.ts

@@ -1,6 +1,5 @@
 export { at } from '../array/at.js';
 export { countBy } from '../array/countBy.js';
-export { differenceWith } from '../array/differenceWith.js';
 export { flatMap } from '../array/flatMap.js';
 export { flatMapDeep } from '../array/flatMapDeep.js';
 export { forEachRight } from '../array/forEachRight.js';
@@ -82,6 +81,7 @@ export { compact } from './array/compact.js';
 export { concat } from './array/concat.js';
 export { difference } from './array/difference.js';
 export { differenceBy } from './array/differenceBy.js';
+export { differenceWith } from './array/differenceWith.js';
 export { drop } from './array/drop.js';
 export { dropRight } from './array/dropRight.js';
 export { dropRightWhile } from './array/dropRightWhile.js';

package/dist/compat/index.js

@@ -496,6 +496,18 @@ function differenceBy(arr, ..._values) {
     return zipWith.differenceBy(Array.from(arr), values, iteratee(iteratee$1));
 }
 
+function differenceWith(array, ...values) {
+    if (!isArrayLikeObject(array)) {
+        return [];
+    }
+    const comparator = last(values);
+    const flattenedValues = flattenArrayLike(values);
+    if (typeof comparator === 'function') {
+        return zipWith.differenceWith(Array.from(array), flattenedValues, comparator);
+    }
+    return zipWith.difference(Array.from(array), flattenedValues);
+}
+
 function isSymbol(value) {
     return typeof value === 'symbol' || value instanceof Symbol;
 }
@@ -2807,7 +2819,6 @@ function toSafeInteger(value) {
 
 exports.at = zipWith.at;
 exports.countBy = zipWith.countBy;
-exports.differenceWith = zipWith.differenceWith;
 exports.flatMap = zipWith.flatMap;
 exports.flatMapDeep = zipWith.flatMapDeep;
 exports.forEachRight = zipWith.forEachRight;
@@ -2913,6 +2924,7 @@ exports.defaults = defaults;
 exports.defer = defer;
 exports.difference = difference;
 exports.differenceBy = differenceBy;
+exports.differenceWith = differenceWith;
 exports.drop = drop;
 exports.dropRight = dropRight;
 exports.dropRightWhile = dropRightWhile;

package/dist/compat/index.mjs

@@ -1,6 +1,5 @@
 export { at } from '../array/at.mjs';
 export { countBy } from '../array/countBy.mjs';
-export { differenceWith } from '../array/differenceWith.mjs';
 export { flatMap } from '../array/flatMap.mjs';
 export { flatMapDeep } from '../array/flatMapDeep.mjs';
 export { forEachRight } from '../array/forEachRight.mjs';
@@ -83,6 +82,7 @@ export { compact } from './array/compact.mjs';
 export { concat } from './array/concat.mjs';
 export { difference } from './array/difference.mjs';
 export { differenceBy } from './array/differenceBy.mjs';
+export { differenceWith } from './array/differenceWith.mjs';
 export { drop } from './array/drop.mjs';
 export { dropRight } from './array/dropRight.mjs';
 export { dropRightWhile } from './array/dropRightWhile.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.29.0-dev.932+e387b4f5",
+  "version": "1.29.0-dev.933+5b5194d3",
   "homepage": "https://es-toolkit.slash.page",
   "bugs": "https://github.com/toss/es-toolkit/issues",
   "repository": {