deep-case-crafter 1.0.0 → 2.0.0

package/dist/index.d.ts

@@ -1,5 +1,231 @@
-import transform from './transform/transform';
-import { StringCase } from './types/stringCaseTypes';
-import { TransformOptions } from './types/transformOptionTypes';
-export default transform;
+/**
+ * Represents the supported string case formats for transformation
+ */
+type StringCase = 'camel' | 'pascal' | 'snake' | 'kebab';
+
+/**
+ * Options for the transform function
+ */
+interface TransformOptions {
+    /**
+     * The target casing format to transform to
+     * @default 'camel'
+     */
+    targetCase?: StringCase;
+    /**
+     * The source casing format to transform from
+     *
+     * When specified:
+     * - Provides precise TypeScript type transformations
+     * - Bypasses runtime case detection (more efficient)
+     * - Ensures consistent results if input has mixed casing
+     *
+     * When omitted:
+     * - Automatic case detection is used at runtime
+     * - TypeScript types will be less precise (string keys)
+     * - Works with mixed case inputs (each key detected separately)
+     *
+     * @example
+     * // With source specified - precise types
+     * const result = transform(data, { targetCase: 'camel', sourceCase: 'snake' });
+     * // result has exact transformed types
+     *
+     * // Without source - flexible runtime behavior
+     * const result = transform(data, { targetCase: 'camel' });
+     * // TypeScript types are more general
+     *
+     * @default undefined (automatic detection)
+     */
+    sourceCase?: StringCase;
+}
+
+/**
+ * Type utility that transforms a snake_case string to camelCase
+ * Example: 'hello_world' -> 'helloWorld'
+ */
+type SnakeToCamel<S extends string> = S extends `${infer P}_${infer C}${infer R}` ? `${P}${Uppercase<C>}${SnakeToCamel<R>}` : S;
+/**
+ * Type utility that transforms a snake_case string to PascalCase
+ * Example: 'hello_world' -> 'HelloWorld'
+ */
+type SnakeWordsToPascal<Parts extends string[]> = Parts extends [
+    infer First extends string,
+    ...infer Rest extends string[]
+] ? `${Capitalize<First>}${SnakeWordsToPascal<Rest>}` : '';
+type SnakeToWords<S extends string> = S extends `${infer P}_${infer R}` ? [P, ...SnakeToWords<R>] : [S];
+type SnakeToPascal<S extends string> = S extends `${infer P}_${infer R}` ? SnakeWordsToPascal<[P, ...SnakeToWords<R>]> : Capitalize<S>;
+/**
+ * Type utility that transforms a snake_case string to kebab-case
+ * Example: 'hello_world' -> 'hello-world'
+ */
+type SnakeToKebab<S extends string> = S extends `${infer P}_${infer R}` ? `${P}-${SnakeToKebab<R>}` : S;
+/**
+ * Type utility that transforms a camelCase string to snake_case
+ * Example: 'helloWorld' -> 'hello_world'
+ */
+type CamelToSnake<S extends string> = S extends `${infer C}${infer R}` ? C extends Uppercase<C> ? `_${Lowercase<C>}${CamelToSnake<R>}` : `${C}${CamelToSnake<R>}` : S;
+/**
+ * Type utility that transforms a camelCase string to PascalCase
+ * Example: 'helloWorld' -> 'HelloWorld'
+ */
+type CamelToPascal<S extends string> = Capitalize<S>;
+/**
+ * Type utility that transforms a camelCase string to kebab-case
+ * Example: 'helloWorld' -> 'hello-world'
+ */
+type CamelToKebab<S extends string> = S extends `${infer C}${infer R}` ? C extends Uppercase<C> ? `-${Lowercase<C>}${CamelToKebab<R>}` : `${C}${CamelToKebab<R>}` : S;
+/**
+ * Type utility that transforms a PascalCase string to camelCase
+ * Example: 'HelloWorld' -> 'helloWorld'
+ */
+type PascalToCamel<S extends string> = S extends `${infer F}${infer R}` ? `${Lowercase<F>}${R}` : S;
+/**
+ * Type utility that transforms a PascalCase string to snake_case
+ * Example: 'HelloWorld' -> 'hello_world'
+ */
+type PascalToSnake<S extends string> = S extends `${infer F}${infer R}` ? R extends `` ? Lowercase<F> : `${Lowercase<F>}${PascalToSnakeInner<R>}` : S;
+type PascalToSnakeInner<S extends string> = S extends `${infer C}${infer R}` ? C extends Uppercase<C> ? `_${Lowercase<C>}${PascalToSnakeInner<R>}` : `${C}${PascalToSnakeInner<R>}` : S;
+/**
+ * Type utility that transforms a PascalCase string to kebab-case
+ * Example: 'HelloWorld' -> 'hello-world'
+ */
+type PascalToKebab<S extends string> = S extends `${infer F}${infer R}` ? R extends `` ? Lowercase<F> : `${Lowercase<F>}${PascalToKebabInner<R>}` : S;
+type PascalToKebabInner<S extends string> = S extends `${infer C}${infer R}` ? C extends Uppercase<C> ? `-${Lowercase<C>}${PascalToKebabInner<R>}` : `${C}${PascalToKebabInner<R>}` : S;
+/**
+ * Type utility that transforms a kebab-case string to camelCase
+ * Example: 'hello-world' -> 'helloWorld'
+ */
+type KebabToCamel<S extends string> = S extends `${infer P}-${infer C}${infer R}` ? `${P}${Uppercase<C>}${KebabToCamel<R>}` : S;
+/**
+ * Type utility that transforms a kebab-case string to PascalCase
+ * Example: 'hello-world' -> 'HelloWorld'
+ */
+type KebabWordsToPascal<Parts extends string[]> = Parts extends [
+    infer First extends string,
+    ...infer Rest extends string[]
+] ? `${Capitalize<First>}${KebabWordsToPascal<Rest>}` : '';
+type KebabToWords<S extends string> = S extends `${infer P}-${infer R}` ? [P, ...KebabToWords<R>] : [S];
+/**
+ * Type utility that transforms a kebab-case string to PascalCase
+ * Example: 'hello-world' -> 'HelloWorld'
+ */
+type KebabToPascal<S extends string> = S extends `${infer P}-${infer R}` ? KebabWordsToPascal<[P, ...KebabToWords<R>]> : Capitalize<S>;
+/**
+ * Type utility that transforms a kebab-case string to snake_case
+ * Example: 'hello-world' -> 'hello_world'
+ */
+type KebabToSnake<S extends string> = S extends `${infer P}-${infer R}` ? `${P}_${KebabToSnake<R>}` : S;
+/**
+ * Utility type to detect preserved keys that shouldn't be transformed.
+ * Preserved keys include those with leading/trailing special characters,
+ * unsupported patterns, or invalid starting/ending characters.
+ */
+type ForbiddenStartChars = '_' | '-' | '$' | '&' | '%' | '#' | '@' | '!' | '*' | '+' | '=' | '~' | '`' | '^' | '(' | ')' | '[' | ']' | '{' | '}' | '|' | '\\' | ':' | ';' | '"' | "'" | '<' | '>' | ',' | '.' | '?' | '/';
+type ForbiddenEndChars = '_' | '-' | '$' | '&' | '%' | '#' | '@' | '!' | '*' | '+' | '=' | '~' | '`' | '^' | '(' | ')' | '[' | ']' | '{' | '}' | '|' | '\\' | ':' | ';' | '"' | "'" | '<' | '>' | ',' | '.' | '?' | '/' | `${number}`;
+type PreservedKey<K extends string> = K extends `${infer First}${string}` ? First extends ForbiddenStartChars ? true : K extends `${string}${infer Last}` ? Last extends ForbiddenEndChars ? true : K extends `${string}__${string}` | `${string}--${string}` ? true : false : false : false;
+/**
+ * Type utility that selects the correct string transformation based on source and target casing
+ */
+type TransformKey<K extends string, O extends TransformOptions> = PreservedKey<K> extends true ? K : undefined extends O['sourceCase'] ? string : O['sourceCase'] extends 'snake' ? undefined extends O['targetCase'] ? SnakeToCamel<K> : O['targetCase'] extends 'camel' ? SnakeToCamel<K> : O['targetCase'] extends 'pascal' ? SnakeToPascal<K> : O['targetCase'] extends 'kebab' ? SnakeToKebab<K> : K : O['sourceCase'] extends 'camel' ? undefined extends O['targetCase'] ? K : O['targetCase'] extends 'snake' ? CamelToSnake<K> : O['targetCase'] extends 'pascal' ? CamelToPascal<K> : O['targetCase'] extends 'kebab' ? CamelToKebab<K> : K : O['sourceCase'] extends 'pascal' ? undefined extends O['targetCase'] ? PascalToCamel<K> : O['targetCase'] extends 'camel' ? PascalToCamel<K> : O['targetCase'] extends 'snake' ? PascalToSnake<K> : O['targetCase'] extends 'kebab' ? PascalToKebab<K> : K : O['sourceCase'] extends 'kebab' ? undefined extends O['targetCase'] ? KebabToCamel<K> : O['targetCase'] extends 'camel' ? KebabToCamel<K> : O['targetCase'] extends 'pascal' ? KebabToPascal<K> : O['targetCase'] extends 'snake' ? KebabToSnake<K> : K : K;
+/**
+ * Recursive type transformations
+ * These types handle nested structures like arrays, objects, Maps, and Sets
+ */
+type SnakeToCamelRecursive<T> = T extends Array<infer U> ? Array<SnakeToCamelRecursive<U>> : T extends Map<infer K, infer V> ? Map<K extends string ? SnakeToCamel<K> : K, SnakeToCamelRecursive<V>> : T extends Set<infer V> ? Set<SnakeToCamelRecursive<V>> : T extends object ? {
+    [K in keyof T as TransformKey<K & string, {
+        sourceCase: 'snake';
+        targetCase: 'camel';
+    }>]: SnakeToCamelRecursive<T[K]>;
+} : T;
+type SnakeToPascalRecursive<T> = T extends Array<infer U> ? Array<SnakeToPascalRecursive<U>> : T extends Map<infer K, infer V> ? Map<K extends string ? SnakeToPascal<K> : K, SnakeToPascalRecursive<V>> : T extends Set<infer V> ? Set<SnakeToPascalRecursive<V>> : T extends object ? {
+    [K in keyof T as TransformKey<K & string, {
+        sourceCase: 'snake';
+        targetCase: 'pascal';
+    }>]: SnakeToPascalRecursive<T[K]>;
+} : T;
+type SnakeToKebabRecursive<T> = T extends Array<infer U> ? Array<SnakeToKebabRecursive<U>> : T extends Map<infer K, infer V> ? Map<K extends string ? SnakeToKebab<K> : K, SnakeToKebabRecursive<V>> : T extends Set<infer V> ? Set<SnakeToKebabRecursive<V>> : T extends object ? {
+    [K in keyof T as TransformKey<K & string, {
+        sourceCase: 'snake';
+        targetCase: 'kebab';
+    }>]: SnakeToKebabRecursive<T[K]>;
+} : T;
+type CamelToSnakeRecursive<T> = T extends Array<infer U> ? Array<CamelToSnakeRecursive<U>> : T extends Map<infer K, infer V> ? Map<K extends string ? CamelToSnake<K> : K, CamelToSnakeRecursive<V>> : T extends Set<infer V> ? Set<CamelToSnakeRecursive<V>> : T extends object ? {
+    [K in keyof T as TransformKey<K & string, {
+        sourceCase: 'camel';
+        targetCase: 'snake';
+    }>]: CamelToSnakeRecursive<T[K]>;
+} : T;
+type CamelToPascalRecursive<T> = T extends Array<infer U> ? Array<CamelToPascalRecursive<U>> : T extends Map<infer K, infer V> ? Map<K extends string ? CamelToPascal<K> : K, CamelToPascalRecursive<V>> : T extends Set<infer V> ? Set<CamelToPascalRecursive<V>> : T extends object ? {
+    [K in keyof T as TransformKey<K & string, {
+        sourceCase: 'camel';
+        targetCase: 'pascal';
+    }>]: CamelToPascalRecursive<T[K]>;
+} : T;
+type CamelToKebabRecursive<T> = T extends Array<infer U> ? Array<CamelToKebabRecursive<U>> : T extends Map<infer K, infer V> ? Map<K extends string ? CamelToKebab<K> : K, CamelToKebabRecursive<V>> : T extends Set<infer V> ? Set<CamelToKebabRecursive<V>> : T extends object ? {
+    [K in keyof T as TransformKey<K & string, {
+        sourceCase: 'camel';
+        targetCase: 'kebab';
+    }>]: CamelToKebabRecursive<T[K]>;
+} : T;
+type PascalToCamelRecursive<T> = T extends Array<infer U> ? Array<PascalToCamelRecursive<U>> : T extends Map<infer K, infer V> ? Map<K extends string ? PascalToCamel<K> : K, PascalToCamelRecursive<V>> : T extends Set<infer V> ? Set<PascalToCamelRecursive<V>> : T extends object ? {
+    [K in keyof T as TransformKey<K & string, {
+        sourceCase: 'pascal';
+        targetCase: 'camel';
+    }>]: PascalToCamelRecursive<T[K]>;
+} : T;
+type PascalToSnakeRecursive<T> = T extends Array<infer U> ? Array<PascalToSnakeRecursive<U>> : T extends Map<infer K, infer V> ? Map<K extends string ? PascalToSnake<K> : K, PascalToSnakeRecursive<V>> : T extends Set<infer V> ? Set<PascalToSnakeRecursive<V>> : T extends object ? {
+    [K in keyof T as TransformKey<K & string, {
+        sourceCase: 'pascal';
+        targetCase: 'snake';
+    }>]: PascalToSnakeRecursive<T[K]>;
+} : T;
+type PascalToKebabRecursive<T> = T extends Array<infer U> ? Array<PascalToKebabRecursive<U>> : T extends Map<infer K, infer V> ? Map<K extends string ? PascalToKebab<K> : K, PascalToKebabRecursive<V>> : T extends Set<infer V> ? Set<PascalToKebabRecursive<V>> : T extends object ? {
+    [K in keyof T as TransformKey<K & string, {
+        sourceCase: 'pascal';
+        targetCase: 'kebab';
+    }>]: PascalToKebabRecursive<T[K]>;
+} : T;
+type KebabToCamelRecursive<T> = T extends Array<infer U> ? Array<KebabToCamelRecursive<U>> : T extends Map<infer K, infer V> ? Map<K extends string ? KebabToCamel<K> : K, KebabToCamelRecursive<V>> : T extends Set<infer V> ? Set<KebabToCamelRecursive<V>> : T extends object ? {
+    [K in keyof T as TransformKey<K & string, {
+        sourceCase: 'kebab';
+        targetCase: 'camel';
+    }>]: KebabToCamelRecursive<T[K]>;
+} : T;
+type KebabToPascalRecursive<T> = T extends Array<infer U> ? Array<KebabToPascalRecursive<U>> : T extends Map<infer K, infer V> ? Map<K extends string ? KebabToPascal<K> : K, KebabToPascalRecursive<V>> : T extends Set<infer V> ? Set<KebabToPascalRecursive<V>> : T extends object ? {
+    [K in keyof T as TransformKey<K & string, {
+        sourceCase: 'kebab';
+        targetCase: 'pascal';
+    }>]: KebabToPascalRecursive<T[K]>;
+} : T;
+type KebabToSnakeRecursive<T> = T extends Array<infer U> ? Array<KebabToSnakeRecursive<U>> : T extends Map<infer K, infer V> ? Map<K extends string ? KebabToSnake<K> : K, KebabToSnakeRecursive<V>> : T extends Set<infer V> ? Set<KebabToSnakeRecursive<V>> : T extends object ? {
+    [K in keyof T as TransformKey<K & string, {
+        sourceCase: 'kebab';
+        targetCase: 'snake';
+    }>]: KebabToSnakeRecursive<T[K]>;
+} : T;
+/**
+ * Generic recursive transformation type
+ * Allows dynamically selecting the transformation based on source and target cases
+ */
+type TransformRecursive<T, FromCase extends StringCase, ToCase extends StringCase> = FromCase extends 'snake' ? ToCase extends 'camel' ? SnakeToCamelRecursive<T> : ToCase extends 'pascal' ? SnakeToPascalRecursive<T> : ToCase extends 'kebab' ? SnakeToKebabRecursive<T> : T : FromCase extends 'camel' ? ToCase extends 'snake' ? CamelToSnakeRecursive<T> : ToCase extends 'pascal' ? CamelToPascalRecursive<T> : ToCase extends 'kebab' ? CamelToKebabRecursive<T> : T : FromCase extends 'pascal' ? ToCase extends 'snake' ? PascalToSnakeRecursive<T> : ToCase extends 'camel' ? PascalToCamelRecursive<T> : ToCase extends 'kebab' ? PascalToKebabRecursive<T> : T : FromCase extends 'kebab' ? ToCase extends 'snake' ? KebabToSnakeRecursive<T> : ToCase extends 'camel' ? KebabToCamelRecursive<T> : ToCase extends 'pascal' ? KebabToPascalRecursive<T> : T : T;
+
+declare function transform<T, From extends StringCase, To extends StringCase>(data: T, options: TransformOptions & {
+    depth?: number;
+    sourceCase: From;
+    targetCase: To;
+}): TransformRecursive<T, From, To>;
+/**
+ * Transform data to a specified output type.
+ *
+ * Note: When using this overload, type safety is not enforced between the input, options, and output type.
+ * The 'sourceCase' option is intentionally omitted, as it is not used for type inference here.
+ */
+declare function transform<T, K>(data: T, options?: Omit<TransformOptions, 'sourceCase'> & {
+    depth?: number;
+}): K;
+declare function transform<T>(data: T, options?: TransformOptions & {
+    depth?: number;
+}): unknown;
+
+export { transform };
 export type { StringCase, TransformOptions };

