es-toolkit 1.50.0 → 1.51.0-dev.2065

package/dist/types/ToCamelCaseKeys.d.mts

@@ -0,0 +1,24 @@
+import { NonPlainObject } from "../_internal/NonPlainObject.mjs";
+
+//#region src/types/ToCamelCaseKeys.d.ts
+type SnakeToCamel<S extends string> = S extends `${infer H}_${infer T}` ? `${Lowercase<H>}${Capitalize<SnakeToCamel<T>>}` : Lowercase<S>;
+type PascalToCamel<S extends string> = S extends `${infer F}${infer R}` ? `${Lowercase<F>}${R}` : S;
+/** If it's snake_case, apply the snake_case rule; for uppercase keys, lowercase the entire string; otherwise, just lowercase the first letter (including PascalCase → camelCase). */
+type AnyToCamel<S extends string> = S extends `${string}_${string}` ? SnakeToCamel<S> : S extends Uppercase<S> ? Lowercase<S> : PascalToCamel<S>;
+/**
+ * Converts the keys of `T` to camelCase recursively.
+ *
+ * This is the return type of the `toCamelCaseKeys` function. Recurses into
+ * plain objects and arrays; built-in objects like `Date`, `Map`, and functions
+ * pass through unchanged.
+ *
+ * @template T - The type whose keys are converted.
+ *
+ * @example
+ * type Response = { user_id: number; first_name: string };
+ * type Converted = ToCamelCaseKeys<Response>;
+ * // => { userId: number; firstName: string }
+ */
+type ToCamelCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToCamelCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as AnyToCamel<Extract<K, string>>]: ToCamelCaseKeys<T[K]> } : T;
+//#endregion
+export { ToCamelCaseKeys };

package/dist/types/ToCamelCaseKeys.d.ts

@@ -0,0 +1,24 @@
+import { NonPlainObject } from "../_internal/NonPlainObject.js";
+
+//#region src/types/ToCamelCaseKeys.d.ts
+type SnakeToCamel<S extends string> = S extends `${infer H}_${infer T}` ? `${Lowercase<H>}${Capitalize<SnakeToCamel<T>>}` : Lowercase<S>;
+type PascalToCamel<S extends string> = S extends `${infer F}${infer R}` ? `${Lowercase<F>}${R}` : S;
+/** If it's snake_case, apply the snake_case rule; for uppercase keys, lowercase the entire string; otherwise, just lowercase the first letter (including PascalCase → camelCase). */
+type AnyToCamel<S extends string> = S extends `${string}_${string}` ? SnakeToCamel<S> : S extends Uppercase<S> ? Lowercase<S> : PascalToCamel<S>;
+/**
+ * Converts the keys of `T` to camelCase recursively.
+ *
+ * This is the return type of the `toCamelCaseKeys` function. Recurses into
+ * plain objects and arrays; built-in objects like `Date`, `Map`, and functions
+ * pass through unchanged.
+ *
+ * @template T - The type whose keys are converted.
+ *
+ * @example
+ * type Response = { user_id: number; first_name: string };
+ * type Converted = ToCamelCaseKeys<Response>;
+ * // => { userId: number; firstName: string }
+ */
+type ToCamelCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToCamelCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as AnyToCamel<Extract<K, string>>]: ToCamelCaseKeys<T[K]> } : T;
+//#endregion
+export { ToCamelCaseKeys };

package/dist/types/ToConstantCaseKeys.d.mts

