deep-case-crafter 1.0.0 → 2.0.0

package/dist/dataTransformers/transformArray.d.ts

@@ -1,19 +0,0 @@
-import { Expand } from '../types/helperTypes';
-import { TransformOptionsInternal } from '../types/transformOptionTypes';
-import { TransformArrayReturn } from '../types/transformTypes';
-/**
- * Transforms all objects and Maps within an array (single level only)
- *
- * @param arr - The array to transform
- * @param options - Transformation options including targetCase (required) and optional sourceCase
- * @returns A new array with transformed items
- *
- * @remarks
- * - This function transforms keys in objects and Maps contained in the array
- * - Only transforms at the current level (not recursive)
- * - Non-object values in the array are kept as-is
- * - When sourceCase is specified, provides more precise type information
- *
- * @internal This function is for internal use by the library
- */
-export default function transformArray<T extends unknown[], O extends TransformOptionsInternal>(arr: T, options: O): Expand<TransformArrayReturn<T, O>>;

package/dist/dataTransformers/transformMap.d.ts

@@ -1,18 +0,0 @@
-import { TransformOptionsInternal } from '../types/transformOptionTypes';
-import { TransformMapReturn } from '../types/transformTypes';
-/**
- * Transforms string keys in a Map (single level only)
- *
- * @param map - The Map to transform
- * @param options - Transformation options including targetCase (required), optional sourceCase and optional preserveSpecialCharacters
- * @returns A new Map with transformed keys
- *
- * @remarks
- * - Only string keys are transformed; other key types remain unchanged
- * - Values are not transformed, only copied to the new Map
- * - When sourceCase is specified, provides precise type transformations
- * - This function does not transform nested structures
- *
- * @internal This function is for internal use by the library
- */
-export default function transformMap<K, V, O extends TransformOptionsInternal>(map: Map<K, V>, options: O): TransformMapReturn<K, V, O>;

package/dist/dataTransformers/transformObject.d.ts

@@ -1,21 +0,0 @@
-import { TransformOptionsInternal } from '../types/transformOptionTypes';
-import { TransformObjectReturn } from '../types/transformTypes';
-/**
- * Transforms an object's keys to the specified case format (single level only)
- * @param obj - The object to transform
- * @param options - Transformation options including targetCase (required), optional sourceCase and optional preserveSpecialCharacters
- * @returns A new object with transformed keys
- *
- * @remarks
- * - Only string keys will be transformed; numeric keys and Symbol keys remain unchanged
- * - When sourceCase is specified:
- *   - TypeScript provides precise property type information
- *   - Transformation is more efficient (bypasses runtime detection)
- * - When sourceCase is not specified:
- *   - Automatic case detection is used for each key
- *   - Return type is Record<string, unknown> for type safety
- * - The preserveSpecialCharacters option retains special characters at the beginning and end of keys
- *
- * @internal This function is for internal use by the library
- */
-export default function transformObject<T extends object, O extends TransformOptionsInternal>(obj: T, options: O): TransformObjectReturn<T, O>;

package/dist/dataTransformers/transformSingleWord.d.ts

@@ -1,8 +0,0 @@
-import { StringCase } from '../types/stringCaseTypes';
-/**
- * Transforms a single word to the target case format
- * @param str - The single word to transform
- * @param targetCase - The target case format
- * @returns The transformed string
- */
-export default function transformSingleWord(str: string, targetCase: StringCase): string;

package/dist/index.esm.js

@@ -1 +0,0 @@
-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}function b(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}))}export{b as default};

package/dist/transform/internalTransform.d.ts

@@ -1,15 +0,0 @@
-import { TransformOptionsInternal } from '../types/transformOptionTypes';
-/**
- * Recursively transforms data structures (objects, arrays, Maps) by changing their keys/property names
- *
- * @param data - The data to transform (object, array, Map)
- * @param options - Transformation options
- * @param visitedRefs - Used internally to track circular references
- * @param currentDepth - Used internally to track current recursion depth
- * @returns The transformed data
- *
- * @internal This function is for internal use by the library
- */
-export default function internalTransform(data: unknown, options: TransformOptionsInternal & {
-    depth?: number;
-}, visitedRefs?: WeakMap<object, unknown>, currentDepth?: number): unknown;

package/dist/transform/transform.d.ts

@@ -1,21 +0,0 @@
-import { StringCase } from '../types/stringCaseTypes';
-import { TransformOptions } from '../types/transformOptionTypes';
-import { TransformRecursive } from '../types/transformTypes';
-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 default transform;

