casemorph 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,12 @@
+# Changelog
+
+## 0.1.0 (2026-03-28)
+
+### Features
+
+- **String transforms**: `camelCase`, `snakeCase`, `kebabCase`, `pascalCase`, `constantCase`
+- **Deep object transforms**: `toCamelCase`, `toSnakeCase`, `toKebabCase`, `toPascalCase`, `toConstantCase`
+- **Full type inference**: string literal types transform at compile-time, deep object keys remap via mapped types
+- **Acronym-aware**: `XMLParser` correctly splits to `xml` + `parser` (not `x` + `m` + `l` + `parser`)
+- **Leaf preservation**: Date, RegExp, Map, Set, Error, and functions are never recursed into
+- **Zero dependencies**

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 best-package
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,184 @@
+# casemorph
+
+**Your API speaks `snake_case`. Your code speaks `camelCase`. casemorph transforms the keys — and the types follow.**
+
+[![npm version](https://img.shields.io/npm/v/casemorph)](https://www.npmjs.com/package/casemorph)
+[![bundle size](https://img.shields.io/bundlephobia/minzip/casemorph)](https://bundlephobia.com/package/casemorph)
+[![TypeScript](https://img.shields.io/badge/TypeScript-strict-blue)](https://www.typescriptlang.org/)
+[![CI](https://img.shields.io/github/actions/workflow/status/best-package/casemorph/ci.yml)](https://github.com/best-package/casemorph/actions)
+[![license](https://img.shields.io/npm/l/casemorph)](./LICENSE)
+
+## The Problem
+
+Every REST API integration involves the same ritual: receive `snake_case` keys, manually map them to `camelCase`, lose all type safety in the process — or litter your code with `as` assertions.
+
+```ts
+// You do this. Every time. And it's wrong.
+const user = response.data as User; // 🤞 Hope the API matches your types
+```
+
+## The Solution
+
+```ts
+import { toCamelCase } from "casemorph";
+
+const user = toCamelCase(apiResponse);
+
+user.firstName;                  // ✅ Autocomplete works — type is string
+user.billingAddress.streetName;  // ✅ Deep transformation
+user.first_name;                 // ❌ Property 'first_name' does not exist
+```
+
+One function call. Keys transform at runtime. Types transform at compile-time. No assertions. No manual mappings. The types follow the data.
+
+## Install
+
+```bash
+npm install casemorph
+pnpm add casemorph
+bun add casemorph
+```
+
+## Quick Start
+
+```ts
+import { toCamelCase, toSnakeCase } from "casemorph";
+
+// API response → your code
+const apiResponse = {
+  user_id: 1,
+  first_name: "Alice",
+  billing_address: { street_name: "123 Main St", zip_code: "75001" },
+  recent_orders: [{ order_id: 42, total_amount: 99.99 }],
+};
+
+const user = toCamelCase(apiResponse);
+user.firstName;                      // "Alice"
+user.billingAddress.zipCode;         // "75001"
+user.recentOrders[0].totalAmount;    // 99.99
+
+// Your code → API request
+const payload = toSnakeCase({ userId: 1, firstName: "Bob" });
+payload.user_id;     // 1
+payload.first_name;  // "Bob"
+```
+
+## API Reference
+
+### Object Transforms
+
+Deeply transform all keys of an object (or array of objects). Primitives, `Date`, `RegExp`, `Map`, `Set`, and `Error` instances are preserved as-is.
+
+| Function | Target | Example key |
+|---|---|---|
+| `toCamelCase(data)` | camelCase | `userName` |
+| `toSnakeCase(data)` | snake_case | `user_name` |
+| `toKebabCase(data)` | kebab-case | `user-name` |
+| `toPascalCase(data)` | PascalCase | `UserName` |
+| `toConstantCase(data)` | CONSTANT_CASE | `USER_NAME` |
+
+```ts
+// Handles nested objects, arrays of objects, and mixed content
+toCamelCase({
+  recent_orders: [{ order_id: 1, line_items: [{ product_name: "Widget" }] }],
+});
+// { recentOrders: [{ orderId: 1, lineItems: [{ productName: "Widget" }] }] }
+```
+
+### String Transforms
+
+Transform a single string between naming conventions. When called with a string literal, the return type is the **transformed literal type**.
+
+| Function | Example |
+|---|---|
+| `camelCase(str)` | `camelCase("user_name")` → `"userName"` (type: `"userName"`) |
+| `snakeCase(str)` | `snakeCase("userName")` → `"user_name"` (type: `"user_name"`) |
+| `kebabCase(str)` | `kebabCase("userName")` → `"user-name"` (type: `"user-name"`) |
+| `pascalCase(str)` | `pascalCase("user_name")` → `"UserName"` (type: `"UserName"`) |
+| `constantCase(str)` | `constantCase("userName")` → `"USER_NAME"` (type: `"USER_NAME"`) |
+
+### Types
+
+All type-level transforms are exported for advanced use in your own types:
+
+```ts
+import type { CamelCase, CamelCaseKeys, SnakeCase, SnakeCaseKeys } from "casemorph";
+
+// String-level
+type A = CamelCase<"user_name">;           // "userName"
+type B = SnakeCase<"XMLHttpRequest">;      // "xml_http_request"
+
+// Object-level
+type ApiResponse = { user_id: number; first_name: string };
+type AppModel = CamelCaseKeys<ApiResponse>; // { userId: number; firstName: string }
+```
+
+**Available types**: `CamelCase`, `SnakeCase`, `KebabCase`, `PascalCase`, `ConstantCase`, `CamelCaseKeys`, `SnakeCaseKeys`, `KebabCaseKeys`, `PascalCaseKeys`, `ConstantCaseKeys`.
+
+## Acronym Handling
+
+casemorph correctly splits acronyms — both at runtime and at the type level:
+
+```ts
+camelCase("XMLParser");       // "xmlParser"    (not "xmlparser" or "xMLParser")
+camelCase("HTMLElement");     // "htmlElement"
+camelCase("getHTTPResponse"); // "getHttpResponse"
+snakeCase("XMLHttpRequest");  // "xml_http_request"
+```
+
+The algorithm detects boundaries between consecutive uppercase letters and the start of a new word, matching the behavior developers expect.
+
+## What Gets Transformed
+
+| Input | Transformed? |
+|---|---|
+| Plain objects (`{}`) | Yes — keys are renamed, values recursed |
+| Arrays | Yes — each element is recursed |
+| Nested objects | Yes — to arbitrary depth |
+| `Date`, `RegExp`, `Error` | No — returned as-is |
+| `Map`, `Set` | No — returned as-is |
+| Functions | No — returned as-is |
+| Primitives (`string`, `number`, `null`, ...) | No — returned as-is |
+
+## Benchmarks
+
+Measured on Apple M4, Node.js 24.x, averaged over 2s runs:
+
+| Operation | ops/sec |
+|---|---|
+| `camelCase(string)` — simple | ~3,200,000 |
+| `camelCase(string)` — acronym | ~2,400,000 |
+| `toCamelCase(obj)` — flat (8 keys) | ~340,000 |
+| `toCamelCase(obj)` — deep (nested + 10-item array) | ~37,000 |
+| `toSnakeCase(obj)` — flat (8 keys) | ~326,000 |
+| naive `key.replace(/_([a-z])/g, ...)` — flat (8 keys) | ~760,000 |
+
+The naive approach is faster for simple snake→camel on flat objects because it skips format detection and acronym handling. casemorph handles **all** formats bidirectionally, detects acronyms, recurses arbitrarily deep, and provides full type inference — for roughly 2x the cost of a hand-rolled regex.
+
+## Compatibility
+
+- Node.js >= 20
+- Bun
+- Deno
+- Cloudflare Workers
+- Any edge runtime (zero dependencies, pure ESM + CJS)
+
+## Bundle Size
+
+**387 bytes** minified + brotli. Zero dependencies.
+
+## Contributing
+
+```bash
+git clone https://github.com/best-package/casemorph.git
+cd casemorph
+npm install
+npm test          # run tests
+npm run bench     # run benchmarks
+npm run typecheck # verify types
+npm run check     # lint + format
+```
+
+## License
+
+[MIT](./LICENSE)

package/dist/index.cjs

@@ -0,0 +1,85 @@
+'use strict';
+
+// src/transform.ts
+var LOWER_TO_UPPER = /([a-z\d])([A-Z])/g;
+var ACRONYM_BOUNDARY = /([A-Z]+)([A-Z][a-z])/g;
+var SEPARATORS = /[_\-\s]+/;
+function splitWords(str) {
+  if (!str) return [];
+  return str.replace(LOWER_TO_UPPER, "$1\0$2").replace(ACRONYM_BOUNDARY, "$1\0$2").split(SEPARATORS).join("\0").split("\0").filter(Boolean).map((w) => w.toLowerCase());
+}
+function joinCamel(words) {
+  if (words.length === 0) return "";
+  return words[0] + words.slice(1).reduce((acc, w) => acc + w.charAt(0).toUpperCase() + w.slice(1), "");
+}
+function joinSnake(words) {
+  return words.join("_");
+}
+function joinKebab(words) {
+  return words.join("-");
+}
+function joinPascal(words) {
+  return words.reduce((acc, w) => acc + w.charAt(0).toUpperCase() + w.slice(1), "");
+}
+function joinConstant(words) {
+  return words.map((w) => w.toUpperCase()).join("_");
+}
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function deepTransformKeys(data, transform) {
+  if (Array.isArray(data)) {
+    return data.map((item) => deepTransformKeys(item, transform));
+  }
+  if (!isPlainObject(data)) return data;
+  const out = {};
+  for (const key of Object.keys(data)) {
+    out[transform(key)] = deepTransformKeys(data[key], transform);
+  }
+  return out;
+}
+function camelCase(str) {
+  return joinCamel(splitWords(str));
+}
+function snakeCase(str) {
+  return joinSnake(splitWords(str));
+}
+function kebabCase(str) {
+  return joinKebab(splitWords(str));
+}
+function pascalCase(str) {
+  return joinPascal(splitWords(str));
+}
+function constantCase(str) {
+  return joinConstant(splitWords(str));
+}
+function toCamelCase(data) {
+  return deepTransformKeys(data, (k) => joinCamel(splitWords(k)));
+}
+function toSnakeCase(data) {
+  return deepTransformKeys(data, (k) => joinSnake(splitWords(k)));
+}
+function toKebabCase(data) {
+  return deepTransformKeys(data, (k) => joinKebab(splitWords(k)));
+}
+function toPascalCase(data) {
+  return deepTransformKeys(data, (k) => joinPascal(splitWords(k)));
+}
+function toConstantCase(data) {
+  return deepTransformKeys(data, (k) => joinConstant(splitWords(k)));
+}
+
+exports.camelCase = camelCase;
+exports.constantCase = constantCase;
+exports.kebabCase = kebabCase;
+exports.pascalCase = pascalCase;
+exports.snakeCase = snakeCase;
+exports.toCamelCase = toCamelCase;
+exports.toConstantCase = toConstantCase;
+exports.toKebabCase = toKebabCase;
+exports.toPascalCase = toPascalCase;
+exports.toSnakeCase = toSnakeCase;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/transform.ts"],"names":[],"mappings":"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","file":"index.cjs","sourcesContent":["import type {\n\tCamelCase,\n\tCamelCaseKeys,\n\tConstantCase,\n\tConstantCaseKeys,\n\tKebabCase,\n\tKebabCaseKeys,\n\tPascalCase,\n\tPascalCaseKeys,\n\tSnakeCase,\n\tSnakeCaseKeys,\n} from \"./types.js\";\n\n// ---------------------------------------------------------------------------\n// Word splitting — mirrors the type-level SplitWords<S>\n// ---------------------------------------------------------------------------\n\n/** Boundary between a lowercase letter (or digit) and an uppercase letter. */\nconst LOWER_TO_UPPER = /([a-z\\d])([A-Z])/g;\n\n/** Boundary between an acronym and the start of the next word. */\nconst ACRONYM_BOUNDARY = /([A-Z]+)([A-Z][a-z])/g;\n\n/** Any explicit separator (underscore, hyphen, whitespace). */\nconst SEPARATORS = /[_\\-\\s]+/;\n\n/**\n * Split any casing convention into lowercase word fragments.\n *\n * Handles snake_case, kebab-case, CONSTANT_CASE, camelCase, PascalCase,\n * and acronyms like `\"XMLHttpRequest\"` → `[\"xml\", \"http\", \"request\"]`.\n */\nfunction splitWords(str: string): string[] {\n\tif (!str) return [];\n\treturn str\n\t\t.replace(LOWER_TO_UPPER, \"$1\\x00$2\")\n\t\t.replace(ACRONYM_BOUNDARY, \"$1\\x00$2\")\n\t\t.split(SEPARATORS)\n\t\t.join(\"\\x00\")\n\t\t.split(\"\\x00\")\n\t\t.filter(Boolean)\n\t\t.map((w) => w.toLowerCase());\n}\n\n// ---------------------------------------------------------------------------\n// Join helpers — one per target format\n// ---------------------------------------------------------------------------\n\nfunction joinCamel(words: string[]): string {\n\tif (words.length === 0) return \"\";\n\treturn (\n\t\twords[0] + words.slice(1).reduce((acc, w) => acc + w.charAt(0).toUpperCase() + w.slice(1), \"\")\n\t);\n}\n\nfunction joinSnake(words: string[]): string {\n\treturn words.join(\"_\");\n}\n\nfunction joinKebab(words: string[]): string {\n\treturn words.join(\"-\");\n}\n\nfunction joinPascal(words: string[]): string {\n\treturn words.reduce((acc, w) => acc + w.charAt(0).toUpperCase() + w.slice(1), \"\");\n}\n\nfunction joinConstant(words: string[]): string {\n\treturn words.map((w) => w.toUpperCase()).join(\"_\");\n}\n\n// ---------------------------------------------------------------------------\n// Deep key transformation\n// ---------------------------------------------------------------------------\n\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n\tif (typeof value !== \"object\" || value === null) return false;\n\tconst proto = Object.getPrototypeOf(value) as unknown;\n\treturn proto === Object.prototype || proto === null;\n}\n\nfunction deepTransformKeys(data: unknown, transform: (key: string) => string): unknown {\n\tif (Array.isArray(data)) {\n\t\treturn data.map((item) => deepTransformKeys(item, transform));\n\t}\n\tif (!isPlainObject(data)) return data;\n\n\tconst out: Record<string, unknown> = {};\n\tfor (const key of Object.keys(data)) {\n\t\tout[transform(key)] = deepTransformKeys(data[key], transform);\n\t}\n\treturn out;\n}\n\n// ---------------------------------------------------------------------------\n// String-level transforms (public)\n// ---------------------------------------------------------------------------\n\n/**\n * Convert a string to camelCase.\n *\n * @example\n * camelCase('user_name')    // 'userName'\n * camelCase('XMLParser')    // 'xmlParser'\n * camelCase('content-type') // 'contentType'\n */\nexport function camelCase<S extends string>(str: S): CamelCase<S> {\n\treturn joinCamel(splitWords(str)) as CamelCase<S>;\n}\n\n/**\n * Convert a string to snake_case.\n *\n * @example\n * snakeCase('userName')     // 'user_name'\n * snakeCase('XMLParser')    // 'xml_parser'\n * snakeCase('content-type') // 'content_type'\n */\nexport function snakeCase<S extends string>(str: S): SnakeCase<S> {\n\treturn joinSnake(splitWords(str)) as SnakeCase<S>;\n}\n\n/**\n * Convert a string to kebab-case.\n *\n * @example\n * kebabCase('userName')   // 'user-name'\n * kebabCase('XMLParser')  // 'xml-parser'\n * kebabCase('user_name')  // 'user-name'\n */\nexport function kebabCase<S extends string>(str: S): KebabCase<S> {\n\treturn joinKebab(splitWords(str)) as KebabCase<S>;\n}\n\n/**\n * Convert a string to PascalCase.\n *\n * @example\n * pascalCase('user_name')  // 'UserName'\n * pascalCase('XMLParser')  // 'XmlParser'\n * pascalCase('kebab-case') // 'KebabCase'\n */\nexport function pascalCase<S extends string>(str: S): PascalCase<S> {\n\treturn joinPascal(splitWords(str)) as PascalCase<S>;\n}\n\n/**\n * Convert a string to CONSTANT_CASE.\n *\n * @example\n * constantCase('userName')   // 'USER_NAME'\n * constantCase('XMLParser')  // 'XML_PARSER'\n * constantCase('kebab-case') // 'KEBAB_CASE'\n */\nexport function constantCase<S extends string>(str: S): ConstantCase<S> {\n\treturn joinConstant(splitWords(str)) as ConstantCase<S>;\n}\n\n// ---------------------------------------------------------------------------\n// Object-level transforms (public)\n// ---------------------------------------------------------------------------\n\n/**\n * Deeply transform all keys of an object (or array of objects) to camelCase.\n * Primitives, Dates, RegExps, Maps, Sets, and other non-plain objects are preserved.\n *\n * @example\n * const result = toCamelCase({ user_name: 'Alice', billing_address: { zip_code: '75001' } })\n * result.userName               // 'Alice'\n * result.billingAddress.zipCode // '75001'\n */\nexport function toCamelCase<T>(data: T): CamelCaseKeys<T> {\n\treturn deepTransformKeys(data, (k) => joinCamel(splitWords(k))) as CamelCaseKeys<T>;\n}\n\n/**\n * Deeply transform all keys of an object (or array of objects) to snake_case.\n *\n * @example\n * const result = toSnakeCase({ userName: 'Alice', billingAddress: { zipCode: '75001' } })\n * result.user_name                  // 'Alice'\n * result.billing_address.zip_code   // '75001'\n */\nexport function toSnakeCase<T>(data: T): SnakeCaseKeys<T> {\n\treturn deepTransformKeys(data, (k) => joinSnake(splitWords(k))) as SnakeCaseKeys<T>;\n}\n\n/**\n * Deeply transform all keys of an object (or array of objects) to kebab-case.\n *\n * @example\n * const result = toKebabCase({ userName: 'Alice' })\n * result['user-name'] // 'Alice'\n */\nexport function toKebabCase<T>(data: T): KebabCaseKeys<T> {\n\treturn deepTransformKeys(data, (k) => joinKebab(splitWords(k))) as KebabCaseKeys<T>;\n}\n\n/**\n * Deeply transform all keys of an object (or array of objects) to PascalCase.\n *\n * @example\n * const result = toPascalCase({ user_name: 'Alice' })\n * result.UserName // 'Alice'\n */\nexport function toPascalCase<T>(data: T): PascalCaseKeys<T> {\n\treturn deepTransformKeys(data, (k) => joinPascal(splitWords(k))) as PascalCaseKeys<T>;\n}\n\n/**\n * Deeply transform all keys of an object (or array of objects) to CONSTANT_CASE.\n *\n * @example\n * const result = toConstantCase({ userName: 'Alice' })\n * result.USER_NAME // 'Alice'\n */\nexport function toConstantCase<T>(data: T): ConstantCaseKeys<T> {\n\treturn deepTransformKeys(data, (k) => joinConstant(splitWords(k))) as ConstantCaseKeys<T>;\n}\n"]}

package/dist/index.d.cts

@@ -0,0 +1,154 @@
+/** True when `C` is a single uppercase ASCII letter (A-Z). */
+type IsUpperLetter<C extends string> = Uppercase<C> extends C ? Lowercase<C> extends C ? false : true : false;
+/**
+ * True when the first character of `S` is a lowercase letter or digit.
+ * Used to detect the end of an acronym run (e.g. the 'a' in "XMLParser").
+ */
+type IsNextLower<S extends string> = S extends `${infer H}${string}` ? IsUpperLetter<H> extends true ? false : H extends "_" | "-" | " " ? false : true : false;
+/**
+ * Splits any casing convention into a tuple of raw word fragments.
+ *
+ * Handles snake_case, kebab-case, CONSTANT_CASE, camelCase, PascalCase,
+ * and acronyms (e.g. `"XMLHttpRequest"` → `["XML", "Http", "Request"]`).
+ */
+type SplitWords<S extends string> = _Split<S, "", false>;
+type _Split<S extends string, W extends string, PU extends boolean> = S extends `${infer H}${infer T}` ? H extends "_" | "-" | " " ? W extends "" ? _Split<T, "", false> : [W, ..._Split<T, "", false>] : IsUpperLetter<H> extends true ? PU extends true ? IsNextLower<T> extends true ? W extends "" ? _Split<T, H, true> : [W, ..._Split<T, H, true>] : _Split<T, `${W}${H}`, true> : W extends "" ? _Split<T, H, true> : [W, ..._Split<T, H, true>] : _Split<T, `${W}${H}`, false> : W extends "" ? [] : [W];
+type JoinCamel<W extends readonly string[]> = W extends readonly [
+    infer F extends string,
+    ...infer R extends string[]
+] ? `${Lowercase<F>}${JoinPascal<R>}` : "";
+type JoinPascal<W extends readonly string[]> = W extends readonly [
+    infer F extends string,
+    ...infer R extends string[]
+] ? `${Capitalize<Lowercase<F>>}${JoinPascal<R>}` : "";
+type JoinSep<W extends readonly string[], S extends string> = W extends readonly [
+    infer F extends string,
+    ...infer R extends string[]
+] ? R extends readonly [string, ...string[]] ? `${Lowercase<F>}${S}${JoinSep<R, S>}` : Lowercase<F> : "";
+type JoinConstant<W extends readonly string[]> = W extends readonly [
+    infer F extends string,
+    ...infer R extends string[]
+] ? R extends readonly [string, ...string[]] ? `${Uppercase<F>}_${JoinConstant<R>}` : Uppercase<F> : "";
+/** Transform a string literal to `camelCase`. */
+type CamelCase<S extends string> = string extends S ? string : JoinCamel<SplitWords<S>>;
+/** Transform a string literal to `snake_case`. */
+type SnakeCase<S extends string> = string extends S ? string : JoinSep<SplitWords<S>, "_">;
+/** Transform a string literal to `kebab-case`. */
+type KebabCase<S extends string> = string extends S ? string : JoinSep<SplitWords<S>, "-">;
+/** Transform a string literal to `PascalCase`. */
+type PascalCase<S extends string> = string extends S ? string : JoinPascal<SplitWords<S>>;
+/** Transform a string literal to `CONSTANT_CASE`. */
+type ConstantCase<S extends string> = string extends S ? string : JoinConstant<SplitWords<S>>;
+/** Object types that should be treated as opaque leaves (never recursed into). */
+type Leaf = Date | RegExp | Error | Map<unknown, unknown> | Set<unknown>;
+/** Deeply transform all keys of `T` to camelCase. */
+type CamelCaseKeys<T> = T extends Leaf ? T : T extends (...args: any[]) => any ? T : T extends readonly (infer U)[] ? CamelCaseKeys<U>[] : T extends object ? {
+    [K in keyof T as CamelCase<K & string>]: CamelCaseKeys<T[K]>;
+} : T;
+/** Deeply transform all keys of `T` to snake_case. */
+type SnakeCaseKeys<T> = T extends Leaf ? T : T extends (...args: any[]) => any ? T : T extends readonly (infer U)[] ? SnakeCaseKeys<U>[] : T extends object ? {
+    [K in keyof T as SnakeCase<K & string>]: SnakeCaseKeys<T[K]>;
+} : T;
+/** Deeply transform all keys of `T` to kebab-case. */
+type KebabCaseKeys<T> = T extends Leaf ? T : T extends (...args: any[]) => any ? T : T extends readonly (infer U)[] ? KebabCaseKeys<U>[] : T extends object ? {
+    [K in keyof T as KebabCase<K & string>]: KebabCaseKeys<T[K]>;
+} : T;
+/** Deeply transform all keys of `T` to PascalCase. */
+type PascalCaseKeys<T> = T extends Leaf ? T : T extends (...args: any[]) => any ? T : T extends readonly (infer U)[] ? PascalCaseKeys<U>[] : T extends object ? {
+    [K in keyof T as PascalCase<K & string>]: PascalCaseKeys<T[K]>;
+} : T;
+/** Deeply transform all keys of `T` to CONSTANT_CASE. */
+type ConstantCaseKeys<T> = T extends Leaf ? T : T extends (...args: any[]) => any ? T : T extends readonly (infer U)[] ? ConstantCaseKeys<U>[] : T extends object ? {
+    [K in keyof T as ConstantCase<K & string>]: ConstantCaseKeys<T[K]>;
+} : T;
+
+/**
+ * Convert a string to camelCase.
+ *
+ * @example
+ * camelCase('user_name')    // 'userName'
+ * camelCase('XMLParser')    // 'xmlParser'
+ * camelCase('content-type') // 'contentType'
+ */
+declare function camelCase<S extends string>(str: S): CamelCase<S>;
+/**
+ * Convert a string to snake_case.
+ *
+ * @example
+ * snakeCase('userName')     // 'user_name'
+ * snakeCase('XMLParser')    // 'xml_parser'
+ * snakeCase('content-type') // 'content_type'
+ */
+declare function snakeCase<S extends string>(str: S): SnakeCase<S>;
+/**
+ * Convert a string to kebab-case.
+ *
+ * @example
+ * kebabCase('userName')   // 'user-name'
+ * kebabCase('XMLParser')  // 'xml-parser'
+ * kebabCase('user_name')  // 'user-name'
+ */
+declare function kebabCase<S extends string>(str: S): KebabCase<S>;
+/**
+ * Convert a string to PascalCase.
+ *
+ * @example
+ * pascalCase('user_name')  // 'UserName'
+ * pascalCase('XMLParser')  // 'XmlParser'
+ * pascalCase('kebab-case') // 'KebabCase'
+ */
+declare function pascalCase<S extends string>(str: S): PascalCase<S>;
+/**
+ * Convert a string to CONSTANT_CASE.
+ *
+ * @example
+ * constantCase('userName')   // 'USER_NAME'
+ * constantCase('XMLParser')  // 'XML_PARSER'
+ * constantCase('kebab-case') // 'KEBAB_CASE'
+ */
+declare function constantCase<S extends string>(str: S): ConstantCase<S>;
+/**
+ * Deeply transform all keys of an object (or array of objects) to camelCase.
+ * Primitives, Dates, RegExps, Maps, Sets, and other non-plain objects are preserved.
+ *
+ * @example
+ * const result = toCamelCase({ user_name: 'Alice', billing_address: { zip_code: '75001' } })
+ * result.userName               // 'Alice'
+ * result.billingAddress.zipCode // '75001'
+ */
+declare function toCamelCase<T>(data: T): CamelCaseKeys<T>;
+/**
+ * Deeply transform all keys of an object (or array of objects) to snake_case.
+ *
+ * @example
+ * const result = toSnakeCase({ userName: 'Alice', billingAddress: { zipCode: '75001' } })
+ * result.user_name                  // 'Alice'
+ * result.billing_address.zip_code   // '75001'
+ */
+declare function toSnakeCase<T>(data: T): SnakeCaseKeys<T>;
+/**
+ * Deeply transform all keys of an object (or array of objects) to kebab-case.
+ *
+ * @example
+ * const result = toKebabCase({ userName: 'Alice' })
+ * result['user-name'] // 'Alice'
+ */
+declare function toKebabCase<T>(data: T): KebabCaseKeys<T>;
+/**
+ * Deeply transform all keys of an object (or array of objects) to PascalCase.
+ *
+ * @example
+ * const result = toPascalCase({ user_name: 'Alice' })
+ * result.UserName // 'Alice'
+ */
+declare function toPascalCase<T>(data: T): PascalCaseKeys<T>;
+/**
+ * Deeply transform all keys of an object (or array of objects) to CONSTANT_CASE.
+ *
+ * @example
+ * const result = toConstantCase({ userName: 'Alice' })
+ * result.USER_NAME // 'Alice'
+ */
+declare function toConstantCase<T>(data: T): ConstantCaseKeys<T>;
+
+export { type CamelCase, type CamelCaseKeys, type ConstantCase, type ConstantCaseKeys, type KebabCase, type KebabCaseKeys, type PascalCase, type PascalCaseKeys, type SnakeCase, type SnakeCaseKeys, camelCase, constantCase, kebabCase, pascalCase, snakeCase, toCamelCase, toConstantCase, toKebabCase, toPascalCase, toSnakeCase };

package/dist/index.d.ts

@@ -0,0 +1,154 @@
+/** True when `C` is a single uppercase ASCII letter (A-Z). */
+type IsUpperLetter<C extends string> = Uppercase<C> extends C ? Lowercase<C> extends C ? false : true : false;
+/**
+ * True when the first character of `S` is a lowercase letter or digit.
+ * Used to detect the end of an acronym run (e.g. the 'a' in "XMLParser").
+ */
+type IsNextLower<S extends string> = S extends `${infer H}${string}` ? IsUpperLetter<H> extends true ? false : H extends "_" | "-" | " " ? false : true : false;
+/**
+ * Splits any casing convention into a tuple of raw word fragments.
+ *
+ * Handles snake_case, kebab-case, CONSTANT_CASE, camelCase, PascalCase,
+ * and acronyms (e.g. `"XMLHttpRequest"` → `["XML", "Http", "Request"]`).
+ */
+type SplitWords<S extends string> = _Split<S, "", false>;
+type _Split<S extends string, W extends string, PU extends boolean> = S extends `${infer H}${infer T}` ? H extends "_" | "-" | " " ? W extends "" ? _Split<T, "", false> : [W, ..._Split<T, "", false>] : IsUpperLetter<H> extends true ? PU extends true ? IsNextLower<T> extends true ? W extends "" ? _Split<T, H, true> : [W, ..._Split<T, H, true>] : _Split<T, `${W}${H}`, true> : W extends "" ? _Split<T, H, true> : [W, ..._Split<T, H, true>] : _Split<T, `${W}${H}`, false> : W extends "" ? [] : [W];
+type JoinCamel<W extends readonly string[]> = W extends readonly [
+    infer F extends string,
+    ...infer R extends string[]
+] ? `${Lowercase<F>}${JoinPascal<R>}` : "";
+type JoinPascal<W extends readonly string[]> = W extends readonly [
+    infer F extends string,
+    ...infer R extends string[]
+] ? `${Capitalize<Lowercase<F>>}${JoinPascal<R>}` : "";
+type JoinSep<W extends readonly string[], S extends string> = W extends readonly [
+    infer F extends string,
+    ...infer R extends string[]
+] ? R extends readonly [string, ...string[]] ? `${Lowercase<F>}${S}${JoinSep<R, S>}` : Lowercase<F> : "";
+type JoinConstant<W extends readonly string[]> = W extends readonly [
+    infer F extends string,
+    ...infer R extends string[]
+] ? R extends readonly [string, ...string[]] ? `${Uppercase<F>}_${JoinConstant<R>}` : Uppercase<F> : "";
+/** Transform a string literal to `camelCase`. */
+type CamelCase<S extends string> = string extends S ? string : JoinCamel<SplitWords<S>>;
+/** Transform a string literal to `snake_case`. */
+type SnakeCase<S extends string> = string extends S ? string : JoinSep<SplitWords<S>, "_">;
+/** Transform a string literal to `kebab-case`. */
+type KebabCase<S extends string> = string extends S ? string : JoinSep<SplitWords<S>, "-">;
+/** Transform a string literal to `PascalCase`. */
+type PascalCase<S extends string> = string extends S ? string : JoinPascal<SplitWords<S>>;
+/** Transform a string literal to `CONSTANT_CASE`. */
+type ConstantCase<S extends string> = string extends S ? string : JoinConstant<SplitWords<S>>;
+/** Object types that should be treated as opaque leaves (never recursed into). */
+type Leaf = Date | RegExp | Error | Map<unknown, unknown> | Set<unknown>;
+/** Deeply transform all keys of `T` to camelCase. */
+type CamelCaseKeys<T> = T extends Leaf ? T : T extends (...args: any[]) => any ? T : T extends readonly (infer U)[] ? CamelCaseKeys<U>[] : T extends object ? {
+    [K in keyof T as CamelCase<K & string>]: CamelCaseKeys<T[K]>;
+} : T;
+/** Deeply transform all keys of `T` to snake_case. */
+type SnakeCaseKeys<T> = T extends Leaf ? T : T extends (...args: any[]) => any ? T : T extends readonly (infer U)[] ? SnakeCaseKeys<U>[] : T extends object ? {
+    [K in keyof T as SnakeCase<K & string>]: SnakeCaseKeys<T[K]>;
+} : T;
+/** Deeply transform all keys of `T` to kebab-case. */
+type KebabCaseKeys<T> = T extends Leaf ? T : T extends (...args: any[]) => any ? T : T extends readonly (infer U)[] ? KebabCaseKeys<U>[] : T extends object ? {
+    [K in keyof T as KebabCase<K & string>]: KebabCaseKeys<T[K]>;
+} : T;
+/** Deeply transform all keys of `T` to PascalCase. */
+type PascalCaseKeys<T> = T extends Leaf ? T : T extends (...args: any[]) => any ? T : T extends readonly (infer U)[] ? PascalCaseKeys<U>[] : T extends object ? {
+    [K in keyof T as PascalCase<K & string>]: PascalCaseKeys<T[K]>;
+} : T;
+/** Deeply transform all keys of `T` to CONSTANT_CASE. */
+type ConstantCaseKeys<T> = T extends Leaf ? T : T extends (...args: any[]) => any ? T : T extends readonly (infer U)[] ? ConstantCaseKeys<U>[] : T extends object ? {
+    [K in keyof T as ConstantCase<K & string>]: ConstantCaseKeys<T[K]>;
+} : T;
+
+/**
+ * Convert a string to camelCase.
+ *
+ * @example
+ * camelCase('user_name')    // 'userName'
+ * camelCase('XMLParser')    // 'xmlParser'
+ * camelCase('content-type') // 'contentType'
+ */
+declare function camelCase<S extends string>(str: S): CamelCase<S>;
+/**
+ * Convert a string to snake_case.
+ *
+ * @example
+ * snakeCase('userName')     // 'user_name'
+ * snakeCase('XMLParser')    // 'xml_parser'
+ * snakeCase('content-type') // 'content_type'
+ */
+declare function snakeCase<S extends string>(str: S): SnakeCase<S>;
+/**
+ * Convert a string to kebab-case.
+ *
+ * @example
+ * kebabCase('userName')   // 'user-name'
+ * kebabCase('XMLParser')  // 'xml-parser'
+ * kebabCase('user_name')  // 'user-name'
+ */
+declare function kebabCase<S extends string>(str: S): KebabCase<S>;
+/**
+ * Convert a string to PascalCase.
+ *
+ * @example
+ * pascalCase('user_name')  // 'UserName'
+ * pascalCase('XMLParser')  // 'XmlParser'
+ * pascalCase('kebab-case') // 'KebabCase'
+ */
+declare function pascalCase<S extends string>(str: S): PascalCase<S>;
+/**
+ * Convert a string to CONSTANT_CASE.
+ *
+ * @example
+ * constantCase('userName')   // 'USER_NAME'
+ * constantCase('XMLParser')  // 'XML_PARSER'
+ * constantCase('kebab-case') // 'KEBAB_CASE'
+ */
+declare function constantCase<S extends string>(str: S): ConstantCase<S>;
+/**
+ * Deeply transform all keys of an object (or array of objects) to camelCase.
+ * Primitives, Dates, RegExps, Maps, Sets, and other non-plain objects are preserved.
+ *
+ * @example
+ * const result = toCamelCase({ user_name: 'Alice', billing_address: { zip_code: '75001' } })
+ * result.userName               // 'Alice'
+ * result.billingAddress.zipCode // '75001'
+ */
+declare function toCamelCase<T>(data: T): CamelCaseKeys<T>;
+/**
+ * Deeply transform all keys of an object (or array of objects) to snake_case.
+ *
+ * @example
+ * const result = toSnakeCase({ userName: 'Alice', billingAddress: { zipCode: '75001' } })
+ * result.user_name                  // 'Alice'
+ * result.billing_address.zip_code   // '75001'
+ */
+declare function toSnakeCase<T>(data: T): SnakeCaseKeys<T>;
+/**
+ * Deeply transform all keys of an object (or array of objects) to kebab-case.
+ *
+ * @example
+ * const result = toKebabCase({ userName: 'Alice' })
+ * result['user-name'] // 'Alice'
+ */
+declare function toKebabCase<T>(data: T): KebabCaseKeys<T>;
+/**
+ * Deeply transform all keys of an object (or array of objects) to PascalCase.
+ *
+ * @example
+ * const result = toPascalCase({ user_name: 'Alice' })
+ * result.UserName // 'Alice'
+ */
+declare function toPascalCase<T>(data: T): PascalCaseKeys<T>;
+/**
+ * Deeply transform all keys of an object (or array of objects) to CONSTANT_CASE.
+ *
+ * @example
+ * const result = toConstantCase({ userName: 'Alice' })
+ * result.USER_NAME // 'Alice'
+ */
+declare function toConstantCase<T>(data: T): ConstantCaseKeys<T>;
+
+export { type CamelCase, type CamelCaseKeys, type ConstantCase, type ConstantCaseKeys, type KebabCase, type KebabCaseKeys, type PascalCase, type PascalCaseKeys, type SnakeCase, type SnakeCaseKeys, camelCase, constantCase, kebabCase, pascalCase, snakeCase, toCamelCase, toConstantCase, toKebabCase, toPascalCase, toSnakeCase };

package/dist/index.js

@@ -0,0 +1,74 @@
+// src/transform.ts
+var LOWER_TO_UPPER = /([a-z\d])([A-Z])/g;
+var ACRONYM_BOUNDARY = /([A-Z]+)([A-Z][a-z])/g;
+var SEPARATORS = /[_\-\s]+/;
+function splitWords(str) {
+  if (!str) return [];
+  return str.replace(LOWER_TO_UPPER, "$1\0$2").replace(ACRONYM_BOUNDARY, "$1\0$2").split(SEPARATORS).join("\0").split("\0").filter(Boolean).map((w) => w.toLowerCase());
+}
+function joinCamel(words) {
+  if (words.length === 0) return "";
+  return words[0] + words.slice(1).reduce((acc, w) => acc + w.charAt(0).toUpperCase() + w.slice(1), "");
+}
+function joinSnake(words) {
+  return words.join("_");
+}
+function joinKebab(words) {
+  return words.join("-");
+}
+function joinPascal(words) {
+  return words.reduce((acc, w) => acc + w.charAt(0).toUpperCase() + w.slice(1), "");
+}
+function joinConstant(words) {
+  return words.map((w) => w.toUpperCase()).join("_");
+}
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function deepTransformKeys(data, transform) {
+  if (Array.isArray(data)) {
+    return data.map((item) => deepTransformKeys(item, transform));
+  }
+  if (!isPlainObject(data)) return data;
+  const out = {};
+  for (const key of Object.keys(data)) {
+    out[transform(key)] = deepTransformKeys(data[key], transform);
+  }
+  return out;
+}
+function camelCase(str) {
+  return joinCamel(splitWords(str));
+}
+function snakeCase(str) {
+  return joinSnake(splitWords(str));
+}
+function kebabCase(str) {
+  return joinKebab(splitWords(str));
+}
+function pascalCase(str) {
+  return joinPascal(splitWords(str));
+}
+function constantCase(str) {
+  return joinConstant(splitWords(str));
+}
+function toCamelCase(data) {
+  return deepTransformKeys(data, (k) => joinCamel(splitWords(k)));
+}
+function toSnakeCase(data) {
+  return deepTransformKeys(data, (k) => joinSnake(splitWords(k)));
+}
+function toKebabCase(data) {
+  return deepTransformKeys(data, (k) => joinKebab(splitWords(k)));
+}
+function toPascalCase(data) {
+  return deepTransformKeys(data, (k) => joinPascal(splitWords(k)));
+}
+function toConstantCase(data) {
+  return deepTransformKeys(data, (k) => joinConstant(splitWords(k)));
+}
+
+export { camelCase, constantCase, kebabCase, pascalCase, snakeCase, toCamelCase, toConstantCase, toKebabCase, toPascalCase, toSnakeCase };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/transform.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["import type {\n\tCamelCase,\n\tCamelCaseKeys,\n\tConstantCase,\n\tConstantCaseKeys,\n\tKebabCase,\n\tKebabCaseKeys,\n\tPascalCase,\n\tPascalCaseKeys,\n\tSnakeCase,\n\tSnakeCaseKeys,\n} from \"./types.js\";\n\n// ---------------------------------------------------------------------------\n// Word splitting — mirrors the type-level SplitWords<S>\n// ---------------------------------------------------------------------------\n\n/** Boundary between a lowercase letter (or digit) and an uppercase letter. */\nconst LOWER_TO_UPPER = /([a-z\\d])([A-Z])/g;\n\n/** Boundary between an acronym and the start of the next word. */\nconst ACRONYM_BOUNDARY = /([A-Z]+)([A-Z][a-z])/g;\n\n/** Any explicit separator (underscore, hyphen, whitespace). */\nconst SEPARATORS = /[_\\-\\s]+/;\n\n/**\n * Split any casing convention into lowercase word fragments.\n *\n * Handles snake_case, kebab-case, CONSTANT_CASE, camelCase, PascalCase,\n * and acronyms like `\"XMLHttpRequest\"` → `[\"xml\", \"http\", \"request\"]`.\n */\nfunction splitWords(str: string): string[] {\n\tif (!str) return [];\n\treturn str\n\t\t.replace(LOWER_TO_UPPER, \"$1\\x00$2\")\n\t\t.replace(ACRONYM_BOUNDARY, \"$1\\x00$2\")\n\t\t.split(SEPARATORS)\n\t\t.join(\"\\x00\")\n\t\t.split(\"\\x00\")\n\t\t.filter(Boolean)\n\t\t.map((w) => w.toLowerCase());\n}\n\n// ---------------------------------------------------------------------------\n// Join helpers — one per target format\n// ---------------------------------------------------------------------------\n\nfunction joinCamel(words: string[]): string {\n\tif (words.length === 0) return \"\";\n\treturn (\n\t\twords[0] + words.slice(1).reduce((acc, w) => acc + w.charAt(0).toUpperCase() + w.slice(1), \"\")\n\t);\n}\n\nfunction joinSnake(words: string[]): string {\n\treturn words.join(\"_\");\n}\n\nfunction joinKebab(words: string[]): string {\n\treturn words.join(\"-\");\n}\n\nfunction joinPascal(words: string[]): string {\n\treturn words.reduce((acc, w) => acc + w.charAt(0).toUpperCase() + w.slice(1), \"\");\n}\n\nfunction joinConstant(words: string[]): string {\n\treturn words.map((w) => w.toUpperCase()).join(\"_\");\n}\n\n// ---------------------------------------------------------------------------\n// Deep key transformation\n// ---------------------------------------------------------------------------\n\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n\tif (typeof value !== \"object\" || value === null) return false;\n\tconst proto = Object.getPrototypeOf(value) as unknown;\n\treturn proto === Object.prototype || proto === null;\n}\n\nfunction deepTransformKeys(data: unknown, transform: (key: string) => string): unknown {\n\tif (Array.isArray(data)) {\n\t\treturn data.map((item) => deepTransformKeys(item, transform));\n\t}\n\tif (!isPlainObject(data)) return data;\n\n\tconst out: Record<string, unknown> = {};\n\tfor (const key of Object.keys(data)) {\n\t\tout[transform(key)] = deepTransformKeys(data[key], transform);\n\t}\n\treturn out;\n}\n\n// ---------------------------------------------------------------------------\n// String-level transforms (public)\n// ---------------------------------------------------------------------------\n\n/**\n * Convert a string to camelCase.\n *\n * @example\n * camelCase('user_name')    // 'userName'\n * camelCase('XMLParser')    // 'xmlParser'\n * camelCase('content-type') // 'contentType'\n */\nexport function camelCase<S extends string>(str: S): CamelCase<S> {\n\treturn joinCamel(splitWords(str)) as CamelCase<S>;\n}\n\n/**\n * Convert a string to snake_case.\n *\n * @example\n * snakeCase('userName')     // 'user_name'\n * snakeCase('XMLParser')    // 'xml_parser'\n * snakeCase('content-type') // 'content_type'\n */\nexport function snakeCase<S extends string>(str: S): SnakeCase<S> {\n\treturn joinSnake(splitWords(str)) as SnakeCase<S>;\n}\n\n/**\n * Convert a string to kebab-case.\n *\n * @example\n * kebabCase('userName')   // 'user-name'\n * kebabCase('XMLParser')  // 'xml-parser'\n * kebabCase('user_name')  // 'user-name'\n */\nexport function kebabCase<S extends string>(str: S): KebabCase<S> {\n\treturn joinKebab(splitWords(str)) as KebabCase<S>;\n}\n\n/**\n * Convert a string to PascalCase.\n *\n * @example\n * pascalCase('user_name')  // 'UserName'\n * pascalCase('XMLParser')  // 'XmlParser'\n * pascalCase('kebab-case') // 'KebabCase'\n */\nexport function pascalCase<S extends string>(str: S): PascalCase<S> {\n\treturn joinPascal(splitWords(str)) as PascalCase<S>;\n}\n\n/**\n * Convert a string to CONSTANT_CASE.\n *\n * @example\n * constantCase('userName')   // 'USER_NAME'\n * constantCase('XMLParser')  // 'XML_PARSER'\n * constantCase('kebab-case') // 'KEBAB_CASE'\n */\nexport function constantCase<S extends string>(str: S): ConstantCase<S> {\n\treturn joinConstant(splitWords(str)) as ConstantCase<S>;\n}\n\n// ---------------------------------------------------------------------------\n// Object-level transforms (public)\n// ---------------------------------------------------------------------------\n\n/**\n * Deeply transform all keys of an object (or array of objects) to camelCase.\n * Primitives, Dates, RegExps, Maps, Sets, and other non-plain objects are preserved.\n *\n * @example\n * const result = toCamelCase({ user_name: 'Alice', billing_address: { zip_code: '75001' } })\n * result.userName               // 'Alice'\n * result.billingAddress.zipCode // '75001'\n */\nexport function toCamelCase<T>(data: T): CamelCaseKeys<T> {\n\treturn deepTransformKeys(data, (k) => joinCamel(splitWords(k))) as CamelCaseKeys<T>;\n}\n\n/**\n * Deeply transform all keys of an object (or array of objects) to snake_case.\n *\n * @example\n * const result = toSnakeCase({ userName: 'Alice', billingAddress: { zipCode: '75001' } })\n * result.user_name                  // 'Alice'\n * result.billing_address.zip_code   // '75001'\n */\nexport function toSnakeCase<T>(data: T): SnakeCaseKeys<T> {\n\treturn deepTransformKeys(data, (k) => joinSnake(splitWords(k))) as SnakeCaseKeys<T>;\n}\n\n/**\n * Deeply transform all keys of an object (or array of objects) to kebab-case.\n *\n * @example\n * const result = toKebabCase({ userName: 'Alice' })\n * result['user-name'] // 'Alice'\n */\nexport function toKebabCase<T>(data: T): KebabCaseKeys<T> {\n\treturn deepTransformKeys(data, (k) => joinKebab(splitWords(k))) as KebabCaseKeys<T>;\n}\n\n/**\n * Deeply transform all keys of an object (or array of objects) to PascalCase.\n *\n * @example\n * const result = toPascalCase({ user_name: 'Alice' })\n * result.UserName // 'Alice'\n */\nexport function toPascalCase<T>(data: T): PascalCaseKeys<T> {\n\treturn deepTransformKeys(data, (k) => joinPascal(splitWords(k))) as PascalCaseKeys<T>;\n}\n\n/**\n * Deeply transform all keys of an object (or array of objects) to CONSTANT_CASE.\n *\n * @example\n * const result = toConstantCase({ userName: 'Alice' })\n * result.USER_NAME // 'Alice'\n */\nexport function toConstantCase<T>(data: T): ConstantCaseKeys<T> {\n\treturn deepTransformKeys(data, (k) => joinConstant(splitWords(k))) as ConstantCaseKeys<T>;\n}\n"]}

package/package.json

@@ -0,0 +1,77 @@
+{
+	"name": "casemorph",
+	"version": "0.1.0",
+	"description": "Type-safe deep case transformation for objects — snake_case, camelCase, kebab-case, PascalCase, CONSTANT_CASE with full TypeScript inference",
+	"author": "Ludovic Blondon",
+	"license": "MIT",
+	"type": "module",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js",
+			"require": "./dist/index.cjs"
+		}
+	},
+	"main": "./dist/index.cjs",
+	"module": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"files": ["dist", "README.md", "LICENSE", "CHANGELOG.md"],
+	"sideEffects": false,
+	"engines": {
+		"node": ">=20"
+	},
+	"keywords": [
+		"typescript",
+		"camelcase",
+		"snake-case",
+		"kebab-case",
+		"pascal-case",
+		"case-conversion",
+		"deep-transform",
+		"type-safe",
+		"object-keys",
+		"naming-convention",
+		"camelcase-keys",
+		"snakecase-keys"
+	],
+	"scripts": {
+		"build": "tsup",
+		"dev": "tsup --watch",
+		"test": "vitest run",
+		"test:watch": "vitest",
+		"test:coverage": "vitest run --coverage",
+		"test:types": "vitest run --typecheck.only",
+		"lint": "biome lint .",
+		"format": "biome format --write .",
+		"format:check": "biome format .",
+		"check": "biome check .",
+		"check:fix": "biome check --fix .",
+		"typecheck": "tsc --noEmit",
+		"bench": "tsx benchmarks/bench.ts",
+		"size": "size-limit",
+		"prepublishOnly": "npm run check && npm run typecheck && npm run test && npm run build",
+		"ci": "npm run check && npm run typecheck && npm run test:coverage && npm run build && npm run size"
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/best-package/casemorph.git"
+	},
+	"size-limit": [
+		{
+			"path": "dist/index.js",
+			"limit": "2 KB"
+		}
+	],
+	"devDependencies": {
+		"@biomejs/biome": "^1",
+		"@size-limit/preset-small-lib": "^11",
+		"@vitest/coverage-v8": "^4",
+		"expect-type": "^1",
+		"size-limit": "^11",
+		"tinybench": "^3",
+		"tsup": "^8",
+		"tsx": "^4",
+		"typescript": "~5.8",
+		"vitest": "^4"
+	}
+}