package/dist/index.js

@@ -1 +1 @@
-"use strict";const e={snake:{camel:function(e){return e.toLowerCase().replace(/_([a-z0-9])/g,((e,t)=>t.toUpperCase()))},pascal:function(e){return e.toLowerCase().replace(/_+([a-z0-9])/g,((e,t)=>t.toUpperCase())).replace(/^[a-z]/,(e=>e.toUpperCase()))},kebab:function(e){return e.replace(/_/g,"-")},snake:e=>e},camel:{snake:function(e){if(!e)return e;let t=e.replace(/([a-z0-9])([A-Z])/g,"$1_$2");return t=t.replace(/([A-Z])(?=[A-Z])/g,"$1_"),t.toLowerCase()},pascal:function(e){return e?e.charAt(0).toUpperCase()+e.slice(1):e},kebab:function(e){if(!e)return e;let t=e.replace(/([a-z0-9])([A-Z])/g,"$1-$2");return t=t.replace(/([A-Z])(?=[A-Z])/g,"$1-"),t.toLowerCase()},camel:e=>e},pascal:{snake:function(e){if(!e)return e;let t=e.replace(/([A-Z]{2,})([A-Z][a-z])/g,"$1_$2");return t=t.replace(/([a-z0-9])([A-Z])/g,"$1_$2"),t.toLowerCase()},camel:function(e){return e?e.charAt(0).toLowerCase()+e.slice(1):e},kebab:function(e){if(!e)return e;let t=e.replace(/([A-Z]{2,})([A-Z][a-z])/g,"$1-$2");return t=t.replace(/([a-z0-9])([A-Z])/g,"$1-$2"),t.toLowerCase()},pascal:e=>e},kebab:{snake:function(e){return e.replace(/-/g,"_")},camel:function(e){return e.toLowerCase().replace(/-+([a-z0-9])/g,((e,t)=>t.toUpperCase()))},pascal:function(e){return e.toLowerCase().replace(/-+([a-z0-9])/g,((e,t)=>t.toUpperCase())).replace(/^[a-z]/,(e=>e.toUpperCase()))},kebab:e=>e}};const t=/^[a-z0-9_]+$/,r=/__+/,n=/^[a-z][a-zA-Z0-9]*$/,s=/^[A-Z][a-zA-Z0-9]*$/,a=/^[a-z0-9-]+$/,o=/-{2,}/,c=/[A-Z]/,u=/[a-z]/,i=/^[a-z0-9]+$/;function l(e){return"string"!=typeof e?null:function(e){if(e.includes("_")||e.includes("-")||e.includes(" "))return!1;if(e.length>0&&!/^[A-Za-z0-9]+$/.test(e))return!1;if(e.length<=1)return!0;const t=e[0],r=e.slice(1);return e===e.toLowerCase()||t===t.toUpperCase()&&r===r.toLowerCase()}(e)?"single":function(e){return"string"==typeof e&&t.test(e)&&!r.test(e)&&(e.includes("_")||i.test(e))}(e)?"snake":function(e){return"string"==typeof e&&n.test(e)&&c.test(e)}(e)?"camel":function(e){return"string"==typeof e&&s.test(e)&&u.test(e)}(e)?"pascal":function(e){return"string"==typeof e&&a.test(e)&&!o.test(e)&&(e.includes("-")||i.test(e))}(e)?"kebab":null}function f(t,r){if(!t)return t;const{targetCase:n}=r,{string:s,shouldTransform:a,sourceCase:o,singleWord:c}=function(e){if("string"!=typeof e)throw new Error("Input must be a string");if(0===e.length)return{string:e,shouldTransform:!1,sourceCase:null,singleWord:!1};if(/[^A-Za-z0-9_-]/.test(e)||/^[^A-Za-z]/.test(e)||/[^A-Za-z0-9]$/.test(e))return{string:e,shouldTransform:!1,sourceCase:null,singleWord:!1};const t=l(e);return t?"single"===t?{string:e,shouldTransform:!0,sourceCase:null,singleWord:!0}:{string:e,shouldTransform:!0,sourceCase:t,singleWord:!1}:{string:e,shouldTransform:!1,sourceCase:null,singleWord:!1}}(t);if(!a)return s;if(c)return function(e,t){switch(t){case"pascal":return e.charAt(0).toUpperCase()+e.slice(1).toLowerCase();case"camel":return e.charAt(0).toLowerCase()+e.slice(1);case"snake":case"kebab":return e.toLowerCase();default:return e}}(s,n);if(!o||o===n)return s;const u=e[o];if(!u)return s;const i=u[n];return i?i(s):s}function p(e,t){if(!(e instanceof Map))return e;const r=[];for(const[n,s]of e.entries())if("string"==typeof n){const e=f(n,t);r.push([e,s])}else r.push([n,s]);return new Map(r)}function g(e,t){if(null===e||"object"!=typeof e||Array.isArray(e))return e;const{targetCase:r,sourceCase:n}=t,s={};for(const t in e)if(Object.prototype.hasOwnProperty.call(e,t)){s[!isNaN(Number(t))&&String(Number(t))===t?Number(t):f(t,{targetCase:r,sourceCase:n})]=e[t]}if(Object.getOwnPropertySymbols){const t=Object.getOwnPropertySymbols(e);for(const r of t)s[r]=e[r]}return s}function C(e,t,r=new WeakMap,n=0){var s;if(null==e||"object"!=typeof e)return e;if(r.has(e))return r.get(e);const a=null!==(s=t.depth)&&void 0!==s?s:3;if(n>=a)return e;const o=Object.assign(Object.assign({},t),{depth:a});let c;if(Array.isArray(e))c=function(e,t){return Array.isArray(e)?e.map((e=>null==e?e:e instanceof Map?p(e,t):"object"!=typeof e||Array.isArray(e)||e instanceof Set?e:g(e,t))):e}(e,t),r.set(e,c),n<a&&(c=c.map((e=>C(e,o,r,n+1))));else if(e instanceof Map){if(c=p(e,t),r.set(e,c),n<a){const e=c;for(const[t,s]of e.entries())null!==s&&"object"==typeof s&&e.set(t,C(s,o,r,n+1))}}else if(e instanceof Set){if(c=new Set(e),r.set(e,c),n<a){const e=c,t=Array.from(e);e.clear();for(const s of t)null!==s&&"object"==typeof s?e.add(C(s,o,r,n+1)):e.add(s)}}else if(c=g(e,t),r.set(e,c),n<a){const e=c;for(const t in e){const s=e[t];null!==s&&"object"==typeof s&&(e[t]=C(s,o,r,n+1))}}return c}module.exports=function(e,t){var r;return C(e,Object.assign(Object.assign({},t),{targetCase:(null==t?void 0:t.targetCase)||"camel",depth:null!==(r=null==t?void 0:t.depth)&&void 0!==r?r:3}))};
+"use strict";const e={snake:{camel:function(e){return e.toLowerCase().replace(/_([a-z0-9])/g,(e,t)=>t.toUpperCase())},pascal:function(e){return e.toLowerCase().replace(/_+([a-z0-9])/g,(e,t)=>t.toUpperCase()).replace(/^[a-z]/,e=>e.toUpperCase())},kebab:function(e){return e.replace(/_/g,"-")},snake:e=>e},camel:{snake:function(e){if(!e)return e;let t=e.replace(/([a-z0-9])([A-Z])/g,"$1_$2");return t=t.replace(/([A-Z])(?=[A-Z])/g,"$1_"),t.toLowerCase()},pascal:function(e){return e?e.charAt(0).toUpperCase()+e.slice(1):e},kebab:function(e){if(!e)return e;let t=e.replace(/([a-z0-9])([A-Z])/g,"$1-$2");return t=t.replace(/([A-Z])(?=[A-Z])/g,"$1-"),t.toLowerCase()},camel:e=>e},pascal:{snake:function(e){if(!e)return e;let t=e.replace(/([A-Z]{2,})([A-Z][a-z])/g,"$1_$2");return t=t.replace(/([a-z0-9])([A-Z])/g,"$1_$2"),t.toLowerCase()},camel:function(e){return e?e.charAt(0).toLowerCase()+e.slice(1):e},kebab:function(e){if(!e)return e;let t=e.replace(/([A-Z]{2,})([A-Z][a-z])/g,"$1-$2");return t=t.replace(/([a-z0-9])([A-Z])/g,"$1-$2"),t.toLowerCase()},pascal:e=>e},kebab:{snake:function(e){return e.replace(/-/g,"_")},camel:function(e){return e.toLowerCase().replace(/-+([a-z0-9])/g,(e,t)=>t.toUpperCase())},pascal:function(e){return e.toLowerCase().replace(/-+([a-z0-9])/g,(e,t)=>t.toUpperCase()).replace(/^[a-z]/,e=>e.toUpperCase())},kebab:e=>e}};const t=/^[a-z0-9_]+$/,r=/__+/,n=/^[a-z][a-zA-Z0-9]*$/,s=/^[A-Z][a-zA-Z0-9]*$/,a=/^[a-z0-9-]+$/,o=/-{2,}/,c=/[A-Z]/,u=/[a-z]/,i=/^[a-z0-9]+$/;function l(e){return"string"!=typeof e?null:function(e){if(e.includes("_")||e.includes("-")||e.includes(" "))return!1;if(e.length>0&&!/^[A-Za-z0-9]+$/.test(e))return!1;if(e.length<=1)return!0;const t=e[0],r=e.slice(1);return e===e.toLowerCase()||t===t.toUpperCase()&&r===r.toLowerCase()}(e)?"single":function(e){return"string"==typeof e&&t.test(e)&&!r.test(e)&&(e.includes("_")||i.test(e))}(e)?"snake":function(e){return"string"==typeof e&&n.test(e)&&c.test(e)}(e)?"camel":function(e){return"string"==typeof e&&s.test(e)&&u.test(e)}(e)?"pascal":function(e){return"string"==typeof e&&a.test(e)&&!o.test(e)&&(e.includes("-")||i.test(e))}(e)?"kebab":null}function f(t,r){if(!t)return t;const{targetCase:n}=r,{string:s,shouldTransform:a,sourceCase:o,singleWord:c}=function(e){if("string"!=typeof e)throw new Error("Input must be a string");if(0===e.length)return{string:e,shouldTransform:!1,sourceCase:null,singleWord:!1};if(/[^A-Za-z0-9_-]/.test(e)||/^[^A-Za-z]/.test(e)||/[^A-Za-z0-9]$/.test(e))return{string:e,shouldTransform:!1,sourceCase:null,singleWord:!1};const t=l(e);return t?"single"===t?{string:e,shouldTransform:!0,sourceCase:null,singleWord:!0}:{string:e,shouldTransform:!0,sourceCase:t,singleWord:!1}:{string:e,shouldTransform:!1,sourceCase:null,singleWord:!1}}(t);if(!a)return s;if(c)return function(e,t){switch(t){case"pascal":return e.charAt(0).toUpperCase()+e.slice(1).toLowerCase();case"camel":return e.charAt(0).toLowerCase()+e.slice(1);case"snake":case"kebab":return e.toLowerCase();default:return e}}(s,n);if(!o||o===n)return s;const u=e[o];if(!u)return s;const i=u[n];return i?i(s):s}function p(e,t){if(!(e instanceof Map))return e;const r=[];for(const[n,s]of e.entries())if("string"==typeof n){const e=f(n,t);r.push([e,s])}else r.push([n,s]);return new Map(r)}function g(e,t){if(null===e||"object"!=typeof e||Array.isArray(e))return e;const{targetCase:r,sourceCase:n}=t,s={};for(const t in e)if(Object.prototype.hasOwnProperty.call(e,t)){s[!isNaN(Number(t))&&String(Number(t))===t?Number(t):f(t,{targetCase:r})]=e[t]}for(const t of Object.getOwnPropertySymbols(e))s[t]=e[t];return s}function C(e,t,r=new WeakMap,n=0){var s;if(null==e||"object"!=typeof e)return e;if(r.has(e))return r.get(e);const a=null!==(s=t.depth)&&void 0!==s?s:1/0;if(n>=a)return e;const o=Object.assign(Object.assign({},t),{depth:a});let c;if(Array.isArray(e))c=function(e,t){return Array.isArray(e)?e.map(e=>null==e?e:e instanceof Map?p(e,t):"object"!=typeof e||Array.isArray(e)||e instanceof Set?e:g(e,t)):e}(e,t),r.set(e,c),c=c.map(e=>C(e,o,r,n+1));else if(e instanceof Map){c=p(e,t),r.set(e,c);const s=c;for(const[e,t]of s.entries())null!==t&&"object"==typeof t&&s.set(e,C(t,o,r,n+1))}else if(e instanceof Set){c=new Set(e),r.set(e,c);const t=c,s=Array.from(t);t.clear();for(const e of s)null!==e&&"object"==typeof e?t.add(C(e,o,r,n+1)):t.add(e)}else{c=g(e,t),r.set(e,c);const s=c;for(const e in s){const t=s[e];null!==t&&"object"==typeof t&&(s[e]=C(t,o,r,n+1))}}return c}exports.transform=function(e,t){var r;return C(e,Object.assign(Object.assign({},t),{targetCase:(null==t?void 0:t.targetCase)||"camel",depth:null!==(r=null==t?void 0:t.depth)&&void 0!==r?r:1/0}))};