package/dist/transform/transformCase.d.ts

@@ -1,23 +0,0 @@
-import { TransformOptionsInternal } from '../types/transformOptionTypes';
-/**
- * Transforms a string from one case format to another.
- *
- * @param str - The string to transform
- * @param options - Transformation options
- * @param options.targetCase - The target case format to transform to
- * @param options.sourceCase - Optional source case format. If provided, skips detection
- *
- * @returns The transformed string, or the original string if transformation is not possible
- *
- * @example
- * // With automatic source detection
- * transformCase('hello_world', { targetCase: 'camel' })
- * // => 'helloWorld'
- *
- * // With explicit source case
- * transformCase('HelloWorld', { targetCase: 'snake', sourceCase: 'pascal' })
- * // => 'hello_world'
- *
- * @internal This function is for internal use by the library
- */
-export default function transformCase(str: string, options: TransformOptionsInternal): string;

package/dist/types/helperTypes.d.ts

@@ -1,3 +0,0 @@
-export type Expand<T> = T extends unknown ? {
-    [K in keyof T]: T[K];
-} : never;

package/dist/types/stringCaseTypes.d.ts

@@ -1,4 +0,0 @@
-/**
- * Represents the supported string case formats for transformation
- */
-export type StringCase = 'camel' | 'pascal' | 'snake' | 'kebab';

package/dist/types/transformOptionTypes.d.ts

@@ -1,41 +0,0 @@
-import { StringCase } from './stringCaseTypes';
-/**
- * Options for the transform function
- */
-export 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;
-}
-/**
- * Internal options for transformation (used within the package).
- * Ensures required fields are set after defaults are applied.
- */
-export type TransformOptionsInternal = Required<Pick<TransformOptions, 'targetCase'>> & Omit<TransformOptions, 'targetCase'>;

package/dist/types/transformTypes.d.ts

