caseforge 0.1.6 → 0.2.1

package/README.md

@@ -20,13 +20,14 @@ npm install caseforge
 ```
 
 ```ts
-import { toCamelCase, toSnakeCase, toKebabCase, toPascalCase } from "caseforge";
+import { toCamelCase, toSnakeCase, toKebabCase, toPascalCase, toUpperCase } from "caseforge";
 
 // String conversion
 toCamelCase("user_name");     // => "userName"
 toSnakeCase("userName");       // => "user_name"
 toKebabCase("userName");       // => "user-name"
 toPascalCase("user_name");     // => "UserName"
+toUpperCase("userName");       // => "USER_NAME"
 
 // Object conversion with type inference
 const apiResponse = {

package/dist/core/toCamelCase.d.ts

@@ -7,8 +7,8 @@ type CamelCase<S extends string> = S extends `${infer A}_${infer B}` ? `${Lowerc
  * Converts all object keys to camelCase format at the type level.
  * @example { user_name: "John Doe" } -> { userName: "John Doe" }
  */
-type CamelCaseKeys<T> = {
-    [K in keyof T as CamelCase<K & string>]: T[K] extends Array<infer U> ? U extends Record<string, unknown> ? Array<CamelCaseKeys<U>> : T[K] : T[K] extends Record<string, unknown> ? CamelCaseKeys<T[K]> : T[K];
+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];
 };
 /**
  * Converts strings or object keys to camelCase format.
@@ -16,6 +16,5 @@ type CamelCaseKeys<T> = {
  * @returns The camelCase string or object.
  */
 export declare function toCamelCase<T extends string>(input: T): CamelCase<T>;
-export declare function toCamelCase<T extends Record<string, unknown>>(input: T): CamelCaseKeys<T>;
-export declare function toCamelCase<T>(input: T): T;
+export declare function toCamelCase<T extends object>(input: T): CamelCaseKeys<T>;
 export {};

package/dist/core/toKebabCase.d.ts

@@ -7,8 +7,8 @@ type KebabCase<S extends string, First extends boolean = true> = S extends `${in
  * Converts all object keys to kebab-case format at the type level.
  * @example { userName: "John Doe" } -> { "user-name": "John Doe" }
  */
-type KebabCaseKeys<T> = {
-    [K in keyof T as KebabCase<K & string>]: T[K] extends Array<infer U> ? U extends Record<string, unknown> ? Array<KebabCaseKeys<U>> : T[K] : T[K] extends Record<string, unknown> ? KebabCaseKeys<T[K]> : T[K];
+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];
 };
 /**
  * Converts strings or object keys to kebab-case format.
@@ -16,6 +16,5 @@ type KebabCaseKeys<T> = {
  * @returns The kebab-case string or object.
  */
 export declare function toKebabCase<T extends string>(input: T): KebabCase<T>;
-export declare function toKebabCase<T extends Record<string, unknown>>(input: T): KebabCaseKeys<T>;
-export declare function toKebabCase<T>(input: T): T;
+export declare function toKebabCase<T extends object>(input: T): KebabCaseKeys<T>;
 export {};

package/dist/core/toPascalCase.d.ts

@@ -8,7 +8,7 @@ type PascalCase<S extends string> = S extends `${infer Head}_${infer Tail}` ? `$
  * @example { user_name: "John Doe" } -> { UserName: "John Doe" }
  */
 type PascalCaseKeys<T> = {
-    [K in keyof T as PascalCase<K & string>]: T[K] extends Array<infer U> ? U extends Record<string, unknown> ? Array<PascalCaseKeys<U>> : T[K] : T[K] extends Record<string, unknown> ? PascalCaseKeys<T[K]> : T[K];
+    [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];
 };
 /**
  * Converts strings or object keys to PascalCase format.
@@ -16,6 +16,5 @@ type PascalCaseKeys<T> = {
  * @returns The PascalCase string or object.
  */
 export declare function toPascalCase<T extends string>(input: T): PascalCase<T>;
-export declare function toPascalCase<T extends Record<string, unknown>>(input: T): PascalCaseKeys<T>;
-export declare function toPascalCase<T>(input: T): T;
+export declare function toPascalCase<T extends object>(input: T): PascalCaseKeys<T>;
 export {};

package/dist/core/toSnakeCase.d.ts

@@ -8,7 +8,7 @@ type SnakeCase<S extends string, First extends boolean = true> = S extends `${in
  * @example { userName: "John Doe" } -> { user_name: "John Doe" }
  */
 type SnakeCaseKeys<T> = {
-    [K in keyof T as SnakeCase<K & string>]: T[K] extends Array<infer U> ? U extends Record<string, unknown> ? Array<SnakeCaseKeys<U>> : T[K] : T[K] extends Record<string, unknown> ? SnakeCaseKeys<T[K]> : T[K];
+    [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];
 };
 /**
  * Converts strings or object keys to snake_case format.
@@ -16,6 +16,5 @@ type SnakeCaseKeys<T> = {
  * @returns The snake_case string or object.
  */
 export declare function toSnakeCase<T extends string>(input: T): SnakeCase<T>;
-export declare function toSnakeCase<T extends Record<string, unknown>>(input: T): SnakeCaseKeys<T>;
-export declare function toSnakeCase<T>(input: T): T;
+export declare function toSnakeCase<T extends object>(input: T): SnakeCaseKeys<T>;
 export {};

package/dist/core/toUpperCase.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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>;
+/**
+ * Converts all object keys to UPPER_SNAKE_CASE format at the type level.
+ * @example { userName: "John Doe" } -> { USER_NAME: "John Doe" }
+ */
+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];
+};
+/**
+ * Converts strings or object keys to UPPER_SNAKE_CASE format.
+ * @param input - A string or object to convert.
+ * @returns The UPPER_SNAKE_CASE string or object.
+ */
+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