package/dist/index.mjs

@@ -0,0 +1 @@
+const e={snake:{camel:function(e){return e.toLowerCase().replace(/_([a-z0-9])/g,(e,t)=>t.toUpperCase())},pascal:function(e){return e.toLowerCase().replace(/_+([a-z0-9])/g,(e,t)=>t.toUpperCase()).replace(/^[a-z]/,e=>e.toUpperCase())},kebab:function(e){return e.replace(/_/g,"-")},snake:e=>e},camel:{snake:function(e){if(!e)return e;let t=e.replace(/([a-z0-9])([A-Z])/g,"$1_$2");return t=t.replace(/([A-Z])(?=[A-Z])/g,"$1_"),t.toLowerCase()},pascal:function(e){return e?e.charAt(0).toUpperCase()+e.slice(1):e},kebab:function(e){if(!e)return e;let t=e.replace(/([a-z0-9])([A-Z])/g,"$1-$2");return t=t.replace(/([A-Z])(?=[A-Z])/g,"$1-"),t.toLowerCase()},camel:e=>e},pascal:{snake:function(e){if(!e)return e;let t=e.replace(/([A-Z]{2,})([A-Z][a-z])/g,"$1_$2");return t=t.replace(/([a-z0-9])([A-Z])/g,"$1_$2"),t.toLowerCase()},camel:function(e){return e?e.charAt(0).toLowerCase()+e.slice(1):e},kebab:function(e){if(!e)return e;let t=e.replace(/([A-Z]{2,})([A-Z][a-z])/g,"$1-$2");return t=t.replace(/([a-z0-9])([A-Z])/g,"$1-$2"),t.toLowerCase()},pascal:e=>e},kebab:{snake:function(e){return e.replace(/-/g,"_")},camel:function(e){return e.toLowerCase().replace(/-+([a-z0-9])/g,(e,t)=>t.toUpperCase())},pascal:function(e){return e.toLowerCase().replace(/-+([a-z0-9])/g,(e,t)=>t.toUpperCase()).replace(/^[a-z]/,e=>e.toUpperCase())},kebab:e=>e}};const t=/^[a-z0-9_]+$/,r=/__+/,n=/^[a-z][a-zA-Z0-9]*$/,s=/^[A-Z][a-zA-Z0-9]*$/,a=/^[a-z0-9-]+$/,o=/-{2,}/,c=/[A-Z]/,u=/[a-z]/,i=/^[a-z0-9]+$/;function l(e){return"string"!=typeof e?null:function(e){if(e.includes("_")||e.includes("-")||e.includes(" "))return!1;if(e.length>0&&!/^[A-Za-z0-9]+$/.test(e))return!1;if(e.length<=1)return!0;const t=e[0],r=e.slice(1);return e===e.toLowerCase()||t===t.toUpperCase()&&r===r.toLowerCase()}(e)?"single":function(e){return"string"==typeof e&&t.test(e)&&!r.test(e)&&(e.includes("_")||i.test(e))}(e)?"snake":function(e){return"string"==typeof e&&n.test(e)&&c.test(e)}(e)?"camel":function(e){return"string"==typeof e&&s.test(e)&&u.test(e)}(e)?"pascal":function(e){return"string"==typeof e&&a.test(e)&&!o.test(e)&&(e.includes("-")||i.test(e))}(e)?"kebab":null}function f(t,r){if(!t)return t;const{targetCase:n}=r,{string:s,shouldTransform:a,sourceCase:o,singleWord:c}=function(e){if("string"!=typeof e)throw new Error("Input must be a string");if(0===e.length)return{string:e,shouldTransform:!1,sourceCase:null,singleWord:!1};if(/[^A-Za-z0-9_-]/.test(e)||/^[^A-Za-z]/.test(e)||/[^A-Za-z0-9]$/.test(e))return{string:e,shouldTransform:!1,sourceCase:null,singleWord:!1};const t=l(e);return t?"single"===t?{string:e,shouldTransform:!0,sourceCase:null,singleWord:!0}:{string:e,shouldTransform:!0,sourceCase:t,singleWord:!1}:{string:e,shouldTransform:!1,sourceCase:null,singleWord:!1}}(t);if(!a)return s;if(c)return function(e,t){switch(t){case"pascal":return e.charAt(0).toUpperCase()+e.slice(1).toLowerCase();case"camel":return e.charAt(0).toLowerCase()+e.slice(1);case"snake":case"kebab":return e.toLowerCase();default:return e}}(s,n);if(!o||o===n)return s;const u=e[o];if(!u)return s;const i=u[n];return i?i(s):s}function p(e,t){if(!(e instanceof Map))return e;const r=[];for(const[n,s]of e.entries())if("string"==typeof n){const e=f(n,t);r.push([e,s])}else r.push([n,s]);return new Map(r)}function g(e,t){if(null===e||"object"!=typeof e||Array.isArray(e))return e;const{targetCase:r,sourceCase:n}=t,s={};for(const t in e)if(Object.prototype.hasOwnProperty.call(e,t)){s[!isNaN(Number(t))&&String(Number(t))===t?Number(t):f(t,{targetCase:r})]=e[t]}for(const t of Object.getOwnPropertySymbols(e))s[t]=e[t];return s}function C(e,t,r=new WeakMap,n=0){var s;if(null==e||"object"!=typeof e)return e;if(r.has(e))return r.get(e);const a=null!==(s=t.depth)&&void 0!==s?s:1/0;if(n>=a)return e;const o=Object.assign(Object.assign({},t),{depth:a});let c;if(Array.isArray(e))c=function(e,t){return Array.isArray(e)?e.map(e=>null==e?e:e instanceof Map?p(e,t):"object"!=typeof e||Array.isArray(e)||e instanceof Set?e:g(e,t)):e}(e,t),r.set(e,c),c=c.map(e=>C(e,o,r,n+1));else if(e instanceof Map){c=p(e,t),r.set(e,c);const s=c;for(const[e,t]of s.entries())null!==t&&"object"==typeof t&&s.set(e,C(t,o,r,n+1))}else if(e instanceof Set){c=new Set(e),r.set(e,c);const t=c,s=Array.from(t);t.clear();for(const e of s)null!==e&&"object"==typeof e?t.add(C(e,o,r,n+1)):t.add(e)}else{c=g(e,t),r.set(e,c);const s=c;for(const e in s){const t=s[e];null!==t&&"object"==typeof t&&(s[e]=C(t,o,r,n+1))}}return c}function A(e,t){var r;return C(e,Object.assign(Object.assign({},t),{targetCase:(null==t?void 0:t.targetCase)||"camel",depth:null!==(r=null==t?void 0:t.depth)&&void 0!==r?r:1/0}))}export{A as transform};

