es-toolkit 1.37.0 → 1.37.1-dev.1244

package/dist/object/index.js

@@ -2,7 +2,61 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const toSnakeCaseKeys = require('../_chunk/toSnakeCaseKeys-kqZCyq.js');
+const isPlainObject = require('../_chunk/isPlainObject-DINLyA.js');
+const isPlainObject$1 = require('../_chunk/isPlainObject-Xaozpc.js');
+const snakeCase = require('../_chunk/snakeCase-BwvoPi.js');
+
+function flattenObject(object, { delimiter = '.' } = {}) {
+    return flattenObjectImpl(object, '', delimiter);
+}
+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}${delimiter}${key}` : key;
+        if (isPlainObject$1.isPlainObject(value) && Object.keys(value).length > 0) {
+            Object.assign(result, flattenObjectImpl(value, prefixedKey, delimiter));
+            continue;
+        }
+        if (Array.isArray(value)) {
+            Object.assign(result, flattenObjectImpl(value, prefixedKey, delimiter));
+            continue;
+        }
+        result[prefixedKey] = value;
+    }
+    return result;
+}
+
+function merge(target, source) {
+    const sourceKeys = Object.keys(source);
+    for (let i = 0; i < sourceKeys.length; i++) {
+        const key = sourceKeys[i];
+        const sourceValue = source[key];
+        const targetValue = target[key];
+        if (Array.isArray(sourceValue)) {
+            if (Array.isArray(targetValue)) {
+                target[key] = merge(targetValue, sourceValue);
+            }
+            else {
+                target[key] = merge([], sourceValue);
+            }
+        }
+        else if (isPlainObject$1.isPlainObject(sourceValue)) {
+            if (isPlainObject$1.isPlainObject(targetValue)) {
+                target[key] = merge(targetValue, sourceValue);
+            }
+            else {
+                target[key] = merge({}, sourceValue);
+            }
+        }
+        else if (targetValue === undefined || sourceValue !== undefined) {
+            target[key] = sourceValue;
+        }
+    }
+    return target;
+}
 
 function mergeWith(target, source, merge) {
     const sourceKeys = Object.keys(source);
@@ -17,7 +71,7 @@ function mergeWith(target, source, merge) {
         else if (Array.isArray(sourceValue)) {
             target[key] = mergeWith(targetValue ?? [], sourceValue, merge);
         }
-        else if (toSnakeCaseKeys.isObjectLike(targetValue) && toSnakeCaseKeys.isObjectLike(sourceValue)) {
+        else if (isPlainObject.isObjectLike(targetValue) && isPlainObject.isObjectLike(sourceValue)) {
             target[key] = mergeWith(targetValue ?? {}, sourceValue, merge);
         }
         else if (targetValue === undefined || sourceValue !== undefined) {
@@ -73,20 +127,60 @@ function pickBy(obj, shouldPick) {
     return result;
 }
 
-exports.clone = toSnakeCaseKeys.clone;
-exports.cloneDeep = toSnakeCaseKeys.cloneDeep;
-exports.cloneDeepWith = toSnakeCaseKeys.cloneDeepWith;
-exports.findKey = toSnakeCaseKeys.findKey;
-exports.flattenObject = toSnakeCaseKeys.flattenObject;
-exports.invert = toSnakeCaseKeys.invert;
-exports.mapKeys = toSnakeCaseKeys.mapKeys;
-exports.mapValues = toSnakeCaseKeys.mapValues;
-exports.merge = toSnakeCaseKeys.merge;
-exports.toCamelCaseKeys = toSnakeCaseKeys.toCamelCaseKeys;
-exports.toMerged = toSnakeCaseKeys.toMerged;
-exports.toSnakeCaseKeys = toSnakeCaseKeys.toSnakeCaseKeys;
+function toCamelCaseKeys(obj) {
+    if (isPlainObject.isArray(obj)) {
+        return obj.map(item => toCamelCaseKeys(item));
+    }
+    if (isPlainObject$1.isPlainObject(obj)) {
+        const result = {};
+        const keys = Object.keys(obj);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            const camelKey = snakeCase.camelCase(key);
+            const camelCaseKeys = toCamelCaseKeys(obj[key]);
+            result[camelKey] = camelCaseKeys;
+        }
+        return result;
+    }
+    return obj;
+}
+
+function toMerged(target, source) {
+    return merge(isPlainObject.cloneDeep(target), source);
+}
+
+function toSnakeCaseKeys(obj) {
+    if (isPlainObject.isArray(obj)) {
+        return obj.map(item => toSnakeCaseKeys(item));
+    }
+    if (isPlainObject.isPlainObject(obj)) {
+        const result = {};
+        const keys = Object.keys(obj);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            const snakeKey = snakeCase.snakeCase(key);
+            const snakeCaseKeys = toSnakeCaseKeys(obj[key]);
+            result[snakeKey] = snakeCaseKeys;
+        }
+        return result;
+    }
+    return obj;
+}
+
+exports.clone = isPlainObject.clone;
+exports.cloneDeep = isPlainObject.cloneDeep;
+exports.cloneDeepWith = isPlainObject.cloneDeepWith;
+exports.findKey = isPlainObject.findKey;
+exports.invert = isPlainObject.invert;
+exports.mapKeys = isPlainObject.mapKeys;
+exports.mapValues = isPlainObject.mapValues;
+exports.flattenObject = flattenObject;
+exports.merge = merge;
 exports.mergeWith = mergeWith;
 exports.omit = omit;
 exports.omitBy = omitBy;
 exports.pick = pick;
 exports.pickBy = pickBy;
+exports.toCamelCaseKeys = toCamelCaseKeys;
+exports.toMerged = toMerged;
+exports.toSnakeCaseKeys = toSnakeCaseKeys;

package/dist/predicate/index.js

@@ -2,41 +2,113 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const isWeakSet = require('../_chunk/isWeakSet-C2NpfO.js');
+const isWeakSet = require('../_chunk/isWeakSet-403Sh5.js');
 const isPlainObject = require('../_chunk/isPlainObject-Xaozpc.js');
 
+function isBlob(x) {
+    if (typeof Blob === 'undefined') {
+        return false;
+    }
+    return x instanceof Blob;
+}
+
 function isBoolean(x) {
     return typeof x === 'boolean';
 }
 
+function isBrowser() {
+    return typeof window !== 'undefined' && window?.document != null;
+}
+
 function isError(value) {
     return value instanceof Error;
 }
 
+function isFile(x) {
+    if (typeof File === 'undefined') {
+        return false;
+    }
+    return isBlob(x) && x instanceof File;
+}
+
+function isJSON(value) {
+    if (typeof value !== 'string') {
+        return false;
+    }
+    try {
+        JSON.parse(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+
+function isJSONValue(value) {
+    switch (typeof value) {
+        case 'object': {
+            return value === null || isJSONArray(value) || isJSONObject(value);
+        }
+        case 'string':
+        case 'number':
+        case 'boolean': {
+            return true;
+        }
+        default: {
+            return false;
+        }
+    }
+}
+function isJSONArray(value) {
+    if (!Array.isArray(value)) {
+        return false;
+    }
+    return value.every(item => isJSONValue(item));
+}
+function isJSONObject(obj) {
+    if (!isPlainObject.isPlainObject(obj)) {
+        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;
+}
+
+function isNode() {
+    return typeof process !== 'undefined' && process?.versions?.node != null;
+}
+
+function isNotNil(x) {
+    return x != null;
+}
+
+function isPromise(value) {
+    return value instanceof Promise;
+}
+
 function isString(value) {
     return typeof value === 'string';
 }
 
 exports.isArrayBuffer = isWeakSet.isArrayBuffer;
-exports.isBlob = isWeakSet.isBlob;
-exports.isBrowser = isWeakSet.isBrowser;
 exports.isBuffer = isWeakSet.isBuffer;
 exports.isDate = isWeakSet.isDate;
 exports.isEqual = isWeakSet.isEqual;
 exports.isEqualWith = isWeakSet.isEqualWith;
-exports.isFile = isWeakSet.isFile;
 exports.isFunction = isWeakSet.isFunction;
-exports.isJSON = isWeakSet.isJSON;
-exports.isJSONArray = isWeakSet.isJSONArray;
-exports.isJSONObject = isWeakSet.isJSONObject;
-exports.isJSONValue = isWeakSet.isJSONValue;
 exports.isLength = isWeakSet.isLength;
 exports.isMap = isWeakSet.isMap;
 exports.isNil = isWeakSet.isNil;
-exports.isNode = isWeakSet.isNode;
-exports.isNotNil = isWeakSet.isNotNil;
 exports.isNull = isWeakSet.isNull;
-exports.isPromise = isWeakSet.isPromise;
 exports.isRegExp = isWeakSet.isRegExp;
 exports.isSet = isWeakSet.isSet;
 exports.isSymbol = isWeakSet.isSymbol;
@@ -46,6 +118,16 @@ exports.isWeakSet = isWeakSet.isWeakSet;
 exports.isPlainObject = isPlainObject.isPlainObject;
 exports.isPrimitive = isPlainObject.isPrimitive;
 exports.isTypedArray = isPlainObject.isTypedArray;
+exports.isBlob = isBlob;
 exports.isBoolean = isBoolean;
+exports.isBrowser = isBrowser;
 exports.isError = isError;
+exports.isFile = isFile;
+exports.isJSON = isJSON;
+exports.isJSONArray = isJSONArray;
+exports.isJSONObject = isJSONObject;
+exports.isJSONValue = isJSONValue;
+exports.isNode = isNode;
+exports.isNotNil = isNotNil;
+exports.isPromise = isPromise;
 exports.isString = isString;

package/dist/string/index.js

@@ -3,7 +3,21 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const snakeCase = require('../_chunk/snakeCase-BwvoPi.js');
-const upperFirst = require('../_chunk/upperFirst-DbrFSz.js');
+const upperFirst = require('../_chunk/upperFirst-C7IztG.js');
+
+function constantCase(str) {
+    const words = snakeCase.words(str);
+    return words.map(word => word.toUpperCase()).join('_');
+}
+
+function pascalCase(str) {
+    const words = snakeCase.words(str);
+    return words.map(word => snakeCase.capitalize(word)).join('');
+}
+
+function reverseString(value) {
+    return [...value].reverse().join('');
+}
 
 function startCase(str) {
     const words = snakeCase.words(str.trim());
@@ -22,7 +36,6 @@ exports.camelCase = snakeCase.camelCase;
 exports.capitalize = snakeCase.capitalize;
 exports.snakeCase = snakeCase.snakeCase;
 exports.words = snakeCase.words;
-exports.constantCase = upperFirst.constantCase;
 exports.deburr = upperFirst.deburr;
 exports.escape = upperFirst.escape;
 exports.escapeRegExp = upperFirst.escapeRegExp;
@@ -30,12 +43,13 @@ exports.kebabCase = upperFirst.kebabCase;
 exports.lowerCase = upperFirst.lowerCase;
 exports.lowerFirst = upperFirst.lowerFirst;
 exports.pad = upperFirst.pad;
-exports.pascalCase = upperFirst.pascalCase;
-exports.reverseString = upperFirst.reverseString;
 exports.trim = upperFirst.trim;
 exports.trimEnd = upperFirst.trimEnd;
 exports.trimStart = upperFirst.trimStart;
 exports.unescape = upperFirst.unescape;
 exports.upperCase = upperFirst.upperCase;
 exports.upperFirst = upperFirst.upperFirst;
+exports.constantCase = constantCase;
+exports.pascalCase = pascalCase;
+exports.reverseString = reverseString;
 exports.startCase = startCase;

package/dist/util/index.js

@@ -2,8 +2,6 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const invariant = require('../_chunk/invariant-BfGFfr.js');
-
 function attempt(func) {
     try {
         return [null, func()];
@@ -13,6 +11,23 @@ function attempt(func) {
     }
 }
 
-exports.attemptAsync = invariant.attemptAsync;
-exports.invariant = invariant.invariant;
+async function attemptAsync(func) {
+    try {
+        const result = await func();
+        return [null, result];
+    }
+    catch (error) {
+        return [error, null];
+    }
+}
+
+function invariant(condition, message) {
+    if (condition) {
+        return;
+    }
+    throw new Error(message);
+}
+
 exports.attempt = attempt;
+exports.attemptAsync = attemptAsync;
+exports.invariant = invariant;

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.37.0",
+  "version": "1.37.1-dev.1244+cb3278e8",
   "homepage": "https://es-toolkit.slash.page",
   "bugs": "https://github.com/toss/es-toolkit/issues",
   "repository": {

package/dist/_chunk/invariant-BfGFfr.js

@@ -1,21 +0,0 @@
-'use strict';
-
-async function attemptAsync(func) {
-    try {
-        const result = await func();
-        return [null, result];
-    }
-    catch (error) {
-        return [error, null];
-    }
-}
-
-function invariant(condition, message) {
-    if (condition) {
-        return;
-    }
-    throw new Error(message);
-}
-
-exports.attemptAsync = attemptAsync;
-exports.invariant = invariant;