@@ -2,3 +2,4 @@ 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";

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 L(x){return typeof x==="string"}function W(x){return Array.isArray(x)}function D(x){return typeof x==="object"&&x!==null&&!W(x)}function X(x){return x instanceof Date||x instanceof RegExp||typeof x==="function"}function H(x,z){let J={};for(let[F,Q]of Object.entries(x)){let U=z(F);if(X(Q))J[U]=Q;else if(W(Q))J[U]=Q.map((V)=>D(V)&&!W(V)?H(V,z):V);else if(D(Q))J[U]=H(Q,z);else J[U]=Q}return J}function Y(x){return x.replace(q.LEADING_UPPER,(z)=>z.toLowerCase()).replace(q.SEPARATOR_WITH_CHAR,(z,J)=>J.toUpperCase()).replace(q.EDGE_SEPARATORS,"")}function I(x){if(L(x))return Y(x);if(D(x))return H(x,Y);return x}function Z(x){return x.replace(q.UPPERCASE,(z)=>`-${z.toLowerCase()}`).replace(q.CONSECUTIVE_SEPARATORS,"-").replace(q.EDGE_SEPARATORS,"")}function M(x){if(L(x))return Z(x);if(D(x))return H(x,Z);return x}function $(x){return x.replace(q.SEPARATOR_WITH_CHAR,(z,J)=>J.toUpperCase()).replace(q.EDGE_SEPARATORS,"").replace(q.LEADING_LOWER,(z)=>z.toUpperCase())}function _(x){if(L(x))return $(x);if(D(x))return H(x,$);return x}function B(x){return x.replace(q.UPPERCASE,(z)=>`_${z.toLowerCase()}`).replace(q.CONSECUTIVE_SEPARATORS,"_").replace(q.EDGE_SEPARATORS,"")}function w(x){if(L(x))return B(x);if(D(x))return H(x,B);return x}export{w as toSnakeCase,_ as toPascalCase,M as toKebabCase,I 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};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};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "caseforge",
-  "version": "0.1.6",
+  "version": "0.2.1",
   "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",