@@ -0,0 +1,21 @@
+import { NonPlainObject } from "../_internal/NonPlainObject.mjs";
+
+//#region src/types/ToConstantCaseKeys.d.ts
+type ConstantCase<S extends string> = S extends Lowercase<S> ? Uppercase<S> : S extends `${infer P1}${infer P2}` ? P2 extends Uncapitalize<P2> ? `${Uppercase<P1>}${ConstantCase<P2>}` : `${Uppercase<P1>}_${ConstantCase<Uncapitalize<P2>>}` : Uppercase<S>;
+/**
+ * Converts the keys of `T` to CONSTANT_CASE recursively.
+ *
+ * This is the return type of the `toConstantCaseKeys` function. Recurses into
+ * plain objects and arrays; built-in objects like `Date`, `Map`, and functions
+ * pass through unchanged.
+ *
+ * @template T - The type whose keys are converted.
+ *
+ * @example
+ * type Response = { userId: number; firstName: string };
+ * type Converted = ToConstantCaseKeys<Response>;
+ * // => { USER_ID: number; FIRST_NAME: string }
+ */
+type ToConstantCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToConstantCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as ConstantCase<string & K>]: ToConstantCaseKeys<T[K]> } : T;
+//#endregion
+export { ToConstantCaseKeys };

package/dist/types/ToConstantCaseKeys.d.ts

@@ -0,0 +1,21 @@
+import { NonPlainObject } from "../_internal/NonPlainObject.js";
+
+//#region src/types/ToConstantCaseKeys.d.ts
+type ConstantCase<S extends string> = S extends Lowercase<S> ? Uppercase<S> : S extends `${infer P1}${infer P2}` ? P2 extends Uncapitalize<P2> ? `${Uppercase<P1>}${ConstantCase<P2>}` : `${Uppercase<P1>}_${ConstantCase<Uncapitalize<P2>>}` : Uppercase<S>;
+/**
+ * Converts the keys of `T` to CONSTANT_CASE recursively.
+ *
+ * This is the return type of the `toConstantCaseKeys` function. Recurses into
+ * plain objects and arrays; built-in objects like `Date`, `Map`, and functions
+ * pass through unchanged.
+ *
+ * @template T - The type whose keys are converted.
+ *
+ * @example
+ * type Response = { userId: number; firstName: string };
+ * type Converted = ToConstantCaseKeys<Response>;
+ * // => { USER_ID: number; FIRST_NAME: string }
+ */
+type ToConstantCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToConstantCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as ConstantCase<string & K>]: ToConstantCaseKeys<T[K]> } : T;
+//#endregion
+export { ToConstantCaseKeys };

package/dist/types/ToKebabCaseKeys.d.mts

@@ -0,0 +1,23 @@
+import { NonPlainObject } from "../_internal/NonPlainObject.mjs";
+
+//#region src/types/ToKebabCaseKeys.d.ts
+type SnakeToKebab<S extends string> = S extends `${infer P1}_${infer P2}` ? Lowercase<`${P1}-${SnakeToKebab<P2>}`> : Lowercase<S>;
+type CamelToKebab<S extends string> = S extends `${infer P1}${infer P2}` ? P2 extends Uncapitalize<P2> ? `${Lowercase<P1>}${CamelToKebab<P2>}` : `${Lowercase<P1>}-${CamelToKebab<Uncapitalize<P2>>}` : S;
+type KebabCase<S extends string> = S extends `${string}_${string}` ? SnakeToKebab<S> : S extends Uppercase<S> ? Lowercase<S> : CamelToKebab<S>;
+/**
+ * Converts the keys of `T` to kebab-case recursively.
+ *
+ * This is the return type of the `toKebabCaseKeys` function. Recurses into
+ * plain objects and arrays; built-in objects like `Date`, `Map`, and functions
+ * pass through unchanged.
+ *
+ * @template T - The type whose keys are converted.
+ *
+ * @example
+ * type Response = { userId: number; firstName: string };
+ * type Converted = ToKebabCaseKeys<Response>;
+ * // => { 'user-id': number; 'first-name': string }
+ */
+type ToKebabCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToKebabCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as KebabCase<string & K>]: ToKebabCaseKeys<T[K]> } : T;
+//#endregion
+export { ToKebabCaseKeys };

package/dist/types/ToKebabCaseKeys.d.ts