@@ -1,279 +0,0 @@
-import { Expand } from './helperTypes';
-import { StringCase } from './stringCaseTypes';
-import { TransformOptions } from './transformOptionTypes';
-/**
- * Type utility that transforms a snake_case string to camelCase
- * Example: 'hello_world' -> 'helloWorld'
- */
-export 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];
-export 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'
- */
-export 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'
- */
-export 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'
- */
-export type CamelToPascal<S extends string> = Capitalize<S>;
-/**
- * Type utility that transforms a camelCase string to kebab-case
- * Example: 'helloWorld' -> 'hello-world'
- */
-export 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'
- */
-export 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'
- */
-export 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'
- */
-export 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'
- */
-export 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'
- */
-export 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'
- */
-export 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
- */
-export 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;
-/**
- * Type utility that transforms all keys in an object from the source case to the target case
- */
-export type TransformObjectKeys<T, O extends TransformOptions = {
-    targetCase: 'camel';
-}> = {
-    [K in keyof T as TransformKey<K & string, O>]: T[K];
-};
-/**
- * Helper type to determine the return type of transformObject based on options
- */
-export type TransformObjectReturn<T, O> = O extends {
-    sourceCase: StringCase;
-} ? Expand<TransformObjectKeys<T, O>> : Record<string | number | symbol, unknown>;
-/**
- * Helper type to determine the return type of transformMap based on options
- */
-export type TransformMapReturn<K, V, O> = O extends {
-    sourceCase: StringCase;
-} ? Map<K extends string ? TransformKey<K & string, O> : K, V> : Map<string | Exclude<K, string>, V>;
-/**
- * Object transformation type aliases
- * These provide more readable type names for common transformations
- */
-export type SnakeToCamelObject<T> = TransformObjectKeys<T, {
-    sourceCase: 'snake';
-    targetCase: 'camel';
-}>;
-export type SnakeToPascalObject<T> = TransformObjectKeys<T, {
-    sourceCase: 'snake';
-    targetCase: 'pascal';
-}>;
-export type SnakeToKebabObject<T> = TransformObjectKeys<T, {
-    sourceCase: 'snake';
-    targetCase: 'kebab';
-}>;
-export type CamelToSnakeObject<T> = TransformObjectKeys<T, {
-    sourceCase: 'camel';
-    targetCase: 'snake';
-}>;
-export type CamelToPascalObject<T> = TransformObjectKeys<T, {
-    sourceCase: 'camel';
-    targetCase: 'pascal';
-}>;
-export type CamelToKebabObject<T> = TransformObjectKeys<T, {
-    sourceCase: 'camel';
-    targetCase: 'kebab';
-}>;
-export type PascalToCamelObject<T> = TransformObjectKeys<T, {
-    sourceCase: 'pascal';
-    targetCase: 'camel';
-}>;
-export type PascalToSnakeObject<T> = TransformObjectKeys<T, {
-    sourceCase: 'pascal';
-    targetCase: 'snake';
-}>;
-export type PascalToKebabObject<T> = TransformObjectKeys<T, {
-    sourceCase: 'pascal';
-    targetCase: 'kebab';
-}>;
-export type KebabToCamelObject<T> = TransformObjectKeys<T, {
-    sourceCase: 'kebab';
-    targetCase: 'camel';
-}>;
-export type KebabToPascalObject<T> = TransformObjectKeys<T, {
-    sourceCase: 'kebab';
-    targetCase: 'pascal';
-}>;
-export type KebabToSnakeObject<T> = TransformObjectKeys<T, {
-    sourceCase: 'kebab';
-    targetCase: 'snake';
-}>;
-/**
- * Array transformation type aliases
- */
-export type SnakeToCamelArray<T> = Array<SnakeToCamelObject<T>>;
-export type SnakeToPascalArray<T> = Array<SnakeToPascalObject<T>>;
-export type SnakeToKebabArray<T> = Array<SnakeToKebabObject<T>>;
-export type CamelToSnakeArray<T> = Array<CamelToSnakeObject<T>>;
-export type CamelToPascalArray<T> = Array<CamelToPascalObject<T>>;
-export type CamelToKebabArray<T> = Array<CamelToKebabObject<T>>;
-export type PascalToCamelArray<T> = Array<PascalToCamelObject<T>>;
-export type PascalToSnakeArray<T> = Array<PascalToSnakeObject<T>>;
-export type PascalToKebabArray<T> = Array<PascalToKebabObject<T>>;
-export type KebabToCamelArray<T> = Array<KebabToCamelObject<T>>;
-export type KebabToPascalArray<T> = Array<KebabToPascalObject<T>>;
-export type KebabToSnakeArray<T> = Array<KebabToSnakeObject<T>>;
-/**
- * Generic transformation utility for objects
- */
-export type TransformObject<T, From extends StringCase, To extends StringCase> = TransformObjectKeys<T, {
-    sourceCase: From;
-    targetCase: To;
-}>;
-/**
- * Generic transformation utility for arrays
- */
-export type TransformArray<T, From extends StringCase, To extends StringCase> = Array<TransformObject<T, From, To>>;
-/**
- * Helper type to determine array return type based on options
- */
-export type TransformArrayReturn<T extends unknown[], O> = O extends {
-    sourceCase: StringCase;
-} ? {
-    [K in keyof T]: T[K] extends object ? TransformObjectKeys<T[K], O> : T[K] extends Map<infer KT, infer VT> ? Map<KT extends string ? string : KT, VT> : T[K];
-} : unknown[];
-/**
- * Recursive type transformations
- * These types handle nested structures like arrays, objects, Maps, and Sets
- */
-export 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;
-export 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;
-export 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;
-export 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;
-export 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;
-export 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;
-export 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;
-export 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;
-export 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;
-export 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;
-export 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;
-export 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
- */
-export 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;
-export {};

package/dist/utils/caseDetectors/isCamelCase.d.ts

@@ -1,13 +0,0 @@
-/**
- * Checks if a string is in camelCase format
- * @param str - The string to check
- * @returns boolean indicating if the string is in camelCase
- *
- * @example
- * ```typescript
- * isCamelCase('helloWorld') // => true
- * isCamelCase('hello_world') // => false
- * ```
- * @internal This function is for internal use by the library
- */
-export default function isCamelCase(str: string): boolean;

package/dist/utils/caseDetectors/isKebabCase.d.ts

@@ -1,13 +0,0 @@
-/**
- * Checks if a string is in kebab-case format
- * @param str - The string to check
- * @returns boolean indicating if the string is in kebab-case
- *
- * @example
- * ```typescript
- * isKebabCase('hello-world') // => true
- * isKebabCase('helloWorld') // => false
- * ```
- * @internal This function is for internal use by the library
- */
-export declare function isKebabCase(str: string): boolean;

package/dist/utils/caseDetectors/isPascalCase.d.ts

