diff --git a/resources/ts/hooks/use-string.tsx b/resources/ts/hooks/use-string.tsx index a0009d34..778449aa 100644 --- a/resources/ts/hooks/use-string.tsx +++ b/resources/ts/hooks/use-string.tsx @@ -6,6 +6,9 @@ interface Stringable { slug: () => Stringable; ucFirst: () => Stringable; camelCase: () => Stringable; + pascalCase: () => Stringable; + kebabCase: () => Stringable; + snakeCase: () => Stringable; upperCase: () => Stringable; lowerCase: () => Stringable; plural: () => Stringable; @@ -16,6 +19,18 @@ interface Stringable { const str = (initialValue: string): Stringable => { let value = initialValue; + // * HELPERS + + /** + * Split string into multiple segments. + * @param string string + * @returns string[] + */ + const splitIntoSegments = (string: string): string[] => + string.split(/[-_\s]+/).filter(Boolean); + + // * METHODS + return { trim: (): Stringable => { value = value.trim(); @@ -33,7 +48,83 @@ const str = (initialValue: string): Stringable => { }, camelCase: (): Stringable => { - value = value.toLowerCase().replace(/[-_\s]+(.)?/g, (_, c) => (c ? c.toUpperCase() : "")); + const segments = splitIntoSegments(value); + + // If segments are empty. + if (segments.length === 0) { + value = ""; + return str(value); + } + + // If single segment and already in camel case. + if (segments.length === 1 && /^[a-z][a-zA-Z0-9]*$/.test(value)) { + return str(value); + } + + // first segment: lower first char, preserve internals + const first = segments[0].charAt(0).toLowerCase() + segments[0].slice(1); + + // rest: uppercase first char; preserve internals if mixed case, otherwise lowercase internals + const rest = segments.slice(1).map((p) => { + if (!p) return ""; + const hasLower = /[a-z]/.test(p); + const hasUpper = /[A-Z]/.test(p); + const isMixed = hasLower && hasUpper; + const head = p.charAt(0).toUpperCase(); + const tail = p.slice(1); + return isMixed ? head + tail : head + tail.toLowerCase(); + }); + + value = [first, ...rest].join(""); + return str(value); + }, + + pascalCase: (): Stringable => { + const segments = splitIntoSegments(value); + if (segments.length === 0) { + value = ""; + return str(value); + } + + // If already Pascal-ish, keep as is + if (segments.length === 1 && /^[A-Z][a-zA-Z0-9]*$/.test(value)) { + return str(value); + } + + const converted = segments.map((p) => { + const hasLower = /[a-z]/.test(p); + const hasUpper = /[A-Z]/.test(p); + const isMixed = hasLower && hasUpper; + + if (isMixed) { + // preserve internal capitals, only uppercase first char + return p.charAt(0).toUpperCase() + p.slice(1); + } else { + // normalize (capitalize first, lowercase rest) + return p.charAt(0).toUpperCase() + p.slice(1).toLowerCase(); + } + }); + + value = converted.join(""); + return str(value); + }, + + kebabCase: (): Stringable => { + const words = value + .replace(/([a-z0-9])([A-Z])/g, "$1 $2") + .split(/[-_\s]+/) + .filter(Boolean); + value = words.map((w) => w.toLowerCase()).join("-"); + return str(value); + }, + + snakeCase: (): Stringable => { + const words = value + .replace(/([a-z0-9])([A-Z])/g, "$1 $2") + .split(/[-\s]+|_+/) + .filter(Boolean); + + value = words.map((w) => w.toLowerCase()).join("_"); return str(value); },