@@ -0,0 +1,23 @@
+import { NonPlainObject } from "../_internal/NonPlainObject.js";
+
+//#region src/types/ToKebabCaseKeys.d.ts
+type SnakeToKebab<S extends string> = S extends `${infer P1}_${infer P2}` ? Lowercase<`${P1}-${SnakeToKebab<P2>}`> : Lowercase<S>;
+type CamelToKebab<S extends string> = S extends `${infer P1}${infer P2}` ? P2 extends Uncapitalize<P2> ? `${Lowercase<P1>}${CamelToKebab<P2>}` : `${Lowercase<P1>}-${CamelToKebab<Uncapitalize<P2>>}` : S;
+type KebabCase<S extends string> = S extends `${string}_${string}` ? SnakeToKebab<S> : S extends Uppercase<S> ? Lowercase<S> : CamelToKebab<S>;
+/**
+ * Converts the keys of `T` to kebab-case recursively.
+ *
+ * This is the return type of the `toKebabCaseKeys` function. Recurses into
+ * plain objects and arrays; built-in objects like `Date`, `Map`, and functions
+ * pass through unchanged.
+ *
+ * @template T - The type whose keys are converted.
+ *
+ * @example
+ * type Response = { userId: number; firstName: string };
+ * type Converted = ToKebabCaseKeys<Response>;
+ * // => { 'user-id': number; 'first-name': string }
+ */
+type ToKebabCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToKebabCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as KebabCase<string & K>]: ToKebabCaseKeys<T[K]> } : T;
+//#endregion
+export { ToKebabCaseKeys };

package/dist/types/ToPascalCaseKeys.d.mts

@@ -0,0 +1,24 @@
+import { NonPlainObject } from "../_internal/NonPlainObject.mjs";
+
+//#region src/types/ToPascalCaseKeys.d.ts
+type SnakeToPascal<S extends string> = S extends `${infer H}_${infer T}` ? `${Capitalize<Lowercase<H>>}${Capitalize<SnakeToPascal<T>>}` : Capitalize<Lowercase<S>>;
+type CamelToPascal<S extends string> = S extends `${infer F}${infer R}` ? `${Uppercase<F>}${R}` : S;
+/** If it's snake_case, apply the snake_case rule; for uppercase keys, lowercase and capitalize the entire string; otherwise, just uppercase the first letter (including camelCase → PascalCase). */
+type AnyToPascal<S extends string> = S extends `${string}_${string}` ? SnakeToPascal<S> : S extends Uppercase<S> ? Capitalize<Lowercase<S>> : CamelToPascal<S>;
+/**
+ * Converts the keys of `T` to PascalCase recursively.
+ *
+ * This is the return type of the `toPascalCaseKeys` function. Recurses into
+ * plain objects and arrays; built-in objects like `Date`, `Map`, and functions
+ * pass through unchanged.
+ *
+ * @template T - The type whose keys are converted.
+ *
+ * @example
+ * type Response = { userId: number; firstName: string };
+ * type Converted = ToPascalCaseKeys<Response>;
+ * // => { UserId: number; FirstName: string }
+ */
+type ToPascalCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToPascalCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as AnyToPascal<Extract<K, string>>]: ToPascalCaseKeys<T[K]> } : T;
+//#endregion
+export { ToPascalCaseKeys };

package/dist/types/ToPascalCaseKeys.d.ts

@@ -0,0 +1,24 @@
+import { NonPlainObject } from "../_internal/NonPlainObject.js";
+
+//#region src/types/ToPascalCaseKeys.d.ts
+type SnakeToPascal<S extends string> = S extends `${infer H}_${infer T}` ? `${Capitalize<Lowercase<H>>}${Capitalize<SnakeToPascal<T>>}` : Capitalize<Lowercase<S>>;
+type CamelToPascal<S extends string> = S extends `${infer F}${infer R}` ? `${Uppercase<F>}${R}` : S;
+/** If it's snake_case, apply the snake_case rule; for uppercase keys, lowercase and capitalize the entire string; otherwise, just uppercase the first letter (including camelCase → PascalCase). */
+type AnyToPascal<S extends string> = S extends `${string}_${string}` ? SnakeToPascal<S> : S extends Uppercase<S> ? Capitalize<Lowercase<S>> : CamelToPascal<S>;
+/**
+ * Converts the keys of `T` to PascalCase recursively.
+ *
+ * This is the return type of the `toPascalCaseKeys` function. Recurses into
+ * plain objects and arrays; built-in objects like `Date`, `Map`, and functions
+ * pass through unchanged.
+ *
+ * @template T - The type whose keys are converted.
+ *
+ * @example
+ * type Response = { userId: number; firstName: string };
+ * type Converted = ToPascalCaseKeys<Response>;
+ * // => { UserId: number; FirstName: string }
+ */
+type ToPascalCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToPascalCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as AnyToPascal<Extract<K, string>>]: ToPascalCaseKeys<T[K]> } : T;
+//#endregion
+export { ToPascalCaseKeys };

