toolbox-x 1.0.0

package/dist/case-C-S-b5YP.d.cts

@@ -0,0 +1,327 @@
+/**
+ * Copyright 2026 - present Nazmul Hassan
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { B as TitleCase, I as SentenceCase, L as SnakeCase, M as PascalSnakeCase, N as PathCase, T as DotCase, V as TrainCase, f as CamelCase, g as ConstantCase, j as PascalCase, k as KebabCase, m as CaseFormat, p as CapitalizeOptions, z as StringCaseOptions } from "./string-CsNsm_65.cjs";
+
+//#region src/string/case.d.ts
+/**
+ * * Converts a string to a specified case format with advanced handling for word boundaries, punctuation, acronyms, and Unicode characters.
+ *
+ * @remarks
+ * - This function is Unicode-aware, treats non-alphanumeric characters (spaces, underscores, dots, slashes, etc.) as word boundaries, and optionally preserves internal acronyms.
+ * - `Title Case` formatting respects small words such as prepositions, articles, conjunctions, and auxiliary verbs (defined in `LOWERCASE`) — these are not capitalized unless they appear at the start or end of the string.
+ * - Leading and trailing punctuation (non-letter/number characters) is preserved in the result.
+ *
+ * @param value - The input string to convert. Can contain letters, numbers, punctuation,
+ *   spaces, underscores, dashes, etc.
+ * @param format - The target case format:
+ *   - `'camelCase'` → camelCase (e.g., `myVariableName`)
+ *   - `'PascalCase'` → PascalCase (e.g., `MyVariableName`)
+ *   - `'snake_case'` → snake_case (e.g., `my_variable_name`)
+ *   - `'kebab-case'` → kebab-case (e.g., `my-variable-name`)
+ *   - `'Title Case'` → Title Case (e.g., `My Variable Name`)
+ *   - `'Sentence case'` → Sentence case (e.g., `My variable name`)
+ *   - `'lowercase'` → all lowercase [ It is recommended to use built-in string method `string.toLowerCase()` ]
+ *   - `'UPPERCASE'` → all uppercase [ It is recommended to use built-in string method `string.toUpperCase()` ]
+ * @param options - Optional configuration options for more control.
+ *
+ * @returns The converted string, with leading/trailing punctuation preserved.
+ *
+ * @example
+ * // Basic usage
+ * convertStringCase('my-example_string', 'camelCase');
+ * // Returns: 'myExampleString'
+ *
+ * convertStringCase('my-example_string', 'snake_case');
+ * // Returns: 'my_example_string'
+ *
+ * convertStringCase('my-example_string', 'kebab-case');
+ * // Returns: 'my-example-string'
+ *
+ * convertStringCase('my example string', 'Title Case');
+ * // Returns: 'My Example String'
+ *
+ * convertStringCase('my example string', 'Sentence case');
+ * // Returns: 'My example string'
+ *
+ * convertStringCase('My example String', 'lowercase');
+ * // Returns: 'my example string'
+ *
+ * convertStringCase('my example string', 'UPPERCASE');
+ * // Returns: 'MY EXAMPLE STRING'
+ *
+ * @example
+ * // Preserve acronyms
+ * convertStringCase('get API response', 'camelCase', { preserveAcronyms: true });
+ * // Returns: 'getAPIResponse'
+ *
+ * convertStringCase('get API response', 'PascalCase', { preserveAcronyms: true });
+ * // Returns: 'GetAPIResponse'
+ *
+ * convertStringCase('the API of things', 'Title Case', { preserveAcronyms: true });
+ * // Returns: 'The API of Things'
+ *
+ * @example
+ * // Leading/trailing punctuation is preserved
+ * convertStringCase('++hello_world++', 'PascalCase');
+ * // Returns: '++HelloWorld++'
+ *
+ * @example
+ * // Dashes are preserved in Title Case
+ * convertStringCase('xml-http_request', 'Title Case');
+ * // Returns: 'Xml-http Request'
+ *
+ * @example
+ * // Empty string returns empty
+ * convertStringCase('', 'camelCase');
+ * // Returns: ''
+ *
+ * @example
+ * // Single token is capitalized properly
+ * convertStringCase('api', 'PascalCase');
+ * // Returns: 'Api'
+ */
+declare function convertStringCase(value: string, format: CaseFormat, options?: StringCaseOptions): string;
+/**
+ * * Utility to convert the first letter of any string to uppercase and the rest lowercase (unless specified).
+ * * Handles surrounding symbols like quotes or parentheses.
+ *
+ * @param string String to be capitalized.
+ * @param options Options to customize the capitalization.
+ * @returns Capitalized string or fully uppercased string depending on `capitalizeAll` option.
+ */
+declare function capitalizeString(string: string, options?: CapitalizeOptions): string;
+/**
+ * * Converts a string into `camelCase`, using the optional custom delimiters in addition to the default delimiters.
+ *
+ * @remarks
+ * - This utility returns appropriate type IntelliSense with string literal. For general purpose use {@link convertStringCase}.
+ * - At the type level, TypeScript supports `up to 45 characters` for reliable literal inference.
+ *   - This limitation does not affect runtime behavior but shows TypeScript compiler error.
+ * - Use it for short literal strings (`up to 45 characters`) for best performance.
+ * - It does not handle ACRONYMS properly, so be cautious when the string has ACRONYMS or use {@link convertStringCase}.
+ * - Custom delimiters are merged with the default set: `space`, `.`, `-`, `_`, `/`.
+ *
+ * @example
+ * toCamelCase("hello world")            // "helloWorld"
+ * toCamelCase("my-awesome_string")      // "myAwesomeString"
+ * toCamelCase("value*with+custom", "*+") // "valueWithCustom"
+ *
+ * @param str The input string to convert.
+ * @param del Additional delimiter characters to recognize.
+ * @returns The `camelCase` formatted string.
+ */
+declare function toCamelCase<Str extends string, Del extends string = ''>(str: Str, ...del: Del[]): CamelCase<Str, Del>;
+/**
+ * * Converts a string into `PascalCase`, using the optional custom delimiters in addition to the default delimiters.
+ *
+ * @remarks
+ * - This utility returns appropriate type IntelliSense with string literal. For general purpose use {@link convertStringCase}.
+ * - At the type level, TypeScript supports `up to 45 characters` for reliable literal inference.
+ *   - This limitation does not affect runtime behavior but shows TypeScript compiler error.
+ * - Use it for short literal strings (`up to 45 characters`) for best performance.
+ * - It does not handle ACRONYMS properly, so be cautious when the string has ACRONYMS or use {@link convertStringCase}.
+ * - Custom delimiters are merged with the default set: `space`, `.`, `-`, `_`, `/`.
+ *
+ * @example
+ * toPascalCase("hello world")            // "HelloWorld"
+ * toPascalCase("my-awesome_string")      // "MyAwesomeString"
+ * toPascalCase("value*with+custom", "*+") // "ValueWithCustom"
+ *
+ * @param str The input string to convert.
+ * @param del Additional delimiter characters to recognize.
+ * @returns The `PascalCase` formatted string.
+ */
+declare function toPascalCase<Str extends string, Del extends string = ''>(str: Str, ...del: Del[]): PascalCase<Str, Del>;
+/**
+ * * Converts a string into `snake_case`, using the optional custom delimiters in addition to the default delimiters.
+ *
+ * @remarks
+ * - This utility returns appropriate type IntelliSense with string literal. For general purpose use {@link convertStringCase}.
+ * - At the type level, TypeScript supports `up to 45 characters` for reliable literal inference.
+ *   - This limitation does not affect runtime behavior but shows TypeScript compiler error.
+ * - Use it for short literal strings (`up to 45 characters`) for best performance.
+ * - Custom delimiters are merged with the default set: `space`, `.`, `-`, `_`, `/`.
+ *
+ * @example
+ * toSnakeCase("hello world")            // "hello_world"
+ * toSnakeCase("my-awesome_string")      // "my_awesome_string"
+ * toSnakeCase("value*with+custom", "*+") // "value_with_custom"
+ *
+ * @param str The input string to convert.
+ * @param del Additional delimiter characters to recognize.
+ * @returns The `snake_case` formatted string.
+ */
+declare function toSnakeCase<Str extends string, Del extends string = ''>(str: Str, ...del: Del[]): SnakeCase<Str, Del>;
+/**
+ * * Converts a string into `kebab-case`, using the optional custom delimiters in addition to the default delimiters.
+ *
+ * @remarks
+ * - This utility returns appropriate type IntelliSense with string literal. For general purpose use {@link convertStringCase}.
+ * - At the type level, TypeScript supports `up to 45 characters` for reliable literal inference.
+ *   - This limitation does not affect runtime behavior but shows TypeScript compiler error.
+ * - Use it for short literal strings (`up to 45 characters`) for best performance.
+ * - Custom delimiters are merged with the default set: `space`, `.`, `-`, `_`, `/`.
+ *
+ * @example
+ * toKebabCase("hello world")            // "hello-world"
+ * toKebabCase("my-awesome_string")      // "my-awesome-string"
+ * toKebabCase("value*with+custom", "*+") // "value-with-custom"
+ *
+ * @param str The input string to convert.
+ * @param del Additional delimiter characters to recognize.
+ * @returns The `kebab-case` formatted string.
+ */
+declare function toKebabCase<Str extends string, Del extends string = ''>(str: Str, ...del: Del[]): KebabCase<Str, Del>;
+/**
+ * * Converts a string into `Train-Case`, using the optional custom delimiters in addition to the default delimiters.
+ *
+ * @remarks
+ * - At the type level, TypeScript supports `up to 45 characters` for reliable literal inference.
+ *   - This limitation does not affect runtime behavior but shows TypeScript compiler error.
+ * - Use it for short literal strings (`up to 45 characters`) for best performance.
+ * - Custom delimiters are merged with the default set: `space`, `.`, `-`, `_`, `/`.
+ *
+ * @example
+ * toTrainCase("hello world")            // "Hello-World"
+ * toTrainCase("my-awesome_string")      // "My-Awesome-String"
+ * toTrainCase("value*with+custom", "*+") // "Value-With-Custom"
+ *
+ * @param str The input string to convert.
+ * @param del Additional delimiter characters to recognize.
+ * @returns The `Train-Case` formatted string.
+ */
+declare function toTrainCase<Str extends string, Del extends string = ''>(str: Str, ...del: Del[]): TrainCase<Str, Del>;
+/**
+ * * Converts a string into `dot.case`, using the optional custom delimiters in addition to the default delimiters.
+ *
+ * @remarks
+ * - At the type level, TypeScript supports `up to 45 characters` for reliable literal inference.
+ *   - This limitation does not affect runtime behavior but shows TypeScript compiler error.
+ * - Use it for short literal strings (`up to 45 characters`) for best performance.
+ * - Custom delimiters are merged with the default set: `space`, `.`, `-`, `_`, `/`.
+ *
+ * @example
+ * toDotCase("hello world")            // "hello.world"
+ * toDotCase("my-awesome_string")      // "my.awesome.string"
+ * toDotCase("value*with+custom", "*+") // "value.with.custom"
+ *
+ * @param str The input string to convert.
+ * @param del Additional delimiter characters to recognize.
+ * @returns The `dot.case` formatted string.
+ */
+declare function toDotCase<Str extends string, Del extends string = ''>(str: Str, ...del: Del[]): DotCase<Str, Del>;
+/**
+ * * Converts a string into `path/case`, using the optional custom delimiters in addition to the default delimiters.
+ *
+ * @remarks
+ * - At the type level, TypeScript supports `up to 45 characters` for reliable literal inference.
+ *   - This limitation does not affect runtime behavior but shows TypeScript compiler error.
+ * - Use it for short literal strings (`up to 45 characters`) for best performance.
+ * - Custom delimiters are merged with the default set: `space`, `.`, `-`, `_`, `/`.
+ *
+ * @example
+ * toPathCase("hello world")            // "hello/world"
+ * toPathCase("my-awesome_string")      // "my/awesome/string"
+ * toPathCase("value*with+custom", "*+") // "value/with/custom"
+ *
+ * @param str The input string to convert.
+ * @param del Additional delimiter characters to recognize.
+ * @returns The `path/case` formatted string.
+ */
+declare function toPathCase<Str extends string, Del extends string = ''>(str: Str, ...del: Del[]): PathCase<Str, Del>;
+/**
+ * * Converts a string into `CONSTANT_CASE`, using the optional custom delimiters in addition to the default delimiters.
+ *
+ * @remarks
+ * - At the type level, TypeScript supports `up to 45 characters` for reliable literal inference.
+ *   - This limitation does not affect runtime behavior but shows TypeScript compiler error.
+ * - Use it for short literal strings (`up to 45 characters`) for best performance.
+ * - Custom delimiters are merged with the default set: `space`, `.`, `-`, `_`, `/`.
+ *
+ * @example
+ * toConstantCase("hello world")            // "HELLO_WORLD"
+ * toConstantCase("my-awesome_string")      // "MY_AWESOME_STRING"
+ * toConstantCase("value*with+custom", "*+") // "VALUE_WITH_CUSTOM"
+ *
+ * @param str The input string to convert.
+ * @param del Additional delimiter characters to recognize.
+ * @returns The `CONSTANT_CASE` formatted string.
+ */
+declare function toConstantCase<Str extends string, Del extends string = ''>(str: Str, ...del: Del[]): ConstantCase<Str, Del>;
+/**
+ * * Converts a string into `Pascal_Snake_Case`, using the optional custom delimiters in addition to the default delimiters.
+ *
+ * @remarks
+ * - At the type level, TypeScript supports `up to 45 characters` for reliable literal inference.
+ *   - This limitation does not affect runtime behavior but shows TypeScript compiler error.
+ * - Use it for short literal strings (`up to 45 characters`) for best performance.
+ * - Custom delimiters are merged with the default set: `space`, `.`, `-`, `_`, `/`.
+ *
+ * @example
+ * toPascalSnakeCase("hello world")            // "Hello_World"
+ * toPascalSnakeCase("my-awesome_string")      // "My_Awesome_String"
+ * toPascalSnakeCase("value*with+custom", "*+") // "Value_With_Custom"
+ *
+ * @param str The input string to convert.
+ * @param del Additional delimiter characters to recognize.
+ * @returns The `Pascal_Snake_Case` formatted string.
+ */
+declare function toPascalSnakeCase<Str extends string, Del extends string = ''>(str: Str, ...del: Del[]): PascalSnakeCase<Str, Del>;
+/**
+ * * Converts a string into `Title Case`, using the optional custom delimiters in addition to the default delimiters.
+ *
+ * @remarks
+ * - This utility returns appropriate type IntelliSense with string literal. For general purpose use {@link convertStringCase}.
+ * - At the type level, TypeScript supports `up to 45 characters` for reliable literal inference.
+ *   - This limitation does not affect runtime behavior but shows TypeScript compiler error.
+ * - Use it for short literal strings (`up to 45 characters`) for best performance.
+ * - It does not handle ACRONYMS properly, so be cautious when the string has ACRONYMS or use {@link convertStringCase}.
+ * - Custom delimiters are merged with the default set: `space`, `.`, `-`, `_`, `/`.
+ *
+ * @example
+ * toTitleCase("hello world")            // "Hello World"
+ * toTitleCase("my-awesome_string")      // "My Awesome String"
+ * toTitleCase("value*with+custom", "*+") // "Value with Custom"
+ *
+ * @param str The input string to convert.
+ * @param del Additional delimiter characters to recognize.
+ * @returns The `Title Case` formatted string.
+ */
+declare function toTitleCase<Str extends string, Del extends string = ''>(str: Str, ...del: Del[]): TitleCase<Str, Del>;
+/**
+ * * Converts a string into `Sentence case`, using the optional custom delimiters in addition to the default delimiters.
+ *
+ * @remarks
+ * - This utility returns appropriate type IntelliSense with string literal. For general purpose use {@link convertStringCase}.
+ * - At the type level, TypeScript supports `up to 45 characters` for reliable literal inference.
+ *   - This limitation does not affect runtime behavior but shows TypeScript compiler error.
+ * - Use it for short literal strings (`up to 45 characters`) for best performance.
+ * - It does not handle ACRONYMS properly, so be cautious when the string has ACRONYMS or use {@link convertStringCase}.
+ * - Custom delimiters are merged with the default set: `space`, `.`, `-`, `_`, `/`.
+ *
+ * @example
+ * toSentenceCase("hello world")            // "Hello world"
+ * toSentenceCase("my-awesome_string")      // "My awesome string"
+ * toSentenceCase("value*with+custom", "*+") // "Value with custom"
+ *
+ * @param str The input string to convert.
+ * @param del Additional delimiter characters to recognize.
+ * @returns The `Sentence case` formatted string.
+ */
+declare function toSentenceCase<Str extends string, Del extends string = ''>(str: Str, ...del: Del[]): SentenceCase<Str, Del>;
+//#endregion
+export { toDotCase as a, toPascalSnakeCase as c, toSnakeCase as d, toTitleCase as f, toConstantCase as i, toPathCase as l, convertStringCase as n, toKebabCase as o, toTrainCase as p, toCamelCase as r, toPascalCase as s, capitalizeString as t, toSentenceCase as u };