package/package.json

@@ -1,13 +1,21 @@
 {
   "name": "deep-case-crafter",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "Transforms deeply nested object, array, Map, and Set keys between common case formats while preserving TypeScript type safety",
   "main": "dist/index.js",
-  "module": "dist/index.esm.js",
+  "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
   "exports": {
-    "import": "./dist/index.esm.js",
-    "require": "./dist/index.js"
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.js"
+      }
+    }
   },
   "files": [
     "dist"
@@ -48,6 +56,7 @@
   ],
   "scripts": {
     "build": "rollup -c",
+    "prepack": "npm run build",
     "prepare": "husky",
     "test": "jest",
     "test-coverage": "npm test -- --coverage",
@@ -57,29 +66,30 @@
     "benchmark": "tsx benchmark/*.benchmark.ts"
   },
   "devDependencies": {
+    "@eslint/js": "10.0.1",
+    "@rollup/plugin-commonjs": "29.0.3",
+    "@rollup/plugin-node-resolve": "16.0.3",
+    "@rollup/plugin-terser": "1.0.0",
+    "@rollup/plugin-typescript": "12.3.0",
     "@types/benchmark": "2.1.5",
+    "@types/jest": "30.0.0",
+    "@types/node": "25.9.1",
     "benchmark": "2.1.4",
-    "@eslint/js": "9.21.0",
-    "@rollup/plugin-commonjs": "28.0.2",
-    "@rollup/plugin-node-resolve": "16.0.0",
-    "@rollup/plugin-terser": "0.4.4",
-    "@rollup/plugin-typescript": "12.1.2",
-    "@types/jest": "29.5.12",
-    "@types/node": "20.14.11",
-    "eslint": "9.21.0",
-    "eslint-config-prettier": "10.0.1",
-    "eslint-plugin-prettier": "5.2.3",
-    "globals": "16.0.0",
+    "eslint": "10.4.1",
+    "eslint-config-prettier": "10.1.8",
+    "eslint-plugin-prettier": "5.5.6",
+    "globals": "17.6.0",
     "husky": "9.1.7",
-    "lint-staged": "15.4.3",
-    "jest": "29.7.0",
-    "rollup": "4.28.1",
+    "jest": "30.4.2",
+    "lint-staged": "17.0.7",
+    "rollup": "4.61.0",
+    "rollup-plugin-dts": "6.4.1",
     "rollup-plugin-peer-deps-external": "2.2.4",
-    "rollup-plugin-visualizer": "5.12.0",
-    "ts-jest": "29.2.3",
+    "rollup-plugin-visualizer": "7.0.1",
+    "ts-jest": "29.4.11",
     "tslib": "2.8.1",
-    "typescript": "5.7.2",
-    "typescript-eslint": "8.24.1",
-    "tsx": "4.19.3"
+    "tsx": "4.22.4",
+    "typescript": "6.0.3",
+    "typescript-eslint": "8.60.1"
   }
 }