@@ -1,14 +0,0 @@
-/**
- * Checks if a string is in PascalCase format
- * @param str - The string to check
- * @returns boolean indicating if the string is in PascalCase
- *
- * @example
- * ```typescript
- * isPascalCase('HelloWorld') // => true
- * isPascalCase('helloWorld') // => false
- * ```
- *
- * @internal This function is for internal use by the library
- */
-export default function isPascalCase(str: string): boolean;

package/dist/utils/caseDetectors/isSnakeCase.d.ts

@@ -1,14 +0,0 @@
-/**
- * Checks if a string is in snake_case format
- * @param str - The string to check
- * @returns boolean indicating if the string is in snake_case
- *
- * @example
- * ```typescript
- * isSnakeCase('hello_world') // => true
- * isSnakeCase('helloWorld') // => false
- * ```
- *
- * @internal This function is for internal use by the library
- */
-export default function isSnakeCase(str: string): boolean;

package/dist/utils/detectSingleWord.d.ts

@@ -1,37 +0,0 @@
-/**
- * Determines whether the given string qualifies as a single word.
- *
- * A string is considered a "single word" if:
- * - It does not contain any delimiters such as underscores (`_`), hyphens (`-`), or spaces.
- * - It contains only alphanumeric characters (letters and digits). Any other character (e.g., punctuation) will cause it to be considered as not a single word.
- * - For strings longer than one character:
- *    - If the entire string is lowercase, it's considered a single word.
- *    - If the string starts with an uppercase letter and the rest are lowercase, it's considered a single word.
- * - Single-character strings and empty strings are treated as a single word.
- *
- * @param {string} str - The string to check.
- * @returns {boolean} Returns `true` if the input string qualifies as a single word, otherwise returns `false`.
- *
- * @example
- * // Returns true because "hello" is a single word (all lowercase).
- * detectSingleWord("hello");
- *
- * @example
- * // Returns true because "Hello" is considered a single word (capitalized first letter only).
- * detectSingleWord("Hello");
- *
- * @example
- * // Returns false because "hello_world" contains an underscore.
- * detectSingleWord("hello_world");
- *
- * @example
- * // Returns false because "hello world" contains a space.
- * detectSingleWord("hello world");
- *
- * @example
- * // Returns false because "hello@world" contains a special character.
- * detectSingleWord("hello@world");
- *
- * @internal This function is for internal use by the library
- */
-export default function detectSingleWord(str: string): boolean;

package/dist/utils/detectStringCase.d.ts

@@ -1,17 +0,0 @@
-import { StringCase } from '../types/stringCaseTypes';
-/**
- * Detects the case format of a string
- * @param str - The string to analyze
- * @returns The detected case format, 'single' for single words, or null if format cannot be determined
- *
- * @example
- * ```typescript
- * detectStringCase('hello_world') // => 'snake'
- * detectStringCase('helloWorld') // => 'camel'
- * detectStringCase('HelloWorld') // => 'pascal'
- * detectStringCase('hello-world') // => 'kebab'
- * detectStringCase('hello') // => 'single'
- * ```
- * @internal This function is for internal use by the library
- */
-export default function detectStringCase(str: string): StringCase | 'single' | null;

package/dist/utils/prepareStringTransformation.d.ts

@@ -1,20 +0,0 @@
-import { StringCase } from '../types/stringCaseTypes';
-/**
- * Internal type used by string preparation utility
- * Not exported as it's an implementation detail
- */
-interface StringPreparationResult {
-    string: string;
-    shouldTransform: boolean;
-    sourceCase: StringCase | null;
-    singleWord: boolean;
-}
-/**
- * Prepares a string for case transformation by validating input
- * @param str - The input string to prepare
- * @returns StringPreparationResult object containing the processed parts
- * @throws {Error} If the input is not a string
- * @internal This function is for internal use by the library
- */
-export declare function prepareStringTransformation(str: string): StringPreparationResult;
-export {};

package/dist/utils/stringFormatters/camelToKebabCase.d.ts

@@ -1,14 +0,0 @@
-/**
- * Converts a camelCase string to kebab-case
- * Core transformation function without special character handling
- *
- * @param str - The camelCase string to convert
- * @returns The kebab-case transformed string
- *
- * @example
- * ```typescript
- * camelToKebabCase('helloWorld') // => 'hello-world'
- * ```
- * @internal This function is for internal use by the library
- */
-export default function camelToKebabCase(str: string): string;