es-toolkit 1.23.0 → 1.24.0-dev.764

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # es-toolkit Changelog
 
+## Version v1.24.0
+
+Released on October 7th, 2024.
+
+- Added support for [isBlob](https://es-toolkit.slash.page/reference/predicate/isBlob.html) and [isDate](https://es-toolkit.slash.page/reference/predicate/isDate.html).
+- Added compatibility functions for [invertBy](https://es-toolkit.slash.page/reference/compat/object/invertBy.html), [times](https://es-toolkit.slash.page/reference/compat/util/times.html), [constant](https://es-toolkit.slash.page/reference/compat/util/constant.html), [slice](https://es-toolkit.slash.page/reference/compat/array/slice.html), [toLength](https://es-toolkit.slash.page/reference/compat/util/toLength.html), [defaultTo](https://es-toolkit.slash.page/reference/compat/util/defaultTo.html), [dropRightWhile](https://es-toolkit.slash.page/reference/array/dropRightWhile.html), [curryRight](https://es-toolkit.slash.page/reference/function/curryRight.html), [rangeRight](https://es-toolkit.slash.page/reference/math/rangeRight.html), [before](https://es-toolkit.slash.page/reference/function/before.html), [eq](https://es-toolkit.slash.page/reference/compat/util/eq.html), [defaults](https://es-toolkit.slash.page/reference/compat/object/defaults.html), [toDefaulted](https://es-toolkit.slash.page/reference/compat/object/toDefaulted.html), [isArrayBuffer](https://es-toolkit.slash.page/reference/predicate/isArrayBuffer.html), [isSet](https://es-toolkit.slash.page/reference/predicate/isSet.html), and [isMap](https://es-toolkit.slash.page/reference/predicate/isMap.html).
+- Enhanced [difference](https://es-toolkit.slash.page/reference/array/difference.html) to work with Array-like objects, aligning its functionality with lodash's behavior.
+- Improved performance for [pickBy](https://es-toolkit.slash.page/reference/object/pickBy.html) and [omitBy](https://es-toolkit.slash.page/reference/object/omitBy.html).
+
 ## Version v1.23.0
 
 Released on October 1st, 2024.

package/README.md

@@ -16,7 +16,7 @@ es-toolkit is a state-of-the-art, high-performance JavaScript utility library wi
 
 ```tsx
 // import from '@es-toolkit/es-toolkit' in jsr.
-import { debounce, chunk } from 'es-toolkit';
+import { chunk, debounce } from 'es-toolkit';
 
 const debouncedLog = debounce(message => {
   console.log(message);

package/dist/_chunk/{isWeakSet-BAMm2l.js → isWeakSet-Bd6nry.js}

@@ -7,6 +7,13 @@ function isArrayBuffer(value) {
     return value instanceof ArrayBuffer;
 }
 
+function isBlob(x) {
+    if (typeof Blob === 'undefined') {
+        return false;
+    }
+    return x instanceof Blob;
+}
+
 function isDate(value) {
     return value instanceof Date;
 }
@@ -49,6 +56,10 @@ const bigInt64ArrayTag = '[object BigInt64Array]';
 const float32ArrayTag = '[object Float32Array]';
 const float64ArrayTag = '[object Float64Array]';
 
+function eq(value, other) {
+    return value === other || (Number.isNaN(value) && Number.isNaN(other));
+}
+
 function isEqualWith(a, b, areValuesEqual) {
     return isEqualWithImpl(a, b, undefined, undefined, undefined, undefined, areValuesEqual);
 }
@@ -100,7 +111,7 @@ function areObjectsEqual(a, b, stack, areValuesEqual) {
         case numberTag: {
             const x = a.valueOf();
             const y = b.valueOf();
-            return x === y || (Number.isNaN(x) && Number.isNaN(y));
+            return eq(x, y);
         }
         case booleanTag:
         case dateTag:
@@ -231,43 +242,26 @@ function isEqual(a, b) {
     return isEqualWith(a, b, noop.noop);
 }
 
-function isMap(value) {
-    return value instanceof Map;
-}
-
-function isNil(x) {
-    return x == null;
-}
-
-function isNotNil(x) {
-    return x != null;
-}
-
-function isNull(x) {
-    return x === null;
-}
-
-function isUndefined(x) {
-    return x === undefined;
-}
-
-function isLength(value) {
-    return Number.isSafeInteger(value) && value >= 0;
-}
-
 function isFunction(value) {
     return typeof value === 'function';
 }
 
-function isRegExp(value) {
-    return value instanceof RegExp;
-}
-
-function isJSONArray(value) {
-    if (!Array.isArray(value)) {
+function isJSONObject(obj) {
+    if (!isPlainObject.isPlainObject(obj)) {
         return false;
     }
-    return value.every(item => isJSONValue(item));
+    const keys = Reflect.ownKeys(obj);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const value = obj[key];
+        if (typeof key !== 'string') {
+            return false;
+        }
+        if (!isJSONValue(value)) {
+            return false;
+        }
+    }
+    return true;
 }
 
 function isJSONValue(value) {
@@ -286,28 +280,45 @@ function isJSONValue(value) {
     }
 }
 
-function isJSONObject(obj) {
-    if (!isPlainObject.isPlainObject(obj)) {
+function isJSONArray(value) {
+    if (!Array.isArray(value)) {
         return false;
     }
-    const keys = Reflect.ownKeys(obj);
-    for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
-        const value = obj[key];
-        if (typeof key !== 'string') {
-            return false;
-        }
-        if (!isJSONValue(value)) {
-            return false;
-        }
-    }
-    return true;
+    return value.every(item => isJSONValue(item));
+}
+
+function isLength(value) {
+    return Number.isSafeInteger(value) && value >= 0;
+}
+
+function isMap(value) {
+    return value instanceof Map;
+}
+
+function isNil(x) {
+    return x == null;
+}
+
+function isNotNil(x) {
+    return x != null;
+}
+
+function isNull(x) {
+    return x === null;
+}
+
+function isRegExp(value) {
+    return value instanceof RegExp;
 }
 
 function isSet(value) {
     return value instanceof Set;
 }
 
+function isUndefined(x) {
+    return x === undefined;
+}
+
 function isWeakMap(value) {
     return value instanceof WeakMap;
 }
@@ -318,9 +329,11 @@ function isWeakSet(value) {
 
 exports.argumentsTag = argumentsTag;
 exports.booleanTag = booleanTag;
+exports.eq = eq;
 exports.getSymbols = getSymbols;
 exports.getTag = getTag;
 exports.isArrayBuffer = isArrayBuffer;
+exports.isBlob = isBlob;
 exports.isDate = isDate;
 exports.isEqual = isEqual;
 exports.isEqualWith = isEqualWith;

package/dist/_chunk/{range-BXlMmn.js → sumBy-BkErWJ.js}

@@ -35,11 +35,6 @@ function meanBy(items, getValue) {
     return mean(nums);
 }
 
-function sumBy(items, getValue) {
-    const nums = items.map(x => getValue(x));
-    return sum(nums);
-}
-
 function range(start, end, step) {
     if (end == null) {
         end = start;
@@ -59,10 +54,35 @@ function range(start, end, step) {
     return result;
 }
 
+function rangeRight(start, end, step) {
+    if (end == null) {
+        end = start;
+        start = 0;
+    }
+    if (step == null) {
+        step = 1;
+    }
+    if (!Number.isInteger(step) || step === 0) {
+        throw new Error(`The step value must be a non-zero integer.`);
+    }
+    const length = Math.max(Math.ceil((end - start) / step), 0);
+    const result = new Array(length);
+    for (let i = 0; i < length; i++) {
+        result[i] = start + (length - i - 1) * step;
+    }
+    return result;
+}
+
+function sumBy(items, getValue) {
+    const nums = items.map(x => getValue(x));
+    return sum(nums);
+}
+
 exports.clamp = clamp;
 exports.inRange = inRange;
 exports.mean = mean;
 exports.meanBy = meanBy;
 exports.range = range;
+exports.rangeRight = rangeRight;
 exports.sum = sum;
 exports.sumBy = sumBy;

package/dist/_chunk/{isObjectLike-aywuSF.js → toMerged-DDLv0D.js}

@@ -2,41 +2,6 @@
 
 const isPlainObject = require('./isPlainObject-DgrsU7.js');
 
-function omitBy(obj, shouldOmit) {
-    const result = {};
-    const objEntries = Object.entries(obj);
-    for (let i = 0; i < objEntries.length; i++) {
-        const [key, value] = objEntries[i];
-        if (!shouldOmit(value, key)) {
-            result[key] = value;
-        }
-    }
-    return result;
-}
-
-function pickBy(obj, shouldPick) {
-    const result = {};
-    const objEntries = Object.entries(obj);
-    for (let i = 0; i < objEntries.length; i++) {
-        const [key, value] = objEntries[i];
-        if (shouldPick(value, key)) {
-            result[key] = value;
-        }
-    }
-    return result;
-}
-
-function invert(obj) {
-    const result = {};
-    const keys = Object.keys(obj);
-    for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
-        const value = obj[key];
-        result[value] = key;
-    }
-    return result;
-}
-
 function clone(obj) {
     if (isPlainObject.isPrimitive(obj)) {
         return obj;
@@ -78,53 +43,6 @@ function clone(obj) {
     return obj;
 }
 
-function flattenObject(object) {
-    return flattenObjectImpl(object);
-}
-function flattenObjectImpl(object, prefix = '') {
-    const result = {};
-    const keys = Object.keys(object);
-    for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
-        const value = object[key];
-        const prefixedKey = prefix ? `${prefix}.${key}` : key;
-        if (isPlainObject.isPlainObject(value) && Object.keys(value).length > 0) {
-            Object.assign(result, flattenObjectImpl(value, prefixedKey));
-            continue;
-        }
-        if (Array.isArray(value)) {
-            for (let index = 0; index < value.length; index++) {
-                result[`${prefixedKey}.${index}`] = value[index];
-            }
-            continue;
-        }
-        result[prefixedKey] = value;
-    }
-    return result;
-}
-
-function mapKeys(object, getNewKey) {
-    const result = {};
-    const keys = Object.keys(object);
-    for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
-        const value = object[key];
-        result[getNewKey(value, key, object)] = value;
-    }
-    return result;
-}
-
-function mapValues(object, getNewValue) {
-    const result = {};
-    const keys = Object.keys(object);
-    for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
-        const value = object[key];
-        result[key] = getNewValue(value, key, object);
-    }
-    return result;
-}
-
 function cloneDeep(obj) {
     return cloneDeepImpl(obj);
 }
@@ -234,6 +152,64 @@ function copyProperties(target, source, stack) {
     }
 }
 
+function flattenObject(object) {
+    return flattenObjectImpl(object);
+}
+function flattenObjectImpl(object, prefix = '') {
+    const result = {};
+    const keys = Object.keys(object);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const value = object[key];
+        const prefixedKey = prefix ? `${prefix}.${key}` : key;
+        if (isPlainObject.isPlainObject(value) && Object.keys(value).length > 0) {
+            Object.assign(result, flattenObjectImpl(value, prefixedKey));
+            continue;
+        }
+        if (Array.isArray(value)) {
+            for (let index = 0; index < value.length; index++) {
+                result[`${prefixedKey}.${index}`] = value[index];
+            }
+            continue;
+        }
+        result[prefixedKey] = value;
+    }
+    return result;
+}
+
+function invert(obj) {
+    const result = {};
+    const keys = Object.keys(obj);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const value = obj[key];
+        result[value] = key;
+    }
+    return result;
+}
+
+function mapKeys(object, getNewKey) {
+    const result = {};
+    const keys = Object.keys(object);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const value = object[key];
+        result[getNewKey(value, key, object)] = value;
+    }
+    return result;
+}
+
+function mapValues(object, getNewValue) {
+    const result = {};
+    const keys = Object.keys(object);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const value = object[key];
+        result[key] = getNewValue(value, key, object);
+    }
+    return result;
+}
+
 function merge(target, source) {
     const sourceKeys = Object.keys(source);
     for (let i = 0; i < sourceKeys.length; i++) {
@@ -263,14 +239,40 @@ function merge(target, source) {
     return target;
 }
 
-function toMerged(target, source) {
-    return merge(cloneDeep(target), source);
-}
-
 function isObjectLike(value) {
     return typeof value === 'object' && value !== null;
 }
 
+function omitBy(obj, shouldOmit) {
+    const result = {};
+    const keys = Object.keys(obj);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const value = obj[key];
+        if (!shouldOmit(value, key)) {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+
+function pickBy(obj, shouldPick) {
+    const result = {};
+    const keys = Object.keys(obj);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const value = obj[key];
+        if (shouldPick(value, key)) {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+
+function toMerged(target, source) {
+    return merge(cloneDeep(target), source);
+}
+
 exports.clone = clone;
 exports.cloneDeep = cloneDeep;
 exports.copyProperties = copyProperties;

package/dist/_chunk/{flowRight-Dv8J0U.js → unary-BZ5Ixo.js}

@@ -1,18 +1,5 @@
 'use strict';
 
-function before(n, func) {
-    if (!Number.isInteger(n) || n < 0) {
-        throw new Error('n must be a non-negative integer.');
-    }
-    let counter = 0;
-    return ((...args) => {
-        if (++counter < n) {
-            return func(...args);
-        }
-        return undefined;
-    });
-}
-
 function after(n, func) {
     if (!Number.isInteger(n) || n < 0) {
         throw new Error(`n must be a non-negative integer.`);
@@ -26,6 +13,12 @@ function after(n, func) {
     });
 }
 
+function ary(func, n) {
+    return function (...args) {
+        return func.apply(this, args.slice(0, n));
+    };
+}
+
 function debounce(func, debounceMs, { signal, edges } = {}) {
     let pendingThis = undefined;
     let pendingArgs = null;
@@ -88,22 +81,18 @@ function debounce(func, debounceMs, { signal, edges } = {}) {
     return debounced;
 }
 
-function once(func) {
-    let called = false;
-    let cache;
-    return function () {
-        if (called) {
-            return cache;
+function flow(...funcs) {
+    return function (...args) {
+        let result = funcs.length ? funcs[0].apply(this, args) : args[0];
+        for (let i = 1; i < funcs.length; i++) {
+            result = funcs[i].call(this, result);
         }
-        const result = func();
-        called = true;
-        cache = result;
         return result;
     };
 }
 
-function negate(func) {
-    return ((...args) => !func(...args));
+function flowRight(...funcs) {
+    return flow(...funcs.reverse());
 }
 
 function memoize(fn, options = {}) {
@@ -121,14 +110,20 @@ function memoize(fn, options = {}) {
     return memoizedFn;
 }
 
-function ary(func, n) {
-    return function (...args) {
-        return func.apply(this, args.slice(0, n));
-    };
+function negate(func) {
+    return ((...args) => !func(...args));
 }
 
-function unary(func) {
-    return ary(func, 1);
+function once(func) {
+    let called = false;
+    let cache;
+    return function (...args) {
+        if (!called) {
+            called = true;
+            cache = func(...args);
+        }
+        return cache;
+    };
 }
 
 function partial(func, ...partialArgs) {
@@ -188,44 +183,12 @@ function rest(func, startIndex = func.length - 1) {
     };
 }
 
-function curryRight(func) {
-    if (func.length === 0 || func.length === 1) {
-        return func;
-    }
-    return function (arg) {
-        return makeCurryRight(func, func.length, [arg]);
-    };
-}
-function makeCurryRight(origin, argsLength, args) {
-    if (args.length === argsLength) {
-        return origin(...args);
-    }
-    else {
-        const next = function (arg) {
-            return makeCurryRight(origin, argsLength, [arg, ...args]);
-        };
-        return next;
-    }
-}
-
-function flow(...funcs) {
-    return function (...args) {
-        let result = funcs.length ? funcs[0].apply(this, args) : args[0];
-        for (let i = 1; i < funcs.length; i++) {
-            result = funcs[i].call(this, result);
-        }
-        return result;
-    };
-}
-
-function flowRight(...funcs) {
-    return flow(...funcs.reverse());
+function unary(func) {
+    return ary(func, 1);
 }
 
 exports.after = after;
 exports.ary = ary;
-exports.before = before;
-exports.curryRight = curryRight;
 exports.debounce = debounce;
 exports.flow = flow;
 exports.flowRight = flowRight;

package/dist/_chunk/{zipWith-EOU_KZ.js → zipWith-wpjySR.js}

@@ -76,7 +76,7 @@ function dropRight(arr, itemsCount) {
 
 function dropRightWhile(arr, canContinueDropping) {
     for (let i = arr.length - 1; i >= 0; i--) {
-        if (!canContinueDropping(arr[i])) {
+        if (!canContinueDropping(arr[i], i, arr)) {
             return arr.slice(0, i + 1);
         }
     }
@@ -335,11 +335,10 @@ function union(arr1, arr2) {
     return uniq(arr1.concat(arr2));
 }
 
-function unionBy(arr1, arr2, mapper) {
+function uniqBy(arr, mapper) {
     const map = new Map();
-    const items = [...arr1, ...arr2];
-    for (let i = 0; i < items.length; i++) {
-        const item = items[i];
+    for (let i = 0; i < arr.length; i++) {
+        const item = arr[i];
         const key = mapper(item);
         if (!map.has(key)) {
             map.set(key, item);
@@ -348,6 +347,10 @@ function unionBy(arr1, arr2, mapper) {
     return Array.from(map.values());
 }
 
+function unionBy(arr1, arr2, mapper) {
+    return uniqBy(arr1.concat(arr2), mapper);
+}
+
 function uniqWith(arr, areItemsEqual) {
     const result = [];
     for (let i = 0; i < arr.length; i++) {
@@ -364,18 +367,6 @@ function unionWith(arr1, arr2, areItemsEqual) {
     return uniqWith(arr1.concat(arr2), areItemsEqual);
 }
 
-function uniqBy(arr, mapper) {
-    const map = new Map();
-    for (let i = 0; i < arr.length; i++) {
-        const item = arr[i];
-        const key = mapper(item);
-        if (!map.has(key)) {
-            map.set(key, item);
-        }
-    }
-    return Array.from(map.values());
-}
-
 function unzip(zipped) {
     let maxLen = 0;
     for (let i = 0; i < zipped.length; i++) {

package/dist/array/dropRightWhile.d.mts

@@ -6,7 +6,7 @@
  *
  * @template T - The type of elements in the array.
  * @param {T[]} arr - The array from which to drop elements.
- * @param {(item: T) => boolean} canContinueDropping - A predicate function that determines
+ * @param {(item: T, index: number, arr: T[]) => boolean} canContinueDropping - A predicate function that determines
  * whether to continue dropping elements. The function is called with each element from the end,
  * and dropping continues as long as it returns true.
  * @returns {T[]} A new array with the elements remaining after the predicate returns false.
@@ -16,6 +16,6 @@
  * const result = dropRightWhile(array, x => x > 3);
  * // result will be [1, 2, 3] since elements greater than 3 are dropped from the end.
  */
-declare function dropRightWhile<T>(arr: readonly T[], canContinueDropping: (item: T) => boolean): T[];
+declare function dropRightWhile<T>(arr: readonly T[], canContinueDropping: (item: T, index: number, arr: readonly T[]) => boolean): T[];
 
 export { dropRightWhile };

package/dist/array/dropRightWhile.d.ts

@@ -6,7 +6,7 @@
  *
  * @template T - The type of elements in the array.
  * @param {T[]} arr - The array from which to drop elements.
- * @param {(item: T) => boolean} canContinueDropping - A predicate function that determines
+ * @param {(item: T, index: number, arr: T[]) => boolean} canContinueDropping - A predicate function that determines
  * whether to continue dropping elements. The function is called with each element from the end,
  * and dropping continues as long as it returns true.
  * @returns {T[]} A new array with the elements remaining after the predicate returns false.
@@ -16,6 +16,6 @@
  * const result = dropRightWhile(array, x => x > 3);
  * // result will be [1, 2, 3] since elements greater than 3 are dropped from the end.
  */
-declare function dropRightWhile<T>(arr: readonly T[], canContinueDropping: (item: T) => boolean): T[];
+declare function dropRightWhile<T>(arr: readonly T[], canContinueDropping: (item: T, index: number, arr: readonly T[]) => boolean): T[];
 
 export { dropRightWhile };

package/dist/array/dropRightWhile.mjs

@@ -1,6 +1,6 @@
 function dropRightWhile(arr, canContinueDropping) {
     for (let i = arr.length - 1; i >= 0; i--) {
-        if (!canContinueDropping(arr[i])) {
+        if (!canContinueDropping(arr[i], i, arr)) {
             return arr.slice(0, i + 1);
         }
     }

package/dist/array/dropWhile.d.mts

@@ -6,7 +6,7 @@
  *
  * @template T - The type of elements in the array.
  * @param {T[]} arr - The array from which to drop elements.
- * @param {(item: T) => boolean} canContinueDropping - A predicate function that determines
+ * @param {(item: T, index: number, arr: T[]) => boolean} canContinueDropping - A predicate function that determines
  * whether to continue dropping elements. The function is called with each element, and dropping
  * continues as long as it returns true.
  * @returns {T[]} A new array with the elements remaining after the predicate returns false.

package/dist/array/dropWhile.d.ts

@@ -6,7 +6,7 @@
  *
  * @template T - The type of elements in the array.
  * @param {T[]} arr - The array from which to drop elements.
- * @param {(item: T) => boolean} canContinueDropping - A predicate function that determines
+ * @param {(item: T, index: number, arr: T[]) => boolean} canContinueDropping - A predicate function that determines
  * whether to continue dropping elements. The function is called with each element, and dropping
  * continues as long as it returns true.
  * @returns {T[]} A new array with the elements remaining after the predicate returns false.