package/readme.md

@@ -1,34 +1,43 @@
 # DeepCaseCrafter
 
-🚀 **DeepCaseCrafter** is a TypeScript utility that **transforms deeply nested object keys** into different case formats while maintaining **type safety**. It supports **objects, arrays, Maps, and Sets** and allows **custom recursion depth**.
+**DeepCaseCrafter** transforms deeply nested object keys between case formats (`camelCase`, `PascalCase`, `snake_case`, `kebab-case`). It works on objects, arrays, Maps, and Sets, with configurable recursion depth, and produces precise output types when both `sourceCase` and `targetCase` are set.
 
 [![npm version](https://img.shields.io/npm/v/deep-case-crafter)](https://www.npmjs.com/package/deep-case-crafter)
-[![License: MIT](https://img.shields.io/npm/l/deep-case-crafter)](https://github.com/your-repo/deep-case-crafter/blob/main/LICENSE)
-[![TypeScript](https://img.shields.io/badge/TypeScript-Ready-blue)](https://www.typescriptlang.org/)
+[![npm bundle size](https://img.shields.io/bundlephobia/minzip/deep-case-crafter)](https://bundlephobia.com/package/deep-case-crafter)
+[![npm type definitions](https://img.shields.io/npm/types/deep-case-crafter)](https://www.npmjs.com/package/deep-case-crafter)
+[![Dev dependency: typescript](https://img.shields.io/github/package-json/dependency-version/gyrgy/deep-case-crafter/dev/typescript/main)](https://github.com/gyrgy/deep-case-crafter/blob/main/package.json)
+[![Documentation](https://img.shields.io/badge/documentation-yes-brightgreen.svg)](https://github.com/gyrgy/deep-case-crafter#readme)
+[![Maintenance](https://img.shields.io/maintenance/yes/2026.svg)](https://github.com/gyrgy/deep-case-crafter/graphs/commit-activity)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/gyrgy/deep-case-crafter/blob/main/LICENSE)
 
 ## Features
 
-- 🔄 **Automatically converts keys** to `camelCase`, `PascalCase`, `snake_case`, and `kebab-case`.
-- 🌍 **Works with deeply nested structures**, including objects, arrays, Maps, and Sets.
-- ✅ **Maintains TypeScript type inference** for better auto-completion.
-- 🔍 **Preserves special keys** (`__`, `--`, leading numbers, special characters).
-- ⚡ **Performance-optimized** with minimal overhead.
-- 🎛 **Configurable recursion depth** (default: `3`).
+- Converts keys to `camelCase`, `PascalCase`, `snake_case`, and `kebab-case`.
+- Works with deeply nested structures, including objects, arrays, Maps, and Sets.
+- Precise TypeScript inference when `sourceCase` and `targetCase` are set (otherwise the result type is widened).
+- Preserves special keys (`__`, `--`, leading numbers, special characters).
+- Configurable recursion depth (default: fully recursive).
 
-## 📦 Installation
+## Installation
 
 ```bash
 npm install deep-case-crafter
 ```
 
+> **⚠️ v2 breaking change:** `transform` is now a **named export**. Update
+> `import transform from 'deep-case-crafter'` to
+> `import { transform } from 'deep-case-crafter'` (CommonJS:
+> `const { transform } = require('deep-case-crafter')`). This fixes type
+> resolution for modern (`node16`/`nodenext`/bundler) consumers.
+
 ---
 
-## 🚀 Quick Start
+## Quick Start
 
-### 1️⃣ **Basic Usage – Just Call `transform`**
+### 1. Basic usage — just call `transform`
 
 ```typescript
-import transform from 'deep-case-crafter';
+import { transform } from 'deep-case-crafter';
 
 const input = { user_id: 1, first_name: 'John' };
 const result = transform(input);
@@ -41,7 +50,7 @@ _(Automatically converts from `snake_case` to `camelCase`)_
 
 ---
 
-### 2️⃣ **Specify the `targetCase`**
+### 2. Specify the `targetCase`
 
 ```typescript
 const input = { user_id: 1, first_name: 'John' };
@@ -57,9 +66,9 @@ console.log(kebabCaseResult);
 
 ---
 
-### 3️⃣ **Explicitly Define `sourceCase` for TypeScript Benefits**
+### 3. Explicitly define `sourceCase` for TypeScript benefits
 
-_TypeScript automatically infers key changes when `sourceCase` is set._
+_TypeScript infers the exact output keys when **both** `sourceCase` and `targetCase` are set._
 
 ```typescript
 const input = { user_id: 1, first_name: 'John' };
@@ -71,7 +80,7 @@ console.log(result);
 
 ---
 
-### 4️⃣ **Transform Deeply Nested Structures**
+### 4. Transform deeply nested structures
 
 ```typescript
 const nestedInput = {
@@ -94,7 +103,7 @@ console.log(transformed);
 
 ---
 
-### 5️⃣ **Transforming a `Map`**
+### 5. Transforming a `Map`
 
 ```typescript
 const mapInput = new Map([
@@ -113,33 +122,44 @@ console.log(result.get('firstName')); // 'John'
 
 ---
 
-### 6️⃣ **Transforming a `Set`**
+### 6. Transforming a `Set`
+
+A `Set` is a collection of _values_, not key/value pairs, so its primitive
+members (strings, numbers, etc.) are passed through unchanged — only the **keys
+of objects nested inside the Set** are transformed.
 
 ```typescript
-const setInput = new Set(['user_id', 'first_name']);
+const setInput = new Set([{ user_id: 1 }, { first_name: 'John' }]);
 const result = transform(setInput, {
   targetCase: 'camel',
   sourceCase: 'snake',
 });
 
-console.log(result); // Set { 'userId', 'firstName' }
+console.log(result); // Set { { userId: 1 }, { firstName: 'John' } }
+
+// Primitive members are left as-is:
+const strings = new Set(['user_id', 'first_name']);
+console.log(transform(strings, { targetCase: 'camel', sourceCase: 'snake' }));
+// Set { 'user_id', 'first_name' }
 ```
 
 ---
 
-## 📖 API
+## API
 
 ### `transform(data, options)`
 
 - **data**: The data structure to transform (`object`, `array`, `Map`, or `Set`).
 - **options**:
   - `targetCase` (optional): `'camel' | 'snake' | 'pascal' | 'kebab'` (default: `'camel'`)
-  - `sourceCase` (optional): **Required for TypeScript inference** (`'snake' | 'camel' | 'pascal' | 'kebab'`).
-  - `depth` (optional): **Recursion depth** (default: `3`, use `Infinity` for full recursion).
+  - `sourceCase` (optional): `'snake' | 'camel' | 'pascal' | 'kebab'`. Omit it to auto-detect each key's case at runtime.
+  - `depth` (optional): **Recursion depth** (default: `Infinity` — the whole structure is transformed). Pass a number to stop transforming below that level. Circular references are always handled safely.
+
+> **TypeScript inference:** precise output types are produced only when both `sourceCase` and `targetCase` are passed. Without both, the call still works at runtime (auto-detecting each key) but the result type is widened.
 
 ---
 
-## 🧑‍💻 Advanced: Explicit Output Type Overload
+## Advanced: explicit output type overload
 
 If you want to specify the output type explicitly (for example, when you know the exact shape you want), you can use the following overload:
 
@@ -149,6 +169,7 @@ const typedResult: Output = result; // TypeScript will enforce Output type here
 ```
 
 **Note:**
+
 - When using this overload, you cannot pass `sourceCase` in the options. If you do, TypeScript will show an error:
   > Object literal may only specify known properties, and 'sourceCase' does not exist in type 'Omit<TransformOptions, "sourceCase"> & { depth?: number }'.
 - This overload is useful when you want to take full control of the output type, but type safety between input, options, and output is not enforced by the library.
@@ -160,42 +181,38 @@ const result = transform(obj, { targetCase: 'camel', sourceCase: 'snake' }); //
 
 ---
 
-## 🚨 Key Preservation Rules
+## Key Preservation Rules
 
-- **Keys that start with special characters or numbers** are **not transformed**.
-- **Keys with `__` or `--` remain unchanged**.
-- **Numbers at the end of keys** are preserved.
+A key is left **completely unchanged** when it:
 
----
-
-## ⚡ Performance & Benchmarks
+- **starts with anything other than a letter** (a digit or special character), e.g. `1st_place`, `_private`;
+- **ends with a non-alphanumeric character**, e.g. `value_`, `count-`;
+- **contains characters outside** `A-Z a-z 0-9 _ -`, e.g. `user.name`, `a@b`;
+- **contains consecutive `__` or `--`**, e.g. `a__b`, `x--y` (ambiguous to detect).
 
-DeepCaseCrafter is optimized for speed and efficiency:
-
-```plaintext
-Transform Deep Object (Depth 5, Width 10)
-x 361,538 ops/sec ±0.12% (91 runs sampled)
-```
+Trailing digits are kept but treated as part of the word, so they do **not** by
+themselves preserve a key — `address_1` becomes `address1`, and the single word
+`item2` stays `item2`.
 
 ---
 
-## 💡 Contributing
+## Contributing
 
-1. **Fork** the repository.
-2. **Create a new branch** (`feature/my-feature`).
-3. **Commit your changes** (`git commit -m "Add new feature"`).
-4. **Submit a pull request** 🚀.
+1. Fork the repository.
+2. Create a new branch (`feature/my-feature`).
+3. Commit your changes.
+4. Submit a pull request.
 
 ---
 
-## 📜 License
+## License
 
 MIT
 
 ---
 
-## 🔗 Links
+## Links
 
 - [NPM Package](https://www.npmjs.com/package/deep-case-crafter)
-- [GitHub Repository](https://github.com/your-repo/deep-case-crafter)
+- [GitHub Repository](https://github.com/gyrgy/deep-case-crafter)
 - [TypeScript Docs](https://www.typescriptlang.org/)

package/dist/constants/formatterMap.d.ts

@@ -1,21 +0,0 @@
-import { StringCase } from '../types/stringCaseTypes';
-/**
- * A mapping of transformation functions for converting strings between different case formats.
- *
- * Each key of this mapping represents the detected source case (e.g., 'snake', 'camel', 'pascal', 'kebab').
- * The corresponding value is an object that maps target case formats to the appropriate transformation function.
- *
- * Each transformation function accepts a string (`str`) that is to be transformed.
- *
- * For instance:
- * - `formatterMap.snake.camel` converts a snake_case string to camelCase.
- * - If the source and target cases are the same (e.g., `formatterMap.snake.snake`), an identity function is provided.
- *
- * @type {Record<StringCase, Record<StringCase, (str: string) => string>>}
- */
-declare const formatterMap: {
-    [source in StringCase]: {
-        [target in StringCase]: (str: string) => string;
-    };
-};
-export default formatterMap;

package/dist/constants/regex.d.ts

@@ -1,9 +0,0 @@
-export declare const SNAKE_ONLY_REGEX: RegExp;
-export declare const SNAKE_CONSECUTIVE_UNDERSCORES_REGEX: RegExp;
-export declare const CAMEL_ONLY_REGEX: RegExp;
-export declare const PASCAL_CASE_FULL_REGEX: RegExp;
-export declare const KEBAB_LOWER_NUMBERS_HYPHENS_REGEX: RegExp;
-export declare const KEBAB_CONSECUTIVE_HYPHENS_REGEX: RegExp;
-export declare const HAS_UPPER_CASE_REGEX: RegExp;
-export declare const HAS_LOWER_CASE_REGEX: RegExp;
-export declare const SINGLE_WORD_REGEX: RegExp;

package/dist/dataTransformers/primitiveTransformer.d.ts

@@ -1,7 +0,0 @@
-/**
- * Transform primitives (returns them unchanged)
- * @param value - The primitive value
- * @returns The same value
- * @internal This function is for internal use by the library
- */
-export default function transformPrimitive<T>(value: T): T;