package/dist/types/ToSnakeCaseKeys.d.mts

@@ -0,0 +1,21 @@
+import { NonPlainObject } from "../_internal/NonPlainObject.mjs";
+
+//#region src/types/ToSnakeCaseKeys.d.ts
+type SnakeCase<S extends string> = S extends Uppercase<S> ? Lowercase<S> : S extends `${infer P1}${infer P2}` ? P2 extends Uncapitalize<P2> ? `${Lowercase<P1>}${SnakeCase<P2>}` : `${Lowercase<P1>}_${SnakeCase<Uncapitalize<P2>>}` : Lowercase<S>;
+/**
+ * Converts the keys of `T` to snake_case recursively.
+ *
+ * This is the return type of the `toSnakeCaseKeys` function. Recurses into
+ * plain objects and arrays; built-in objects like `Date`, `Map`, and functions
+ * pass through unchanged.
+ *
+ * @template T - The type whose keys are converted.
+ *
+ * @example
+ * type Request = { userId: number; firstName: string };
+ * type Converted = ToSnakeCaseKeys<Request>;
+ * // => { user_id: number; first_name: string }
+ */
+type ToSnakeCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToSnakeCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as SnakeCase<string & K>]: ToSnakeCaseKeys<T[K]> } : T;
+//#endregion
+export { ToSnakeCaseKeys };

package/dist/types/ToSnakeCaseKeys.d.ts

@@ -0,0 +1,21 @@
+import { NonPlainObject } from "../_internal/NonPlainObject.js";
+
+//#region src/types/ToSnakeCaseKeys.d.ts
+type SnakeCase<S extends string> = S extends Uppercase<S> ? Lowercase<S> : S extends `${infer P1}${infer P2}` ? P2 extends Uncapitalize<P2> ? `${Lowercase<P1>}${SnakeCase<P2>}` : `${Lowercase<P1>}_${SnakeCase<Uncapitalize<P2>>}` : Lowercase<S>;
+/**
+ * Converts the keys of `T` to snake_case recursively.
+ *
+ * This is the return type of the `toSnakeCaseKeys` function. Recurses into
+ * plain objects and arrays; built-in objects like `Date`, `Map`, and functions
+ * pass through unchanged.
+ *
+ * @template T - The type whose keys are converted.
+ *
+ * @example
+ * type Request = { userId: number; firstName: string };
+ * type Converted = ToSnakeCaseKeys<Request>;
+ * // => { user_id: number; first_name: string }
+ */
+type ToSnakeCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToSnakeCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as SnakeCase<string & K>]: ToSnakeCaseKeys<T[K]> } : T;
+//#endregion
+export { ToSnakeCaseKeys };

package/dist/types/index.d.mts

@@ -1,7 +1,12 @@
+import { ToCamelCaseKeys } from "./ToCamelCaseKeys.mjs";
+import { ToConstantCaseKeys } from "./ToConstantCaseKeys.mjs";
+import { ToKebabCaseKeys } from "./ToKebabCaseKeys.mjs";
+import { ToPascalCaseKeys } from "./ToPascalCaseKeys.mjs";
+import { ToSnakeCaseKeys } from "./ToSnakeCaseKeys.mjs";
 import { DeepPartial } from "./DeepPartial.mjs";
 import { DeepReadonly } from "./DeepReadonly.mjs";
 import { NonEmptyArray } from "./NonEmptyArray.mjs";
 import { Simplify } from "./Simplify.mjs";
 import { ValueOf } from "./ValueOf.mjs";
 import { Writable } from "./Writable.mjs";
