es-toolkit 1.31.0 → 1.32.0-dev.1003

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # es-toolkit Changelog
 
+## Version v1.32.0
+
+Released on January 30th, 2024.
+
+- Added support for [Semaphore](https://es-toolkit.slash.page/reference/promise/Semaphore.html), [Mutex](https://es-toolkit.slash.page/reference/promise/Mutex.html), [isPromise](https://es-toolkit.slash.page/reference/predicate/isPromise.html), and [retry](https://es-toolkit.slash.page/reference/function/retry.html).
+- Introduced compatibility functions for [multiply](https://es-toolkit.slash.page/reference/compat/math/multiply.html), [sortedIndex](https://es-toolkit.slash.page/reference/compat/array/sortedIndex.html), and [sortedIndexBy](https://es-toolkit.slash.page/reference/compat/array/sortedIndexBy.html).
+- Added support for custom delimiters in [flattenObject](https://es-toolkit.slash.page/reference/object/flattenObject.html).
+- Added support for `fromIndex` parameters in [find](https://es-toolkit.slash.page/reference/compat/array/find.html).
+- Fixed a bug in [cloneDeep](https://es-toolkit.slash.page/reference/object/cloneDeep.html) and [cloneDeepWith](https://es-toolkit.slash.page/reference/object/cloneDeepWith.html) that cloned uncloneable objects.
+
 ## Version v1.31.0
 
 Released on December 27th, 2024.

package/dist/_chunk/AbortError-Cg4ZQ1.js

@@ -0,0 +1,10 @@
+'use strict';
+
+class AbortError extends Error {
+    constructor(message = 'The operation was aborted') {
+        super(message);
+        this.name = 'AbortError';
+    }
+}
+
+exports.AbortError = AbortError;

package/dist/_chunk/delay-_VMfFa.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const AbortError = require('./AbortError-Cg4ZQ1.js');
+
+function delay(ms, { signal } = {}) {
+    return new Promise((resolve, reject) => {
+        const abortError = () => {
+            reject(new AbortError.AbortError());
+        };
+        const abortHandler = () => {
+            clearTimeout(timeoutId);
+            abortError();
+        };
+        if (signal?.aborted) {
+            return abortError();
+        }
+        const timeoutId = setTimeout(() => {
+            signal?.removeEventListener('abort', abortHandler);
+            resolve();
+        }, ms);
+        signal?.addEventListener('abort', abortHandler, { once: true });
+    });
+}
+
+exports.delay = delay;

package/dist/_chunk/isPlainObject-Xaozpc.js

@@ -0,0 +1,93 @@
+'use strict';
+
+function isPrimitive(value) {
+    return value == null || (typeof value !== 'object' && typeof value !== 'function');
+}
+
+function isTypedArray(x) {
+    return ArrayBuffer.isView(x) && !(x instanceof DataView);
+}
+
+function getSymbols(object) {
+    return Object.getOwnPropertySymbols(object).filter(symbol => Object.prototype.propertyIsEnumerable.call(object, symbol));
+}
+
+function getTag(value) {
+    if (value == null) {
+        return value === undefined ? '[object Undefined]' : '[object Null]';
+    }
+    return Object.prototype.toString.call(value);
+}
+
+const regexpTag = '[object RegExp]';
+const stringTag = '[object String]';
+const numberTag = '[object Number]';
+const booleanTag = '[object Boolean]';
+const argumentsTag = '[object Arguments]';
+const symbolTag = '[object Symbol]';
+const dateTag = '[object Date]';
+const mapTag = '[object Map]';
+const setTag = '[object Set]';
+const arrayTag = '[object Array]';
+const functionTag = '[object Function]';
+const arrayBufferTag = '[object ArrayBuffer]';
+const objectTag = '[object Object]';
+const errorTag = '[object Error]';
+const dataViewTag = '[object DataView]';
+const uint8ArrayTag = '[object Uint8Array]';
+const uint8ClampedArrayTag = '[object Uint8ClampedArray]';
+const uint16ArrayTag = '[object Uint16Array]';
+const uint32ArrayTag = '[object Uint32Array]';
+const bigUint64ArrayTag = '[object BigUint64Array]';
+const int8ArrayTag = '[object Int8Array]';
+const int16ArrayTag = '[object Int16Array]';
+const int32ArrayTag = '[object Int32Array]';
+const bigInt64ArrayTag = '[object BigInt64Array]';
+const float32ArrayTag = '[object Float32Array]';
+const float64ArrayTag = '[object Float64Array]';
+
+function isPlainObject(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const proto = Object.getPrototypeOf(value);
+    const hasObjectPrototype = proto === null ||
+        proto === Object.prototype ||
+        Object.getPrototypeOf(proto) === null;
+    if (!hasObjectPrototype) {
+        return false;
+    }
+    return Object.prototype.toString.call(value) === '[object Object]';
+}
+
+exports.argumentsTag = argumentsTag;
+exports.arrayBufferTag = arrayBufferTag;
+exports.arrayTag = arrayTag;
+exports.bigInt64ArrayTag = bigInt64ArrayTag;
+exports.bigUint64ArrayTag = bigUint64ArrayTag;
+exports.booleanTag = booleanTag;
+exports.dataViewTag = dataViewTag;
+exports.dateTag = dateTag;
+exports.errorTag = errorTag;
+exports.float32ArrayTag = float32ArrayTag;
+exports.float64ArrayTag = float64ArrayTag;
+exports.functionTag = functionTag;
+exports.getSymbols = getSymbols;
+exports.getTag = getTag;
+exports.int16ArrayTag = int16ArrayTag;
+exports.int32ArrayTag = int32ArrayTag;
+exports.int8ArrayTag = int8ArrayTag;
+exports.isPlainObject = isPlainObject;
+exports.isPrimitive = isPrimitive;
+exports.isTypedArray = isTypedArray;
+exports.mapTag = mapTag;
+exports.numberTag = numberTag;
+exports.objectTag = objectTag;
+exports.regexpTag = regexpTag;
+exports.setTag = setTag;
+exports.stringTag = stringTag;
+exports.symbolTag = symbolTag;
+exports.uint16ArrayTag = uint16ArrayTag;
+exports.uint32ArrayTag = uint32ArrayTag;
+exports.uint8ArrayTag = uint8ArrayTag;
+exports.uint8ClampedArrayTag = uint8ClampedArrayTag;

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

@@ -1,6 +1,6 @@
 'use strict';
 
-const isPlainObject = require('./isPlainObject-octpoD.js');
+const isPlainObject = require('./isPlainObject-Xaozpc.js');
 const noop = require('./noop-2IwLUk.js');
 
 function isArrayBuffer(value) {
@@ -22,40 +22,6 @@ function isDate(value) {
     return value instanceof Date;
 }
 
-function getTag(value) {
-    if (value == null) {
-        return value === undefined ? '[object Undefined]' : '[object Null]';
-    }
-    return Object.prototype.toString.call(value);
-}
-
-const regexpTag = '[object RegExp]';
-const stringTag = '[object String]';
-const numberTag = '[object Number]';
-const booleanTag = '[object Boolean]';
-const argumentsTag = '[object Arguments]';
-const symbolTag = '[object Symbol]';
-const dateTag = '[object Date]';
-const mapTag = '[object Map]';
-const setTag = '[object Set]';
-const arrayTag = '[object Array]';
-const functionTag = '[object Function]';
-const arrayBufferTag = '[object ArrayBuffer]';
-const objectTag = '[object Object]';
-const errorTag = '[object Error]';
-const dataViewTag = '[object DataView]';
-const uint8ArrayTag = '[object Uint8Array]';
-const uint8ClampedArrayTag = '[object Uint8ClampedArray]';
-const uint16ArrayTag = '[object Uint16Array]';
-const uint32ArrayTag = '[object Uint32Array]';
-const bigUint64ArrayTag = '[object BigUint64Array]';
-const int8ArrayTag = '[object Int8Array]';
-const int16ArrayTag = '[object Int16Array]';
-const int32ArrayTag = '[object Int32Array]';
-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));
 }
@@ -94,33 +60,33 @@ function areObjectsEqual(a, b, stack, areValuesEqual) {
     if (Object.is(a, b)) {
         return true;
     }
-    let aTag = getTag(a);
-    let bTag = getTag(b);
-    if (aTag === argumentsTag) {
-        aTag = objectTag;
+    let aTag = isPlainObject.getTag(a);
+    let bTag = isPlainObject.getTag(b);
+    if (aTag === isPlainObject.argumentsTag) {
+        aTag = isPlainObject.objectTag;
     }
-    if (bTag === argumentsTag) {
-        bTag = objectTag;
+    if (bTag === isPlainObject.argumentsTag) {
+        bTag = isPlainObject.objectTag;
     }
     if (aTag !== bTag) {
         return false;
     }
     switch (aTag) {
-        case stringTag:
+        case isPlainObject.stringTag:
             return a.toString() === b.toString();
-        case numberTag: {
+        case isPlainObject.numberTag: {
             const x = a.valueOf();
             const y = b.valueOf();
             return eq(x, y);
         }
-        case booleanTag:
-        case dateTag:
-        case symbolTag:
+        case isPlainObject.booleanTag:
+        case isPlainObject.dateTag:
+        case isPlainObject.symbolTag:
             return Object.is(a.valueOf(), b.valueOf());
-        case regexpTag: {
+        case isPlainObject.regexpTag: {
             return a.source === b.source && a.flags === b.flags;
         }
-        case functionTag: {
+        case isPlainObject.functionTag: {
             return a === b;
         }
     }
@@ -134,7 +100,7 @@ function areObjectsEqual(a, b, stack, areValuesEqual) {
     stack.set(b, a);
     try {
         switch (aTag) {
-            case mapTag: {
+            case isPlainObject.mapTag: {
                 if (a.size !== b.size) {
                     return false;
                 }
@@ -145,7 +111,7 @@ function areObjectsEqual(a, b, stack, areValuesEqual) {
                 }
                 return true;
             }
-            case setTag: {
+            case isPlainObject.setTag: {
                 if (a.size !== b.size) {
                     return false;
                 }
@@ -163,18 +129,18 @@ function areObjectsEqual(a, b, stack, areValuesEqual) {
                 }
                 return true;
             }
-            case arrayTag:
-            case uint8ArrayTag:
-            case uint8ClampedArrayTag:
-            case uint16ArrayTag:
-            case uint32ArrayTag:
-            case bigUint64ArrayTag:
-            case int8ArrayTag:
-            case int16ArrayTag:
-            case int32ArrayTag:
-            case bigInt64ArrayTag:
-            case float32ArrayTag:
-            case float64ArrayTag: {
+            case isPlainObject.arrayTag:
+            case isPlainObject.uint8ArrayTag:
+            case isPlainObject.uint8ClampedArrayTag:
+            case isPlainObject.uint16ArrayTag:
+            case isPlainObject.uint32ArrayTag:
+            case isPlainObject.bigUint64ArrayTag:
+            case isPlainObject.int8ArrayTag:
+            case isPlainObject.int16ArrayTag:
+            case isPlainObject.int32ArrayTag:
+            case isPlainObject.bigInt64ArrayTag:
+            case isPlainObject.float32ArrayTag:
+            case isPlainObject.float64ArrayTag: {
                 if (typeof Buffer !== 'undefined' && Buffer.isBuffer(a) !== Buffer.isBuffer(b)) {
                     return false;
                 }
@@ -188,22 +154,22 @@ function areObjectsEqual(a, b, stack, areValuesEqual) {
                 }
                 return true;
             }
-            case arrayBufferTag: {
+            case isPlainObject.arrayBufferTag: {
                 if (a.byteLength !== b.byteLength) {
                     return false;
                 }
                 return areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack, areValuesEqual);
             }
-            case dataViewTag: {
+            case isPlainObject.dataViewTag: {
                 if (a.byteLength !== b.byteLength || a.byteOffset !== b.byteOffset) {
                     return false;
                 }
                 return areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack, areValuesEqual);
             }
-            case errorTag: {
+            case isPlainObject.errorTag: {
                 return a.name === b.name && a.message === b.message;
             }
-            case objectTag: {
+            case isPlainObject.objectTag: {
                 const areEqualInstances = areObjectsEqual(a.constructor, b.constructor, stack, areValuesEqual) ||
                     (isPlainObject.isPlainObject(a) && isPlainObject.isPlainObject(b));
                 if (!areEqualInstances) {
@@ -312,6 +278,10 @@ function isNull(x) {
     return x === null;
 }
 
+function isPromise(value) {
+    return value instanceof Promise;
+}
+
 function isRegExp(value) {
     return value instanceof RegExp;
 }
@@ -320,6 +290,10 @@ function isSet(value) {
     return value instanceof Set;
 }
 
+function isSymbol(value) {
+    return typeof value === 'symbol';
+}
+
 function isUndefined(x) {
     return x === undefined;
 }
@@ -332,10 +306,7 @@ function isWeakSet(value) {
     return value instanceof WeakSet;
 }
 
-exports.argumentsTag = argumentsTag;
-exports.booleanTag = booleanTag;
 exports.eq = eq;
-exports.getTag = getTag;
 exports.isArrayBuffer = isArrayBuffer;
 exports.isBlob = isBlob;
 exports.isBuffer = isBuffer;
@@ -352,10 +323,10 @@ exports.isMap = isMap;
 exports.isNil = isNil;
 exports.isNotNil = isNotNil;
 exports.isNull = isNull;
+exports.isPromise = isPromise;
 exports.isRegExp = isRegExp;
 exports.isSet = isSet;
+exports.isSymbol = isSymbol;
 exports.isUndefined = isUndefined;
 exports.isWeakMap = isWeakMap;
 exports.isWeakSet = isWeakSet;
-exports.numberTag = numberTag;
-exports.stringTag = stringTag;

package/dist/_chunk/{toMerged-DGFrN7.js → toMerged-BQTfB8.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-const isPlainObject = require('./isPlainObject-octpoD.js');
+const isPlainObject = require('./isPlainObject-Xaozpc.js');
 
 function clone(obj) {
     if (isPlainObject.isPrimitive(obj)) {
@@ -140,7 +140,7 @@ function cloneDeepWithImpl(valueToClone, keyToClone, objectToClone, stack = new
         copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
         return result;
     }
-    if (typeof valueToClone === 'object' && valueToClone !== null) {
+    if (typeof valueToClone === 'object' && isCloneableObject(valueToClone)) {
         const result = Object.create(Object.getPrototypeOf(valueToClone));
         stack.set(valueToClone, result);
         copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
@@ -158,6 +158,37 @@ function copyProperties(target, source, objectToClone = target, stack, cloneValu
         }
     }
 }
+function isCloneableObject(object) {
+    switch (isPlainObject.getTag(object)) {
+        case isPlainObject.argumentsTag:
+        case isPlainObject.arrayTag:
+        case isPlainObject.arrayBufferTag:
+        case isPlainObject.dataViewTag:
+        case isPlainObject.booleanTag:
+        case isPlainObject.dateTag:
+        case isPlainObject.float32ArrayTag:
+        case isPlainObject.float64ArrayTag:
+        case isPlainObject.int8ArrayTag:
+        case isPlainObject.int16ArrayTag:
+        case isPlainObject.int32ArrayTag:
+        case isPlainObject.mapTag:
+        case isPlainObject.numberTag:
+        case isPlainObject.objectTag:
+        case isPlainObject.regexpTag:
+        case isPlainObject.setTag:
+        case isPlainObject.stringTag:
+        case isPlainObject.symbolTag:
+        case isPlainObject.uint8ArrayTag:
+        case isPlainObject.uint8ClampedArrayTag:
+        case isPlainObject.uint16ArrayTag:
+        case isPlainObject.uint32ArrayTag: {
+            return true;
+        }
+        default: {
+            return false;
+        }
+    }
+}
 
 function cloneDeep(obj) {
     return cloneDeepWithImpl(obj, undefined, obj, new Map(), undefined);
@@ -168,22 +199,22 @@ function findKey(obj, predicate) {
     return keys.find(key => predicate(obj[key], key, obj));
 }
 
-function flattenObject(object) {
-    return flattenObjectImpl(object);
+function flattenObject(object, { delimiter = '.' } = {}) {
+    return flattenObjectImpl(object, '', delimiter);
 }
-function flattenObjectImpl(object, prefix = '') {
+function flattenObjectImpl(object, prefix = '', delimiter = '.') {
     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;
+        const prefixedKey = prefix ? `${prefix}${delimiter}${key}` : key;
         if (isPlainObject.isPlainObject(value) && Object.keys(value).length > 0) {
-            Object.assign(result, flattenObjectImpl(value, prefixedKey));
+            Object.assign(result, flattenObjectImpl(value, prefixedKey, delimiter));
             continue;
         }
         if (Array.isArray(value)) {
-            Object.assign(result, flattenObjectImpl(value, prefixedKey));
+            Object.assign(result, flattenObjectImpl(value, prefixedKey, delimiter));
             continue;
         }
         result[prefixedKey] = value;

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

@@ -1,5 +1,7 @@
 'use strict';
 
+const delay = require('./delay-_VMfFa.js');
+
 function after(n, func) {
     if (!Number.isInteger(n) || n < 0) {
         throw new Error(`n must be a non-negative integer.`);
@@ -189,6 +191,38 @@ function rest(func, startIndex = func.length - 1) {
     };
 }
 
+const DEFAULT_DELAY = 0;
+const DEFAULT_RETRIES = Number.POSITIVE_INFINITY;
+async function retry(func, _options) {
+    let delay$1;
+    let retries;
+    let signal;
+    if (typeof _options === 'number') {
+        delay$1 = DEFAULT_DELAY;
+        retries = _options;
+        signal = undefined;
+    }
+    else {
+        delay$1 = _options?.delay ?? DEFAULT_DELAY;
+        retries = _options?.retries ?? DEFAULT_RETRIES;
+        signal = _options?.signal;
+    }
+    let error;
+    for (let i = 0; i < retries; i++) {
+        if (signal?.aborted) {
+            throw error ?? new Error(`The retry operation was aborted due to an abort signal.`);
+        }
+        try {
+            return await func();
+        }
+        catch (err) {
+            error = err;
+            await delay.delay(delay$1);
+        }
+    }
+    throw error;
+}
+
 function unary(func) {
     return ary(func, 1);
 }
@@ -206,4 +240,5 @@ exports.once = once;
 exports.partial = partial;
 exports.partialRight = partialRight;
 exports.rest = rest;
+exports.retry = retry;
 exports.unary = unary;

package/dist/array/at.d.mts

@@ -13,6 +13,6 @@
  * const result = at(numbers, [1, 3, 4]);
  * console.log(result); // [20, 40, 50]
  */
-declare function at<T>(arr: readonly T[], indices: number[]): Array<T | undefined>;
+declare function at<T>(arr: readonly T[], indices: number[]): T[];
 
 export { at };

package/dist/array/at.d.ts

@@ -13,6 +13,6 @@
  * const result = at(numbers, [1, 3, 4]);
  * console.log(result); // [20, 40, 50]
  */
-declare function at<T>(arr: readonly T[], indices: number[]): Array<T | undefined>;
+declare function at<T>(arr: readonly T[], indices: number[]): T[];
 
 export { at };

package/dist/array/pullAt.d.mts

@@ -16,6 +16,6 @@
  * console.log(removed); // [20, 40, 50]
  * console.log(numbers); // [10, 30]
  */
-declare function pullAt<T>(arr: T[], indicesToRemove: number[]): Array<T | undefined>;
+declare function pullAt<T>(arr: T[], indicesToRemove: number[]): T[];
 
 export { pullAt };

package/dist/array/pullAt.d.ts

@@ -16,6 +16,6 @@
  * console.log(removed); // [20, 40, 50]
  * console.log(numbers); // [10, 30]
  */
-declare function pullAt<T>(arr: T[], indicesToRemove: number[]): Array<T | undefined>;
+declare function pullAt<T>(arr: T[], indicesToRemove: number[]): T[];
 
 export { pullAt };