es-toolkit 1.36.0 → 1.37.0-dev.1243

package/CHANGELOG.md

@@ -1,4 +1,19 @@
 # es-toolkit Changelog
+
+## Version v1.37.0
+
+Released on May 3rd, 2025.
+
+- Introduced compatibility functions for [result](https://es-toolkit.slash.page/reference/compat/object/result.html), [omitBy](https://es-toolkit.slash.page/reference/object/omitBy.html), [xorBy](https://es-toolkit.slash.page/reference/array/xorBy.html), [xorWith](https://es-toolkit.slash.page/reference/array/xorWith.html), [unzipWith](https://es-toolkit.slash.page/reference/array/unzipWith.html), [sampleSize](https://es-toolkit.slash.page/reference/array/sampleSize.html), [transform](https://es-toolkit.slash.page/reference/compat/object/transform.html), [wrap](https://es-toolkit.slash.page/reference/compat/function/wrap.html), [countBy](https://es-toolkit.slash.page/reference/array/countBy.html), and [xor](https://es-toolkit.slash.page/reference/array/xor.html).
+- Added vitest benchmark for [ary](https://es-toolkit.slash.page/reference/function/ary.html) function.
+- Fixed string comparison in [sortBy](https://es-toolkit.slash.page/reference/array/sortBy.html) and [orderBy](https://es-toolkit.slash.page/reference/array/orderBy.html) by removing locale comparison and using ASCII code instead.
+- Fixed type definition in [isBuffer](https://es-toolkit.slash.page/reference/predicate/isBuffer.html).
+- Fixed internal documentation links for Korean and Japanese headings.
+- Improved code readability and documentation for various functions.
+- Prevented circular dependencies by updating import paths in [toCamelCaseKeys](https://es-toolkit.slash.page/reference/object/toCamelCaseKeys.html) and [toSnakeCaseKeys](https://es-toolkit.slash.page/reference/object/toSnakeCaseKeys.html).
+
+We sincerely thank @chldmsqls34, @umsungjun, @raon0211, @dayongkr, @shren207, @oror-sine, @L2HYUNN, @D-Sketon, @ariandel-dev, @Jeong-Rae, and @beomxtone for their contributions. We appreciate your great efforts!
+
 ## Version v1.36.0
 
 Released on April 24th, 2025.

package/dist/_chunk/isPlainObject-DINLyA.js

@@ -0,0 +1,281 @@
+'use strict';
+
+const isPlainObject$1 = require('./isPlainObject-Xaozpc.js');
+
+function clone(obj) {
+    if (isPlainObject$1.isPrimitive(obj)) {
+        return obj;
+    }
+    if (Array.isArray(obj) ||
+        isPlainObject$1.isTypedArray(obj) ||
+        obj instanceof ArrayBuffer ||
+        (typeof SharedArrayBuffer !== 'undefined' && obj instanceof SharedArrayBuffer)) {
+        return obj.slice(0);
+    }
+    const prototype = Object.getPrototypeOf(obj);
+    const Constructor = prototype.constructor;
+    if (obj instanceof Date || obj instanceof Map || obj instanceof Set) {
+        return new Constructor(obj);
+    }
+    if (obj instanceof RegExp) {
+        const newRegExp = new Constructor(obj);
+        newRegExp.lastIndex = obj.lastIndex;
+        return newRegExp;
+    }
+    if (obj instanceof DataView) {
+        return new Constructor(obj.buffer.slice(0));
+    }
+    if (obj instanceof Error) {
+        const newError = new Constructor(obj.message);
+        newError.stack = obj.stack;
+        newError.name = obj.name;
+        newError.cause = obj.cause;
+        return newError;
+    }
+    if (typeof File !== 'undefined' && obj instanceof File) {
+        const newFile = new Constructor([obj], obj.name, { type: obj.type, lastModified: obj.lastModified });
+        return newFile;
+    }
+    if (typeof obj === 'object') {
+        const newObject = Object.create(prototype);
+        return Object.assign(newObject, obj);
+    }
+    return obj;
+}
+
+function cloneDeepWith(obj, cloneValue) {
+    return cloneDeepWithImpl(obj, undefined, obj, new Map(), cloneValue);
+}
+function cloneDeepWithImpl(valueToClone, keyToClone, objectToClone, stack = new Map(), cloneValue = undefined) {
+    const cloned = cloneValue?.(valueToClone, keyToClone, objectToClone, stack);
+    if (cloned != null) {
+        return cloned;
+    }
+    if (isPlainObject$1.isPrimitive(valueToClone)) {
+        return valueToClone;
+    }
+    if (stack.has(valueToClone)) {
+        return stack.get(valueToClone);
+    }
+    if (Array.isArray(valueToClone)) {
+        const result = new Array(valueToClone.length);
+        stack.set(valueToClone, result);
+        for (let i = 0; i < valueToClone.length; i++) {
+            result[i] = cloneDeepWithImpl(valueToClone[i], i, objectToClone, stack, cloneValue);
+        }
+        if (Object.hasOwn(valueToClone, 'index')) {
+            result.index = valueToClone.index;
+        }
+        if (Object.hasOwn(valueToClone, 'input')) {
+            result.input = valueToClone.input;
+        }
+        return result;
+    }
+    if (valueToClone instanceof Date) {
+        return new Date(valueToClone.getTime());
+    }
+    if (valueToClone instanceof RegExp) {
+        const result = new RegExp(valueToClone.source, valueToClone.flags);
+        result.lastIndex = valueToClone.lastIndex;
+        return result;
+    }
+    if (valueToClone instanceof Map) {
+        const result = new Map();
+        stack.set(valueToClone, result);
+        for (const [key, value] of valueToClone) {
+            result.set(key, cloneDeepWithImpl(value, key, objectToClone, stack, cloneValue));
+        }
+        return result;
+    }
+    if (valueToClone instanceof Set) {
+        const result = new Set();
+        stack.set(valueToClone, result);
+        for (const value of valueToClone) {
+            result.add(cloneDeepWithImpl(value, undefined, objectToClone, stack, cloneValue));
+        }
+        return result;
+    }
+    if (typeof Buffer !== 'undefined' && Buffer.isBuffer(valueToClone)) {
+        return valueToClone.subarray();
+    }
+    if (isPlainObject$1.isTypedArray(valueToClone)) {
+        const result = new (Object.getPrototypeOf(valueToClone).constructor)(valueToClone.length);
+        stack.set(valueToClone, result);
+        for (let i = 0; i < valueToClone.length; i++) {
+            result[i] = cloneDeepWithImpl(valueToClone[i], i, objectToClone, stack, cloneValue);
+        }
+        return result;
+    }
+    if (valueToClone instanceof ArrayBuffer ||
+        (typeof SharedArrayBuffer !== 'undefined' && valueToClone instanceof SharedArrayBuffer)) {
+        return valueToClone.slice(0);
+    }
+    if (valueToClone instanceof DataView) {
+        const result = new DataView(valueToClone.buffer.slice(0), valueToClone.byteOffset, valueToClone.byteLength);
+        stack.set(valueToClone, result);
+        copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+        return result;
+    }
+    if (typeof File !== 'undefined' && valueToClone instanceof File) {
+        const result = new File([valueToClone], valueToClone.name, {
+            type: valueToClone.type,
+        });
+        stack.set(valueToClone, result);
+        copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+        return result;
+    }
+    if (valueToClone instanceof Blob) {
+        const result = new Blob([valueToClone], { type: valueToClone.type });
+        stack.set(valueToClone, result);
+        copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+        return result;
+    }
+    if (valueToClone instanceof Error) {
+        const result = new valueToClone.constructor();
+        stack.set(valueToClone, result);
+        result.message = valueToClone.message;
+        result.name = valueToClone.name;
+        result.stack = valueToClone.stack;
+        result.cause = valueToClone.cause;
+        copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+        return result;
+    }
+    if (typeof valueToClone === 'object' && isCloneableObject(valueToClone)) {
+        const result = Object.create(Object.getPrototypeOf(valueToClone));
+        stack.set(valueToClone, result);
+        copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+        return result;
+    }
+    return valueToClone;
+}
+function copyProperties(target, source, objectToClone = target, stack, cloneValue) {
+    const keys = [...Object.keys(source), ...isPlainObject$1.getSymbols(source)];
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const descriptor = Object.getOwnPropertyDescriptor(target, key);
+        if (descriptor == null || descriptor.writable) {
+            target[key] = cloneDeepWithImpl(source[key], key, objectToClone, stack, cloneValue);
+        }
+    }
+}
+function isCloneableObject(object) {
+    switch (isPlainObject$1.getTag(object)) {
+        case isPlainObject$1.argumentsTag:
+        case isPlainObject$1.arrayTag:
+        case isPlainObject$1.arrayBufferTag:
+        case isPlainObject$1.dataViewTag:
+        case isPlainObject$1.booleanTag:
+        case isPlainObject$1.dateTag:
+        case isPlainObject$1.float32ArrayTag:
+        case isPlainObject$1.float64ArrayTag:
+        case isPlainObject$1.int8ArrayTag:
+        case isPlainObject$1.int16ArrayTag:
+        case isPlainObject$1.int32ArrayTag:
+        case isPlainObject$1.mapTag:
+        case isPlainObject$1.numberTag:
+        case isPlainObject$1.objectTag:
+        case isPlainObject$1.regexpTag:
+        case isPlainObject$1.setTag:
+        case isPlainObject$1.stringTag:
+        case isPlainObject$1.symbolTag:
+        case isPlainObject$1.uint8ArrayTag:
+        case isPlainObject$1.uint8ClampedArrayTag:
+        case isPlainObject$1.uint16ArrayTag:
+        case isPlainObject$1.uint32ArrayTag: {
+            return true;
+        }
+        default: {
+            return false;
+        }
+    }
+}
+
+function cloneDeep(obj) {
+    return cloneDeepWithImpl(obj, undefined, obj, new Map(), undefined);
+}
+
+function findKey(obj, predicate) {
+    const keys = Object.keys(obj);
+    return keys.find(key => predicate(obj[key], key, obj));
+}
+
+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 isObjectLike(value) {
+    return typeof value === 'object' && value !== null;
+}
+
+function isArray(value) {
+    return Array.isArray(value);
+}
+
+function isPlainObject(object) {
+    if (typeof object !== 'object') {
+        return false;
+    }
+    if (object == null) {
+        return false;
+    }
+    if (Object.getPrototypeOf(object) === null) {
+        return true;
+    }
+    if (Object.prototype.toString.call(object) !== '[object Object]') {
+        const tag = object[Symbol.toStringTag];
+        if (tag == null) {
+            return false;
+        }
+        const isTagReadonly = !Object.getOwnPropertyDescriptor(object, Symbol.toStringTag)?.writable;
+        if (isTagReadonly) {
+            return false;
+        }
+        return object.toString() === `[object ${tag}]`;
+    }
+    let proto = object;
+    while (Object.getPrototypeOf(proto) !== null) {
+        proto = Object.getPrototypeOf(proto);
+    }
+    return Object.getPrototypeOf(object) === proto;
+}
+
+exports.clone = clone;
+exports.cloneDeep = cloneDeep;
+exports.cloneDeepWith = cloneDeepWith;
+exports.copyProperties = copyProperties;
+exports.findKey = findKey;
+exports.invert = invert;
+exports.isArray = isArray;
+exports.isObjectLike = isObjectLike;
+exports.isPlainObject = isPlainObject;
+exports.mapKeys = mapKeys;
+exports.mapValues = mapValues;

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;