-export { type DeepPartial, type DeepReadonly, type NonEmptyArray, type Simplify, type ValueOf, type Writable };
+export { type DeepPartial, type DeepReadonly, type NonEmptyArray, type Simplify, type ToCamelCaseKeys, type ToConstantCaseKeys, type ToKebabCaseKeys, type ToPascalCaseKeys, type ToSnakeCaseKeys, type ValueOf, type Writable };

package/dist/types/index.d.ts

@@ -1,7 +1,12 @@
+import { ToCamelCaseKeys } from "./ToCamelCaseKeys.js";
+import { ToConstantCaseKeys } from "./ToConstantCaseKeys.js";
+import { ToKebabCaseKeys } from "./ToKebabCaseKeys.js";
+import { ToPascalCaseKeys } from "./ToPascalCaseKeys.js";
+import { ToSnakeCaseKeys } from "./ToSnakeCaseKeys.js";
 import { DeepPartial } from "./DeepPartial.js";
 import { DeepReadonly } from "./DeepReadonly.js";
 import { NonEmptyArray } from "./NonEmptyArray.js";
 import { Simplify } from "./Simplify.js";
 import { ValueOf } from "./ValueOf.js";
 import { Writable } from "./Writable.js";
-export { type DeepPartial, type DeepReadonly, type NonEmptyArray, type Simplify, type ValueOf, type Writable };
+export { type DeepPartial, type DeepReadonly, type NonEmptyArray, type Simplify, type ToCamelCaseKeys, type ToConstantCaseKeys, type ToKebabCaseKeys, type ToPascalCaseKeys, type ToSnakeCaseKeys, type ValueOf, type Writable };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "es-toolkit",
-  "version": "1.50.0",
+  "version": "1.51.0-dev.2065+5dc4477f",
   "description": "A state-of-the-art, high-performance JavaScript utility library with a small bundle size and strong type annotations.",
   "homepage": "https://es-toolkit.dev",
   "bugs": "https://github.com/toss/es-toolkit/issues",
@@ -34,6 +34,16 @@
         "default": "./dist/array/index.js"
       }
     },
+    "./bigint": {
+      "import": {
+        "types": "./dist/bigint/index.d.mts",
+        "default": "./dist/bigint/index.mjs"
+      },
+      "require": {
+        "types": "./dist/bigint/index.d.ts",
+        "default": "./dist/bigint/index.js"
+      }
+    },
     "./compat": {
       "import": {
         "types": "./dist/compat/index.d.mts",
@@ -185,10 +195,12 @@
     "./package.json": "./package.json"
   },
   "files": [
+    "NOTICE",
     "dist",
     "compat",
     "*.d.ts",
     "array.js",
+    "bigint.js",
     "compat.js",
     "error.js",
     "fp.js",
@@ -206,7 +218,8 @@
   "workspaces": [
     "docs",
     "benchmarks",
-    "tests/types"
+    "tests/types",
+    "tests/browser-compat"
   ],
   "scripts": {
     "bench": "yarn workspace benchmarks bench",
@@ -238,6 +251,8 @@
     "broken-link-checker": "0.7.8",
     "eslint": "^9.39.2",
     "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-compat": "^7.0.2",
+    "eslint-plugin-es-x": "^10.0.0",
     "eslint-plugin-no-for-of-array": "^0.0.1",
     "eslint-plugin-prettier": "^5.2.1",
     "eslint-plugin-vue": "^9.28.0",
@@ -283,6 +298,16 @@
           "default": "./dist/array/index.js"
         }
       },
+      "./bigint": {
+        "import": {
+          "types": "./dist/bigint/index.d.mts",
+          "default": "./dist/bigint/index.mjs"
+        },
+        "require": {
+          "types": "./dist/bigint/index.d.ts",
+          "default": "./dist/bigint/index.js"
+        }
+      },
       "./compat": {
         "import": {
           "types": "./dist/compat/index.d.mts",