caseforge 0.2.2 → 0.4.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Chikada Hiroki
+Copyright (c) 2026 Chikada Hiroki
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -2,6 +2,7 @@
 
 [![npm version](https://badge.fury.io/js/caseforge.svg)](https://www.npmjs.com/package/caseforge)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Coverage: 100%](https://img.shields.io/badge/coverage-100%25-brightgreen.svg)](https://github.com/chikadahiroki/caseforge)
 
 > Type-safe and lightweight case conversion library for TypeScript.
 
@@ -9,7 +10,8 @@
 
 - 🎯 Type-safe conversions with full TypeScript support
 - 🪶 Zero dependencies
-- 🔄 Supports camelCase, snake_case, kebab-case, and PascalCase
+- 🔄 Supports camelCase, snake_case, kebab-case, PascalCase, and UPPER_CASE
+- 🔍 Case format detection functions
 - 🌳 Deep object and array transformation
 - 📦 Works with Bun, Node.js, and browsers
 
@@ -20,7 +22,18 @@ npm install caseforge
 ```
 
 ```ts
-import { toCamelCase, toSnakeCase, toKebabCase, toPascalCase, toUpperCase } from "caseforge";
+import { 
+  toCamelCase, 
+  toSnakeCase, 
+  toKebabCase, 
+  toPascalCase, 
+  toUpperCase,
+  isCamelCase,
+  isSnakeCase,
+  isKebabCase,
+  isPascalCase,
+  isUpperCase
+} from "caseforge";
 
 // String conversion
 toCamelCase("user_name");     // => "userName"
@@ -29,6 +42,13 @@ toKebabCase("userName");       // => "user-name"
 toPascalCase("user_name");     // => "UserName"
 toUpperCase("userName");       // => "USER_NAME"
 
+// Case format detection
+isCamelCase("userName");       // => true
+isSnakeCase("user_name");      // => true
+isKebabCase("user-name");      // => true
+isPascalCase("UserName");      // => true
+isUpperCase("USER_NAME");      // => true
+
 // Object conversion with type inference
 const apiResponse = {
   user_id: 123,
@@ -41,10 +61,34 @@ const apiResponse = {
 const result = toCamelCase(apiResponse);
 // result.userId (typed!)
 // result.userName (typed!)
-// result.userSettings.notificationEnabled (typed!)## API
+// result.userSettings.notificationEnabled (typed!)
 
+// Detect API response format and convert accordingly
+const sampleKey = Object.keys(apiResponse)[0];
+if (isSnakeCase(sampleKey)) {
+  const converted = toCamelCase(apiResponse);
+  // Use converted data
+}
 ```
 
+## API
+
+### Conversion Functions
+
+- `toCamelCase(input)` - Converts to camelCase
+- `toSnakeCase(input)` - Converts to snake_case
+- `toKebabCase(input)` - Converts to kebab-case
+- `toPascalCase(input)` - Converts to PascalCase
+- `toUpperCase(input)` - Converts to UPPER_SNAKE_CASE
+
+### Detection Functions
+
+- `isCamelCase(value)` - Checks if a string is in camelCase format
+- `isSnakeCase(value)` - Checks if a string is in snake_case format
+- `isKebabCase(value)` - Checks if a string is in kebab-case format
+- `isPascalCase(value)` - Checks if a string is in PascalCase format
+- `isUpperCase(value)` - Checks if a string is in UPPER_SNAKE_CASE format
+
 ## License
 
 MIT © Chikada Hiroki

package/dist/core/toCamelCase.d.ts

@@ -2,12 +2,12 @@
  * Converts a string to camelCase format at the type level.
  * @example "user_name" -> "userName"
  */
-type CamelCase<S extends string> = S extends `${infer A}_${infer B}` ? `${Lowercase<A>}${Capitalize<CamelCase<B>>}` : S extends `${infer A}-${infer B}` ? `${Lowercase<A>}${Capitalize<CamelCase<B>>}` : Uncapitalize<S>;
+export type CamelCase<S extends string> = S extends `${infer A}_${infer B}` ? `${Lowercase<A>}${Capitalize<CamelCase<B>>}` : S extends `${infer A}-${infer B}` ? `${Lowercase<A>}${Capitalize<CamelCase<B>>}` : Uncapitalize<S>;
 /**
  * Converts all object keys to camelCase format at the type level.
  * @example { user_name: "John Doe" } -> { userName: "John Doe" }
  */
-type CamelCaseKeys<T> = {
+export type CamelCaseKeys<T> = {
     [K in keyof T as CamelCase<K & string>]: T[K] extends readonly (infer U)[] ? U extends object ? readonly CamelCaseKeys<U>[] : T[K] : T[K] extends object ? CamelCaseKeys<T[K]> : T[K];
 };
 /**
@@ -17,4 +17,3 @@ type CamelCaseKeys<T> = {
  */
 export declare function toCamelCase<T extends string>(input: T): CamelCase<T>;
 export declare function toCamelCase<T extends object>(input: T): CamelCaseKeys<T>;
-export {};

package/dist/core/toKebabCase.d.ts

@@ -2,12 +2,12 @@
  * Converts a string to kebab-case format at the type level.
  * @example "userName" -> "user-name"
  */
-type KebabCase<S extends string, First extends boolean = true> = S extends `${infer C}${infer R}` ? C extends "_" ? `-${KebabCase<R, false>}` : C extends Uppercase<C> ? First extends true ? `${Lowercase<C>}${KebabCase<R, false>}` : `-${Lowercase<C>}${KebabCase<R, false>}` : `${C}${KebabCase<R, false>}` : S;
+export type KebabCase<S extends string, First extends boolean = true> = S extends `${infer C}${infer R}` ? C extends "_" ? `-${KebabCase<R, false>}` : C extends Uppercase<C> ? First extends true ? `${Lowercase<C>}${KebabCase<R, false>}` : `-${Lowercase<C>}${KebabCase<R, false>}` : `${C}${KebabCase<R, false>}` : S;
 /**
  * Converts all object keys to kebab-case format at the type level.
  * @example { userName: "John Doe" } -> { "user-name": "John Doe" }
  */
-type KebabCaseKeys<T> = {
+export type KebabCaseKeys<T> = {
     [K in keyof T as KebabCase<K & string>]: T[K] extends readonly (infer U)[] ? U extends object ? readonly KebabCaseKeys<U>[] : T[K] : T[K] extends object ? KebabCaseKeys<T[K]> : T[K];
 };
 /**
@@ -17,4 +17,3 @@ type KebabCaseKeys<T> = {
  */
 export declare function toKebabCase<T extends string>(input: T): KebabCase<T>;
 export declare function toKebabCase<T extends object>(input: T): KebabCaseKeys<T>;
-export {};

package/dist/core/toPascalCase.d.ts

@@ -2,12 +2,12 @@
  * Converts a string to PascalCase format at the type level.
  * @example "user_name" -> "UserName"
  */
-type PascalCase<S extends string> = S extends `${infer Head}_${infer Tail}` ? `${Capitalize<Lowercase<Head>>}${PascalCase<Tail>}` : S extends `${infer Head}-${infer Tail}` ? `${Capitalize<Lowercase<Head>>}${PascalCase<Tail>}` : S extends `${infer First}${infer Rest}` ? `${Capitalize<First>}${Rest}` : S;
+export type PascalCase<S extends string> = S extends `${infer Head}_${infer Tail}` ? `${Capitalize<Lowercase<Head>>}${PascalCase<Tail>}` : S extends `${infer Head}-${infer Tail}` ? `${Capitalize<Lowercase<Head>>}${PascalCase<Tail>}` : S extends `${infer First}${infer Rest}` ? `${Capitalize<First>}${Rest}` : S;
 /**
  * Converts all object keys to PascalCase format at the type level.
  * @example { user_name: "John Doe" } -> { UserName: "John Doe" }
  */
-type PascalCaseKeys<T> = {
+export type PascalCaseKeys<T> = {
     [K in keyof T as PascalCase<K & string>]: T[K] extends readonly (infer U)[] ? U extends object ? readonly PascalCaseKeys<U>[] : T[K] : T[K] extends object ? PascalCaseKeys<T[K]> : T[K];
 };
 /**
@@ -17,4 +17,3 @@ type PascalCaseKeys<T> = {
  */
 export declare function toPascalCase<T extends string>(input: T): PascalCase<T>;
 export declare function toPascalCase<T extends object>(input: T): PascalCaseKeys<T>;
-export {};

package/dist/core/toSnakeCase.d.ts

@@ -2,12 +2,12 @@
  * Converts a string to snake_case format at the type level.
  * @example "userName" -> "user_name"
  */
-type SnakeCase<S extends string, First extends boolean = true> = S extends `${infer C}${infer R}` ? C extends "_" | "-" ? `_${SnakeCase<R, false>}` : C extends Uppercase<C> ? First extends true ? `${Lowercase<C>}${SnakeCase<R, false>}` : `_${Lowercase<C>}${SnakeCase<R, false>}` : `${C}${SnakeCase<R, false>}` : S;
+export type SnakeCase<S extends string, First extends boolean = true> = S extends `${infer C}${infer R}` ? C extends "_" | "-" ? `_${SnakeCase<R, false>}` : C extends Uppercase<C> ? First extends true ? `${Lowercase<C>}${SnakeCase<R, false>}` : `_${Lowercase<C>}${SnakeCase<R, false>}` : `${C}${SnakeCase<R, false>}` : S;
 /**
  * Converts all object keys to snake_case format at the type level.
  * @example { userName: "John Doe" } -> { user_name: "John Doe" }
  */
-type SnakeCaseKeys<T> = {
+export type SnakeCaseKeys<T> = {
     [K in keyof T as SnakeCase<K & string>]: T[K] extends readonly (infer U)[] ? U extends object ? readonly SnakeCaseKeys<U>[] : T[K] : T[K] extends object ? SnakeCaseKeys<T[K]> : T[K];
 };
 /**
@@ -17,4 +17,3 @@ type SnakeCaseKeys<T> = {
  */
 export declare function toSnakeCase<T extends string>(input: T): SnakeCase<T>;
 export declare function toSnakeCase<T extends object>(input: T): SnakeCaseKeys<T>;
-export {};

package/dist/core/toUpperCase.d.ts

@@ -2,12 +2,12 @@
  * Converts a string to UPPER_SNAKE_CASE format at the type level.
  * @example "userName" -> "USER_NAME"
  */
-type UpperCase<S extends string, First extends boolean = true> = S extends `${infer C}${infer R}` ? C extends "_" | "-" ? `_${UpperCase<R, false>}` : C extends Uppercase<C> ? First extends true ? `${Uppercase<C>}${UpperCase<R, false>}` : `_${Uppercase<C>}${UpperCase<R, false>}` : `${Uppercase<C>}${UpperCase<R, false>}` : Uppercase<S>;
+export type UpperCase<S extends string, First extends boolean = true> = S extends `${infer C}${infer R}` ? C extends "_" | "-" ? `_${UpperCase<R, false>}` : C extends Uppercase<C> ? First extends true ? `${Uppercase<C>}${UpperCase<R, false>}` : `_${Uppercase<C>}${UpperCase<R, false>}` : `${Uppercase<C>}${UpperCase<R, false>}` : Uppercase<S>;
 /**
  * Converts all object keys to UPPER_SNAKE_CASE format at the type level.
  * @example { userName: "John Doe" } -> { USER_NAME: "John Doe" }
  */
-type UpperCaseKeys<T> = {
+export type UpperCaseKeys<T> = {
     [K in keyof T as UpperCase<K & string>]: T[K] extends readonly (infer U)[] ? U extends object ? readonly UpperCaseKeys<U>[] : T[K] : T[K] extends object ? UpperCaseKeys<T[K]> : T[K];
 };
 /**
@@ -17,4 +17,3 @@ type UpperCaseKeys<T> = {
  */
 export declare function toUpperCase<T extends string>(input: T): UpperCase<T>;
 export declare function toUpperCase<T extends object>(input: T): UpperCaseKeys<T>;
-export {};

package/dist/index.d.ts

@@ -1,5 +1,6 @@
-export { toCamelCase } from "./core/toCamelCase";
-export { toKebabCase } from "./core/toKebabCase";
-export { toPascalCase } from "./core/toPascalCase";
-export { toSnakeCase } from "./core/toSnakeCase";
-export { toUpperCase } from "./core/toUpperCase";
+export { type CamelCase, type CamelCaseKeys, toCamelCase, } from "./core/toCamelCase";
+export { type KebabCase, type KebabCaseKeys, toKebabCase, } from "./core/toKebabCase";
+export { type PascalCase, type PascalCaseKeys, toPascalCase, } from "./core/toPascalCase";
+export { type SnakeCase, type SnakeCaseKeys, toSnakeCase, } from "./core/toSnakeCase";
+export { toUpperCase, type UpperCase, type UpperCaseKeys, } from "./core/toUpperCase";
+export { isCamelCase, isKebabCase, isPascalCase, isSnakeCase, isUpperCase, } from "./utils/caseGuards";

package/dist/index.js

@@ -1 +1 @@
-var q={LEADING_UPPER:/^[A-Z]/,UPPERCASE:/[A-Z]/g,LEADING_LOWER:/^[a-z]/,SEPARATOR_WITH_CHAR:/[_-]+(.)/g,EDGE_SEPARATORS:/^[_-]+|[_-]+$/g,CONSECUTIVE_SEPARATORS:/[_-]+/g};function J(x){return typeof x==="string"}function X(x){return Array.isArray(x)}function D(x){return typeof x==="object"&&x!==null&&!X(x)}function Y(x){return x instanceof Date||x instanceof RegExp||typeof x==="function"}function H(x,z){let L={};for(let[M,Q]of Object.entries(x)){let V=z(M);if(Y(Q))L[V]=Q;else if(X(Q))L[V]=Q.map((W)=>D(W)&&!X(W)?H(W,z):W);else if(D(Q))L[V]=H(Q,z);else L[V]=Q}return L}function Z(x){return x.replace(q.LEADING_UPPER,(z)=>z.toLowerCase()).replace(q.SEPARATOR_WITH_CHAR,(z,L)=>L.toUpperCase()).replace(q.EDGE_SEPARATORS,"")}function U(x){if(J(x))return Z(x);if(D(x))return H(x,Z);return x}function $(x){return x.replace(q.UPPERCASE,(z)=>`-${z.toLowerCase()}`).replace(q.CONSECUTIVE_SEPARATORS,"-").replace(q.EDGE_SEPARATORS,"")}function w(x){if(J(x))return $(x);if(D(x))return H(x,$);return x}function B(x){return x.replace(q.SEPARATOR_WITH_CHAR,(z,L)=>L.toUpperCase()).replace(q.EDGE_SEPARATORS,"").replace(q.LEADING_LOWER,(z)=>z.toUpperCase())}function _(x){if(J(x))return B(x);if(D(x))return H(x,B);return x}function F(x){return x.replace(q.UPPERCASE,(z)=>`_${z.toLowerCase()}`).replace(q.CONSECUTIVE_SEPARATORS,"_").replace(q.EDGE_SEPARATORS,"")}function d(x){if(J(x))return F(x);if(D(x))return H(x,F);return x}function I(x){return x.replace(q.UPPERCASE,(z)=>`_${z.toLowerCase()}`).replace(q.CONSECUTIVE_SEPARATORS,"_").replace(q.EDGE_SEPARATORS,"").toUpperCase()}function G(x){if(J(x))return I(x);if(D(x))return H(x,I);return x}export{G as toUpperCase,d as toSnakeCase,_ as toPascalCase,w as toKebabCase,U as toCamelCase};
+var q={LEADING_UPPER:/^[A-Z]/,UPPERCASE:/[A-Z]/g,LEADING_LOWER:/^[a-z]/,SEPARATOR_WITH_CHAR:/[_-]+(.)/g,EDGE_SEPARATORS:/^[_-]+|[_-]+$/g,CONSECUTIVE_SEPARATORS:/[_-]+/g,CAMEL_CASE:/^[a-z][a-zA-Z0-9]*$/,KEBAB_CASE:/^[a-z][a-z0-9-]*$/,PASCAL_CASE:/^[A-Z][a-zA-Z0-9]*$/,SNAKE_CASE:/^[a-z][a-z0-9_]*$/,UPPER_SNAKE_CASE:/^[A-Z][A-Z0-9_]*$/};function z(x){return typeof x==="string"}function X(x){return Array.isArray(x)}function H(x){return typeof x==="object"&&x!==null&&!X(x)}function Y(x){return x instanceof Date||x instanceof RegExp||typeof x==="function"}function J(x,D){let L={};for(let[M,Q]of Object.entries(x)){let V=D(M);if(Y(Q))L[V]=Q;else if(X(Q))L[V]=Q.map((W)=>H(W)&&!X(W)?J(W,D):W);else if(H(Q))L[V]=J(Q,D);else L[V]=Q}return L}function Z(x){return x.replace(q.LEADING_UPPER,(D)=>D.toLowerCase()).replace(q.SEPARATOR_WITH_CHAR,(D,L)=>L.toUpperCase()).replace(q.EDGE_SEPARATORS,"")}function U(x){if(z(x))return Z(x);if(H(x))return J(x,Z);return x}function $(x){return x.replace(q.UPPERCASE,(D)=>`-${D.toLowerCase()}`).replace(q.CONSECUTIVE_SEPARATORS,"-").replace(q.EDGE_SEPARATORS,"")}function C(x){if(z(x))return $(x);if(H(x))return J(x,$);return x}function B(x){return x.replace(q.SEPARATOR_WITH_CHAR,(D,L)=>L.toUpperCase()).replace(q.EDGE_SEPARATORS,"").replace(q.LEADING_LOWER,(D)=>D.toUpperCase())}function w(x){if(z(x))return B(x);if(H(x))return J(x,B);return x}function F(x){return x.replace(q.UPPERCASE,(D)=>`_${D.toLowerCase()}`).replace(q.CONSECUTIVE_SEPARATORS,"_").replace(q.EDGE_SEPARATORS,"")}function K(x){if(z(x))return F(x);if(H(x))return J(x,F);return x}function I(x){return x.replace(q.UPPERCASE,(D)=>`_${D.toLowerCase()}`).replace(q.CONSECUTIVE_SEPARATORS,"_").replace(q.EDGE_SEPARATORS,"").toUpperCase()}function d(x){if(z(x))return I(x);if(H(x))return J(x,I);return x}function G(x){if(!z(x))return!1;return q.CAMEL_CASE.test(x)&&!x.includes("_")&&!x.includes("-")}function _(x){if(!z(x))return!1;return q.SNAKE_CASE.test(x)&&!x.includes("-")&&!q.UPPERCASE.test(x)}function y(x){if(!z(x))return!1;return q.KEBAB_CASE.test(x)&&!x.includes("_")&&!q.UPPERCASE.test(x)}function O(x){if(!z(x))return!1;return q.PASCAL_CASE.test(x)&&!x.includes("_")&&!x.includes("-")}function k(x){if(!z(x))return!1;return q.UPPER_SNAKE_CASE.test(x)&&!x.includes("-")}export{d as toUpperCase,K as toSnakeCase,w as toPascalCase,C as toKebabCase,U as toCamelCase,k as isUpperCase,_ as isSnakeCase,O as isPascalCase,y as isKebabCase,G as isCamelCase};

package/dist/utils/caseGuards.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Checks if a string is in camelCase format.
+ * @param value - The value to check.
+ * @returns `true` if the value is in camelCase format, `false` otherwise.
+ */
+export declare function isCamelCase(value: unknown): boolean;
+/**
+ * Checks if a string is in snake_case format.
+ * @param value - The value to check.
+ * @returns `true` if the value is in snake_case format, `false` otherwise.
+ */
+export declare function isSnakeCase(value: unknown): boolean;
+/**
+ * Checks if a string is in kebab-case format.
+ * @param value - The value to check.
+ * @returns `true` if the value is in kebab-case format, `false` otherwise.
+ */
+export declare function isKebabCase(value: unknown): boolean;
+/**
+ * Checks if a string is in PascalCase format.
+ * @param value - The value to check.
+ * @returns `true` if the value is in PascalCase format, `false` otherwise.
+ */
+export declare function isPascalCase(value: unknown): boolean;
+/**
+ * Checks if a string is in UPPER_SNAKE_CASE format.
+ * @param value - The value to check.
+ * @returns `true` if the value is in UPPER_SNAKE_CASE format, `false` otherwise.
+ */
+export declare function isUpperCase(value: unknown): boolean;

package/dist/utils/patterns.d.ts

@@ -14,4 +14,14 @@ export declare const PATTERNS: {
     readonly EDGE_SEPARATORS: RegExp;
     /** Matches consecutive separators */
     readonly CONSECUTIVE_SEPARATORS: RegExp;
+    /** Matches a complete camelCase string */
+    readonly CAMEL_CASE: RegExp;
+    /** Matches a complete kebab-case string */
+    readonly KEBAB_CASE: RegExp;
+    /** Matches a complete PascalCase string */
+    readonly PASCAL_CASE: RegExp;
+    /** Matches a complete snake_case string */
+    readonly SNAKE_CASE: RegExp;
+    /** Matches a complete UPPER_SNAKE_CASE string */
+    readonly UPPER_SNAKE_CASE: RegExp;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "caseforge",
-  "version": "0.2.2",
+  "version": "0.4.0",
   "description": "caseforge - Effortlessly convert between snake_case, camelCase, and more in TypeScript. Zero dependencies, type-safe, and easy to use for any project.",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",