es-toolkit 1.30.1 → 1.31.0-dev.989

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # es-toolkit Changelog
 
+## Version v1.31.0
+
+Released on December 27th, 2024.
+
+- Added support for the [windowed](https://es-toolkit.slash.page/reference/array/windowed.html), [remove](https://es-toolkit.slash.page/reference/array/remove.html) and [asyncNoop](https://es-toolkit.slash.page/reference/function/asyncNoop.html) functions.
+- Introduced compatibility functions for [pullAll](https://es-toolkit.slash.page/reference/compat/array/pullAll.html), [subtract](https://es-toolkit.slash.page/reference/compat/math/subtract.html), [isBuffer](https://es-toolkit.slash.page/reference/predicate/isBuffer.html), and [methodOf](https://es-toolkit.slash.page/reference/compat/util/methodOf.html).
+- Enhanced the performance of [pull](https://es-toolkit.slash.page/reference/array/pull.html) when working with large arrays.
+- Resolved an issue where [reverse](https://es-toolkit.slash.page/reference/compat/array/reverse.html) was not being exported in our compatibility library.
+- Updated [groupBy](https://es-toolkit.slash.page/reference/array/groupBy.html) to properly handle keys like `toString` or `valueOf`.
+- Fixed [merge](https://es-toolkit.slash.page/reference/object/merge.html) to correctly merge values when `target` or any of its values are `null` or `undefined`.
+
+We sincerely thank @T3sT3ro, @D-Sketon, @tuhm1, @willmanduffy, @apeltop, @aken-you, @SaeWooKKang, and @ssi02014 for their contributions. We appreciate your great efforts!
+
 ## Version v1.30.1
 
 Released on December 14th, 2024.

package/dist/_chunk/{unary-CcTNuC.js → unary-B6qG7C.js}

@@ -19,6 +19,8 @@ function ary(func, n) {
     };
 }
 
+async function asyncNoop() { }
+
 function debounce(func, debounceMs, { signal, edges } = {}) {
     let pendingThis = undefined;
     let pendingArgs = null;
@@ -193,6 +195,7 @@ function unary(func) {
 
 exports.after = after;
 exports.ary = ary;
+exports.asyncNoop = asyncNoop;
 exports.debounce = debounce;
 exports.flow = flow;
 exports.flowRight = flowRight;

package/dist/_chunk/{zipWith-nbzldx.js → zipWith-Bdyzuy.js}

@@ -149,11 +149,11 @@ function forEachRight(arr, callback) {
 }
 
 function groupBy(arr, getKeyFromItem) {
-    const result = Object.create(null);
+    const result = {};
     for (let i = 0; i < arr.length; i++) {
         const item = arr[i];
         const key = getKeyFromItem(item);
-        if (result[key] == null) {
+        if (!Object.hasOwn(result, key)) {
             result[key] = [];
         }
         result[key].push(item);
@@ -256,11 +256,18 @@ function partition(arr, isInTruthy) {
 
 function pull(arr, valuesToRemove) {
     const valuesSet = new Set(valuesToRemove);
-    for (let i = arr.length - 1; i >= 0; i--) {
+    let resultIndex = 0;
+    for (let i = 0; i < arr.length; i++) {
         if (valuesSet.has(arr[i])) {
-            arr.splice(i, 1);
+            continue;
         }
+        if (!Object.hasOwn(arr, i)) {
+            delete arr[resultIndex++];
+            continue;
+        }
+        arr[resultIndex++] = arr[i];
     }
+    arr.length = resultIndex;
     return arr;
 }
 
@@ -273,6 +280,25 @@ function pullAt(arr, indicesToRemove) {
     return removed;
 }
 
+function remove(arr, shouldRemoveElement) {
+    const originalArr = arr.slice();
+    const removed = [];
+    let resultIndex = 0;
+    for (let i = 0; i < arr.length; i++) {
+        if (shouldRemoveElement(arr[i], i, originalArr)) {
+            removed.push(arr[i]);
+            continue;
+        }
+        if (!Object.hasOwn(arr, i)) {
+            delete arr[resultIndex++];
+            continue;
+        }
+        arr[resultIndex++] = arr[i];
+    }
+    arr.length = resultIndex;
+    return removed;
+}
+
 function sample(arr) {
     const randomIndex = Math.floor(Math.random() * arr.length);
     return arr[randomIndex];
@@ -412,6 +438,21 @@ function unzipWith(target, iteratee) {
     return result;
 }
 
+function windowed(arr, size, step = 1, { partialWindows = false } = {}) {
+    if (size <= 0 || !Number.isInteger(size)) {
+        throw new Error('Size must be a positive integer.');
+    }
+    if (step <= 0 || !Number.isInteger(step)) {
+        throw new Error('Step must be a positive integer.');
+    }
+    const result = [];
+    const end = partialWindows ? arr.length : arr.length - size + 1;
+    for (let i = 0; i < end; i += step) {
+        result.push(arr.slice(i, i + size));
+    }
+    return result;
+}
+
 function without(array, ...values) {
     return difference(array, values);
 }
@@ -503,6 +544,7 @@ exports.minBy = minBy;
 exports.partition = partition;
 exports.pull = pull;
 exports.pullAt = pullAt;
+exports.remove = remove;
 exports.sample = sample;
 exports.sampleSize = sampleSize;
 exports.shuffle = shuffle;
@@ -519,6 +561,7 @@ exports.uniqBy = uniqBy;
 exports.uniqWith = uniqWith;
 exports.unzip = unzip;
 exports.unzipWith = unzipWith;
+exports.windowed = windowed;
 exports.without = without;
 exports.xor = xor;
 exports.xorBy = xorBy;

package/dist/array/groupBy.mjs

@@ -1,9 +1,9 @@
 function groupBy(arr, getKeyFromItem) {
-    const result = Object.create(null);
+    const result = {};
     for (let i = 0; i < arr.length; i++) {
         const item = arr[i];
         const key = getKeyFromItem(item);
-        if (result[key] == null) {
+        if (!Object.hasOwn(result, key)) {
             result[key] = [];
         }
         result[key].push(item);

package/dist/array/index.d.mts

@@ -31,6 +31,7 @@ export { orderBy } from './orderBy.mjs';
 export { partition } from './partition.mjs';
 export { pull } from './pull.mjs';
 export { pullAt } from './pullAt.mjs';
+export { remove } from './remove.mjs';
 export { sample } from './sample.mjs';
 export { sampleSize } from './sampleSize.mjs';
 export { shuffle } from './shuffle.mjs';
@@ -49,6 +50,7 @@ export { uniqBy } from './uniqBy.mjs';
 export { uniqWith } from './uniqWith.mjs';
 export { unzip } from './unzip.mjs';
 export { unzipWith } from './unzipWith.mjs';
+export { windowed } from './windowed.mjs';
 export { without } from './without.mjs';
 export { xor } from './xor.mjs';
 export { xorBy } from './xorBy.mjs';

package/dist/array/index.d.ts

@@ -31,6 +31,7 @@ export { orderBy } from './orderBy.js';
 export { partition } from './partition.js';
 export { pull } from './pull.js';
 export { pullAt } from './pullAt.js';
+export { remove } from './remove.js';
 export { sample } from './sample.js';
 export { sampleSize } from './sampleSize.js';
 export { shuffle } from './shuffle.js';
@@ -49,6 +50,7 @@ export { uniqBy } from './uniqBy.js';
 export { uniqWith } from './uniqWith.js';
 export { unzip } from './unzip.js';
 export { unzipWith } from './unzipWith.js';
+export { windowed } from './windowed.js';
 export { without } from './without.js';
 export { xor } from './xor.js';
 export { xorBy } from './xorBy.js';

package/dist/array/index.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const zipWith = require('../_chunk/zipWith-nbzldx.js');
+const zipWith = require('../_chunk/zipWith-Bdyzuy.js');
 
 function compareValues(a, b, order) {
     if (a < b) {
@@ -77,6 +77,7 @@ exports.minBy = zipWith.minBy;
 exports.partition = zipWith.partition;
 exports.pull = zipWith.pull;
 exports.pullAt = zipWith.pullAt;
+exports.remove = zipWith.remove;
 exports.sample = zipWith.sample;
 exports.sampleSize = zipWith.sampleSize;
 exports.shuffle = zipWith.shuffle;
@@ -93,6 +94,7 @@ exports.uniqBy = zipWith.uniqBy;
 exports.uniqWith = zipWith.uniqWith;
 exports.unzip = zipWith.unzip;
 exports.unzipWith = zipWith.unzipWith;
+exports.windowed = zipWith.windowed;
 exports.without = zipWith.without;
 exports.xor = zipWith.xor;
 exports.xorBy = zipWith.xorBy;

package/dist/array/index.mjs

@@ -31,6 +31,7 @@ export { orderBy } from './orderBy.mjs';
 export { partition } from './partition.mjs';
 export { pull } from './pull.mjs';
 export { pullAt } from './pullAt.mjs';
+export { remove } from './remove.mjs';
 export { sample } from './sample.mjs';
 export { sampleSize } from './sampleSize.mjs';
 export { shuffle } from './shuffle.mjs';
@@ -49,6 +50,7 @@ export { uniqBy } from './uniqBy.mjs';
 export { uniqWith } from './uniqWith.mjs';
 export { unzip } from './unzip.mjs';
 export { unzipWith } from './unzipWith.mjs';
+export { windowed } from './windowed.mjs';
 export { without } from './without.mjs';
 export { xor } from './xor.mjs';
 export { xorBy } from './xorBy.mjs';

package/dist/array/pull.mjs

@@ -1,10 +1,17 @@
 function pull(arr, valuesToRemove) {
     const valuesSet = new Set(valuesToRemove);
-    for (let i = arr.length - 1; i >= 0; i--) {
+    let resultIndex = 0;
+    for (let i = 0; i < arr.length; i++) {
         if (valuesSet.has(arr[i])) {
-            arr.splice(i, 1);
+            continue;
         }
+        if (!Object.hasOwn(arr, i)) {
+            delete arr[resultIndex++];
+            continue;
+        }
+        arr[resultIndex++] = arr[i];
     }
+    arr.length = resultIndex;
     return arr;
 }
 

package/dist/array/remove.d.mts

@@ -0,0 +1,19 @@
+/**
+ * Removes elements from an array based on a predicate function.
+ *
+ * This function changes `arr` in place.
+ * If you want to remove elements without modifying the original array, use `filter`.
+ *
+ * @template T
+ * @param {T[]} arr - The array to modify.
+ * @param {(value: T, index: number, array: T[]) => boolean} shouldRemoveElement - The function invoked per iteration to determine if an element should be removed.
+ * @returns {T[]} The modified array with the specified elements removed.
+ *
+ * @example
+ * const numbers = [1, 2, 3, 4, 5];
+ * remove(numbers, (value) => value % 2 === 0);
+ * console.log(numbers); // [1, 3, 5]
+ */
+declare function remove<T>(arr: T[], shouldRemoveElement: (value: T, index: number, array: T[]) => boolean): T[];
+
+export { remove };

package/dist/array/remove.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Removes elements from an array based on a predicate function.
+ *
+ * This function changes `arr` in place.
+ * If you want to remove elements without modifying the original array, use `filter`.
+ *
+ * @template T
+ * @param {T[]} arr - The array to modify.
+ * @param {(value: T, index: number, array: T[]) => boolean} shouldRemoveElement - The function invoked per iteration to determine if an element should be removed.
+ * @returns {T[]} The modified array with the specified elements removed.
+ *
+ * @example
+ * const numbers = [1, 2, 3, 4, 5];
+ * remove(numbers, (value) => value % 2 === 0);
+ * console.log(numbers); // [1, 3, 5]
+ */
+declare function remove<T>(arr: T[], shouldRemoveElement: (value: T, index: number, array: T[]) => boolean): T[];
+
+export { remove };

package/dist/array/remove.mjs

@@ -0,0 +1,20 @@
+function remove(arr, shouldRemoveElement) {
+    const originalArr = arr.slice();
+    const removed = [];
+    let resultIndex = 0;
+    for (let i = 0; i < arr.length; i++) {
+        if (shouldRemoveElement(arr[i], i, originalArr)) {
+            removed.push(arr[i]);
+            continue;
+        }
+        if (!Object.hasOwn(arr, i)) {
+            delete arr[resultIndex++];
+            continue;
+        }
+        arr[resultIndex++] = arr[i];
+    }
+    arr.length = resultIndex;
+    return removed;
+}
+
+export { remove };

package/dist/array/windowed.d.mts

@@ -0,0 +1,50 @@
+/**
+ * Options for the windowed function.
+ *
+ * @interface WindowedOptions
+ * @property {boolean} [partialWindows=false] - Whether to include partial windows at the end of the array.
+ */
+interface WindowedOptions {
+    /**
+     * Whether to include partial windows at the end of the array.
+     *
+     * By default, `windowed` only includes full windows in the result,
+     * ignoring any leftover elements that can't form a full window.
+     *
+     * If `partialWindows` is true, the function will also include these smaller, partial windows at the end of the result.
+     */
+    partialWindows?: boolean;
+}
+/**
+ * Creates an array of sub-arrays (windows) from the input array, each of the specified size.
+ * The windows can overlap depending on the step size provided.
+ *
+ * By default, only full windows are included in the result, and any leftover elements that can't form a full window are ignored.
+ *
+ * If the `partialWindows` option is set to true in the options object, the function will also include partial windows at the end of the result.
+ * Partial windows are smaller sub-arrays created when there aren't enough elements left in the input array to form a full window.
+ *
+ * @template T
+ * @param {readonly T[]} arr - The input array to create windows from.
+ * @param {number} size - The size of each window. Must be a positive integer.
+ * @param {number} [step=1] - The step size between the start of each window. Must be a positive integer.
+ * @param {WindowedOptions} [options={}] - Options object to configure the behavior of the function.
+ * @param {boolean} [options.partialWindows=false] - Whether to include partial windows at the end of the array.
+ * @returns {T[][]} An array of windows (sub-arrays) created from the input array.
+ * @throws {Error} If the size or step is not a positive integer.
+ *
+ * @example
+ * windowed([1, 2, 3, 4], 2);
+ * // => [[1, 2], [2, 3], [3, 4]]
+ *
+ * @example
+ * windowed([1, 2, 3, 4, 5, 6], 3, 2);
+ * // => [[1, 2, 3], [3, 4, 5]]
+ *
+ * @example
+ * windowed([1, 2, 3, 4, 5, 6], 3, 2, { partialWindows: true });
+ * // => [[1, 2, 3], [3, 4, 5], [5, 6]]
+ */
+declare function windowed<T>(arr: readonly T[], size: number, step?: number, { partialWindows }?: WindowedOptions): T[][];
+
+export { type WindowedOptions, windowed };

package/dist/array/windowed.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Options for the windowed function.
+ *
+ * @interface WindowedOptions
+ * @property {boolean} [partialWindows=false] - Whether to include partial windows at the end of the array.
+ */
+interface WindowedOptions {
+    /**
+     * Whether to include partial windows at the end of the array.
+     *
+     * By default, `windowed` only includes full windows in the result,
+     * ignoring any leftover elements that can't form a full window.
+     *
+     * If `partialWindows` is true, the function will also include these smaller, partial windows at the end of the result.
+     */
+    partialWindows?: boolean;
+}
+/**
+ * Creates an array of sub-arrays (windows) from the input array, each of the specified size.
+ * The windows can overlap depending on the step size provided.
+ *
+ * By default, only full windows are included in the result, and any leftover elements that can't form a full window are ignored.
+ *
+ * If the `partialWindows` option is set to true in the options object, the function will also include partial windows at the end of the result.
+ * Partial windows are smaller sub-arrays created when there aren't enough elements left in the input array to form a full window.
+ *
+ * @template T
+ * @param {readonly T[]} arr - The input array to create windows from.
+ * @param {number} size - The size of each window. Must be a positive integer.
+ * @param {number} [step=1] - The step size between the start of each window. Must be a positive integer.
+ * @param {WindowedOptions} [options={}] - Options object to configure the behavior of the function.
+ * @param {boolean} [options.partialWindows=false] - Whether to include partial windows at the end of the array.
+ * @returns {T[][]} An array of windows (sub-arrays) created from the input array.
+ * @throws {Error} If the size or step is not a positive integer.
+ *
+ * @example
+ * windowed([1, 2, 3, 4], 2);
+ * // => [[1, 2], [2, 3], [3, 4]]
+ *
+ * @example
+ * windowed([1, 2, 3, 4, 5, 6], 3, 2);
+ * // => [[1, 2, 3], [3, 4, 5]]
+ *
+ * @example
+ * windowed([1, 2, 3, 4, 5, 6], 3, 2, { partialWindows: true });
+ * // => [[1, 2, 3], [3, 4, 5], [5, 6]]
+ */
+declare function windowed<T>(arr: readonly T[], size: number, step?: number, { partialWindows }?: WindowedOptions): T[][];
+
+export { type WindowedOptions, windowed };

package/dist/array/windowed.mjs

@@ -0,0 +1,16 @@
+function windowed(arr, size, step = 1, { partialWindows = false } = {}) {
+    if (size <= 0 || !Number.isInteger(size)) {
+        throw new Error('Size must be a positive integer.');
+    }
+    if (step <= 0 || !Number.isInteger(step)) {
+        throw new Error('Step must be a positive integer.');
+    }
+    const result = [];
+    const end = partialWindows ? arr.length : arr.length - size + 1;
+    for (let i = 0; i < end; i += step) {
+        result.push(arr.slice(i, i + size));
+    }
+    return result;
+}
+
+export { windowed };