{"version":3,"file":"index.cjs","names":["isNonEmptyString","isPlainObject","isNonEmptyString","isPlainObject","isString","isEmptyString","isNonEmptyString","isNonEmptyString","isNumber","isString","getPreciseType","createMessage"],"sources":["../../src/strings/capitalizations/capitalizeFirst.ts","../../src/strings/capitalizations/capitalizeWords.ts","../../src/strings/sanitizations/stripHtmlTags.ts","../../src/strings/utils/getDisplayName.ts","../../src/strings/utils/getInitialsName.ts","../../src/strings/utils/replaceAt.ts"],"sourcesContent":["import { isPlainObject } from \"@/predicates/is/isPlainObject\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\n\ntype CapitalizeFirstOptions = {\n  /** If true **(default)**, the rest of the string will be converted to lowercase after capitalizing the first letter.\n   *\n   * @default true\n   */\n  lowerCaseNextRest?: boolean;\n  /** If true, the string will trimmed, default: `false`.\n   *\n   * @default false\n   */\n  trim?: boolean;\n};\n\n/** ----------------------------------------------------------\n * * ***Utility: `capitalizeFirst`.***\n * -----------------------------------------------------------\n * **Capitalizes the first letter of a string, with optionally lowercases the rest and trims whitespace.**\n *\n * ---\n * @param {string | null | undefined} string - The string to be processed.\n * @param {CapitalizeFirstOptions} [options] - Options to control behavior.\n * @param {CapitalizeFirstOptions[\"lowerCaseNextRest\"]} [options.lowerCaseNextRest=true] - If true, lowercases the rest (next first letter), default: `true`.\n * @param {CapitalizeFirstOptions[\"trim\"]} [options.trim=false] - If true, trims the string before processing, default: `false`.\n *\n * ---\n * @returns {string} The processed string, returns `\"\"` if input is `null`, `undefined`, or `not a valid string`.\n *\n * ---\n * @example\n * ```ts\n * capitalizeFirst(\" hello WORLD \");\n * // ➔ \" Hello world\"\n * capitalizeFirst(\" hello WORLD \", { trim: true });\n * // ➔ \"Hello world\"\n * capitalizeFirst(\"FOO\", { lowerCaseNextRest: false });\n * // ➔ \"FOO\"\n * capitalizeFirst(\"   foo BAR   \", { trim: true, lowerCaseNextRest: false });\n * // ➔ \"Foo BAR\"\n * ```\n * ---\n * #### ℹ️ If `null`, `undefined`, or ***`not a valid string`*** input, return `\"\"`.\n * ```ts\n * capitalizeFirst(123);\n * capitalizeFirst(null);\n * capitalizeFirst(undefined);\n * // ➔ \"\"\n * ```\n */\nexport const capitalizeFirst = (\n  string: string | null | undefined,\n  options?: CapitalizeFirstOptions\n): string => {\n  if (!isNonEmptyString(string)) return \"\";\n\n  if (!isPlainObject(options)) options = {};\n\n  const lowerCaseNextRest = options.lowerCaseNextRest !== false;\n  const trim = options.trim === true;\n\n  if (trim) string = string.trim();\n\n  return (\n    (string[0] ? string[0].toUpperCase() : \"\") +\n    (lowerCaseNextRest ? string.slice(1).toLowerCase() : string.slice(1))\n  );\n};\n","import { isPlainObject } from \"@/predicates/is/isPlainObject\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\n\ntype CapitalizeWordsOptions = {\n  /** If `true`, removes leading and trailing spaces, default `false`.\n   *\n   * @default false\n   */\n  trim?: boolean;\n  /** If `true`, collapses multiple spaces **between words** into a single space (while preserving leading/trailing spaces), default `false`.\n   *\n   * @default false\n   */\n  collapseSpaces?: boolean;\n};\n\n/** ----------------------------------------------------------\n * * ***Utility: `capitalizeWords`.***\n * -----------------------------------------------------------\n * **Capitalizes the first letter of each word in a string while converting the rest to lowercase.**\n *\n * ----\n * @param {string | null | undefined} value\n *  ***The input string to be processed.***\n *     - If `null` or `undefined`, returns an empty-string (`\"\"`).\n * @param {CapitalizeWordsOptions} [options]\n *  ***Optional settings to control the output:***\n *     - `trim`: If `true`, removes leading and trailing spaces, defaultValue: `false`.\n *     - `collapseSpaces`: If `true`, collapses multiple spaces **between words** into a single space (while preserving leading/trailing spaces), defaultValue: `false`.\n *\n * ---\n * @returns {string} A new string where each word starts with an uppercase letter\n * and the remaining letters are lowercase.\n *  - If `value` is `empty`, `null`, or `undefined`, returns an `empty-string`.\n *\n * ---\n * @example\n * ```ts\n * capitalizeWords(\"  hello   world  \");\n * // ➔ \"  Hello   World  \"\n * capitalizeWords(\"  hello   world  \", { trim: true });\n * // ➔ \"Hello   World\"\n * capitalizeWords(\"  hello   world  \", { collapseSpaces: true });\n * // ➔ \"  Hello World  \"\n * capitalizeWords(\"  hello   world  \", { trim: true, collapseSpaces: true });\n * // ➔ \"Hello World\"\n * ```\n * ---\n * #### ℹ️ If `null`, `undefined`, or ***`not a valid string`*** input, return `\"\"`.\n * ```ts\n * capitalizeWords(123);\n * capitalizeWords(null);\n * capitalizeWords(undefined);\n * // ➔ \"\"\n * ```\n */\nexport const capitalizeWords = (\n  value: string | null | undefined,\n  options?: CapitalizeWordsOptions\n): string => {\n  if (!isNonEmptyString(value)) return \"\";\n\n  let result = value;\n\n  if (!isPlainObject(options)) options = {};\n\n  const collapseSpaces = options.collapseSpaces === true;\n  const trim = options.trim === true;\n\n  if (trim) result = result.trim();\n\n  if (collapseSpaces) {\n    const leadingSpaces = result.match(/^\\s*/)?.[0] ?? \"\";\n    const trailingSpaces = result.match(/\\s*$/)?.[0] ?? \"\";\n    result = result.trim().replace(/\\s+/g, \" \");\n    result = `${leadingSpaces}${result}${trailingSpaces}`;\n  }\n\n  return result\n    .toLowerCase()\n    .split(\" \")\n    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))\n    .join(\" \");\n};\n","import type { Extends } from \"@rzl-zone/ts-types-plus\";\nimport { isString } from \"@/predicates/is/isString\";\nimport { isEmptyString } from \"@/predicates/is/isEmptyString\";\n\n/** ----------------------------------------------------------\n * * ***Utility: `stripHtmlTags`.***\n * -----------------------------------------------------------\n * **This function removes valid HTML tags (including nested and self-closing ones)\n * by replacing them with spaces, then collapses multiple whitespaces into a single space.**\n *\n * ---\n * - **It handles the following cases:**\n *     - If the input is not a string (`null`, `undefined`, or any non-string), it is returned as undefined.\n *     - If the input is an empty or whitespace-only string, it returns an empty string (`\"\"`).\n *     - Otherwise, it returns the cleaned string with tags removed and normalized whitespace.\n *\n * ---\n * @template T - Input string type (string | null | undefined).\n *\n * ---\n * @param {string | null | undefined} input - A string potentially containing HTML tags.\n *\n * ---\n * @returns {string | undefined} Cleaned string if input is string, or original input otherwise.\n *\n * ---\n * @example\n * stripHtmlTags(\"<p>Hello</p>\");\n * // ➔ \"Hello\"\n * stripHtmlTags(\"<div><b>Bold</b> text</div>\");\n * // ➔ \"Bold text\"\n * stripHtmlTags(\"Line<br/>Break\");\n * // ➔ \"Line Break\"\n * stripHtmlTags(\"2 < 5 and 5 > 2\");\n * // ➔ \"2 < 5 and 5 > 2\"\n * stripHtmlTags(\"\");\n * // ➔ \"\"\n * stripHtmlTags(\"   \");\n * // ➔ \"\"\n * stripHtmlTags(null);\n * // ➔ undefined\n * stripHtmlTags(undefined);\n * // ➔ undefined\n */\nexport function stripHtmlTags(input: string): string;\nexport function stripHtmlTags<T>(\n  input: T\n): Extends<string, T> extends true ? string | undefined : undefined;\nexport function stripHtmlTags(input: unknown) {\n  if (!isString(input)) return undefined;\n\n  if (isEmptyString(input)) return \"\";\n\n  return input\n    .replace(/<\\/?[a-zA-Z][^<>]*\\/?>/g, \" \")\n    .replace(/\\s+/g, \" \")\n    .trim();\n}\n","import { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\nimport { capitalizeWords } from \"../capitalizations\";\n\n/**\n * Configuration options for the `getDisplayName` utility.\n */\ntype GetDisplayNameOptions = {\n  /**\n   * If `true`, extracts the second display word from the last word (for names with 3+ words), defaultValue: `true` (e.g., \"John Michael Doe\" -> \"John Doe\").\n   *\n   * @default true\n   */\n  useLastWord?: boolean;\n  /**\n   * If `true`, forces the first letter of each word to be uppercase and the rest lowercase.\n   * If `false`, returns the words in their original casing.\n   *\n   * @default true\n   */\n  capitalizeFirst?: boolean;\n};\n\n/** ----------------------------------------------------------\n * * ***Utility: `getDisplayName`.***\n * -----------------------------------------------------------\n * **Formats a full name into a cleaner display name.**\n *\n * ---\n * - **Behavior:**\n *      - For names with 3+ words, returns the first and last word (by default), unless `useLastWord` is false.\n *      - For single or two-word names, returns the formatted words.\n *      - Applies Title Case formatting by default (`capitalizeFirst`), converting \"JOHN DOE\" to \"John Doe\".\n *      - For `empty`, `null`, `undefined` or `whitespace-only input`, returns an empty string (`\"\"`).\n *\n * ---\n * @param {string | null | undefined} name - The name string to format.\n * @param {GetDisplayNameOptions} [options] - Configuration options for display formatting.\n *\n * ---\n * @returns {string} The formatted display name.\n *\n * ---\n * @example\n * // Standard two-word names:\n * getDisplayName(\"john doe\");\n * // ➔ \"John Doe\"\n * getDisplayName(\"JOHN DOE\");\n * // ➔ \"John Doe\"\n *\n * // Names with three or more words:\n * getDisplayName(\"john michael doe\");\n * // ➔ \"John Doe\" (Default: useLastWord is true)\n * getDisplayName(\"john michael doe\", { useLastWord: false });\n * // ➔ \"John Michael\"\n *\n * // Single word or single letter:\n * getDisplayName(\"jo\");\n * // ➔ \"Jo\"\n * getDisplayName(\"j\");\n * // ➔ \"J\"\n *\n * // Disabling auto-capitalization:\n * getDisplayName(\"JOHN DOE\", { capitalizeFirst: false });\n * // ➔ \"JOHN DOE\"\n * getDisplayName(\"john michael doe\", { useLastWord: false, capitalizeFirst: false });\n * // ➔ \"john michael\"\n *\n * // Handling messy whitespace:\n * getDisplayName(\"   john    michael   doe   \");\n * // ➔ \"John Doe\"\n *\n * // Handling empty or invalid inputs:\n * getDisplayName(\"\");\n * // ➔ \"\"\n * getDisplayName(null);\n * // ➔ \"\"\n */\nexport const getDisplayName = (\n  name: string | null | undefined,\n  options?: GetDisplayNameOptions\n): string => {\n  // Assumes isNonEmptyString() is defined elsewhere in your codebase\n  if (!isNonEmptyString(name)) return \"\";\n\n  const { useLastWord = true, capitalizeFirst = true } = options || {};\n\n  // Trim spaces and remove duplicate spaces\n  name = name.replace(/\\s+/g, \" \").trim();\n\n  const nameParts = name.split(\" \");\n\n  // Helper function to format a single word safely\n  const formatWord = (word: string | undefined): string => {\n    if (!word) return \"\";\n    if (!capitalizeFirst) return word;\n\n    return capitalizeWords(word, { trim: true, collapseSpaces: true });\n  };\n\n  // Handle single-word names\n  if (nameParts.length === 1) {\n    return formatWord(nameParts[0]);\n  }\n\n  // Handle names with two or more words\n  const firstWord = formatWord(nameParts[0]);\n  const secondWordIndex = useLastWord ? nameParts.length - 1 : 1;\n  const secondWord = formatWord(nameParts[secondWordIndex]);\n\n  return `${firstWord} ${secondWord}`;\n};\n","import { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\n\n/**\n * Configuration options for the `getInitialsName` utility.\n */\ntype GetInitialsOptions = {\n  /**\n   * If `true`, extracts the second initial from the last word (for names with 2+ words), defaultValue: `true`.\n   *\n   * @default true\n   */\n  useLastWord?: boolean;\n  /**\n   * If `true`, the second letter will be lowercase (for single-word names), defaultValue: `true`.\n   *\n   * @default true\n   */\n  lowercaseSecondLetter?: boolean;\n};\n\n/** ----------------------------------------------------------\n * * ***Utility: `getInitialsName`.***\n * -----------------------------------------------------------\n * **Extracts initials from the given name string.**\n *\n * ---\n * - **Behavior:**\n *      - For names with two or more words, returns the first letter of the first word,\n *        and the second letter from the last word (by default), unless `useLastWord` is false.\n *      - For a single word with 2+ characters, returns the first two letters. The second\n *        letter will be lowercase (by default), unless `lowercaseSecondLetter` is false.\n *      - For a single character, returns that character in uppercase.\n *      - For `empty`, `null`, `undefined` or `whitespace-only input`, returns an empty string (`\"\"`).\n *\n * ---\n * @param {string | null | undefined} name - The name to extract initials from.\n * @param {GetInitialsOptions} [options] - Configuration options for initial extraction.\n *\n * ---\n * @returns {string} The extracted initials.\n *\n * ---\n * @example\n * // Single-word names:\n * getInitialsName(\"Alice\");\n * // ➔ \"Al\" (Default: lowercaseSecondLetter is true)\n * getInitialsName(\"Alice\", { lowercaseSecondLetter: false });\n * // ➔ \"AL\"\n *\n * // Two-word names:\n * getInitialsName(\"John Ronald\");\n * // ➔ \"JR\"\n *\n * // Three or more words:\n * getInitialsName(\"John Ronald Donal\");\n * // ➔ \"JD\" (Default: useLastWord is true)\n * getInitialsName(\"John Ronald Donal\", { useLastWord: false });\n * // ➔ \"JR\"\n *\n * // Edge cases:\n * getInitialsName(\"X\");\n * // ➔ \"X\"\n * getInitialsName(\"   John    Doe   \");\n * // ➔ \"JD\"\n * getInitialsName(null);\n * // ➔ \"\"\n */\nexport const getInitialsName = (\n  name: string | null | undefined,\n  options?: GetInitialsOptions\n): string => {\n  // Assumes isNonEmptyString() is defined elsewhere in your codebase\n  if (!isNonEmptyString(name)) return \"\";\n\n  const { useLastWord = true, lowercaseSecondLetter = true } = options || {};\n\n  // Trim spaces and remove duplicate spaces\n  name = name.replace(/\\s+/g, \" \").trim();\n\n  const nameParts = name.split(\" \");\n\n  // Handle names with two or more words\n  if (nameParts.length > 1) {\n    const firstInitial = nameParts[0]?.[0] ?? \"\";\n    const secondWordIndex = useLastWord ? nameParts.length - 1 : 1;\n    const secondInitial = nameParts[secondWordIndex]?.[0] ?? \"\";\n\n    return (firstInitial + secondInitial).toUpperCase();\n  }\n\n  // Handle single-word names with more than one character\n  if (name.length > 1) {\n    const firstLetter = name[0]?.toUpperCase() ?? \"\";\n    const secondLetter = lowercaseSecondLetter\n      ? (name[1]?.toLowerCase() ?? \"\")\n      : (name[1]?.toUpperCase() ?? \"\");\n\n    return firstLetter + secondLetter;\n  }\n\n  // Handle single-character names\n  return name[0]?.toUpperCase() ?? \"\";\n};\n","import { createMessage } from \"@/_private/logger\";\n\nimport { isNumber } from \"@/predicates/is/isNumber\";\nimport { isString } from \"@/predicates/is/isString\";\nimport { getPreciseType } from \"@/predicates/type/getPreciseType\";\n\n/** ----------------------------------------------------------\n *  * ***Utility: `replaceAt`.***\n * -----------------------------------------------------------\n * **Replaces exactly one character at the specified index in the original string\n * with the provided `replaceTo` string.**\n *\n * ---\n * - **Behavior:**\n *      - If `replaceTo` has more than one character,\n *        the result will expand accordingly.\n *\n * ---\n * @param {number} index - The starting index where the replacement should occur.\n * @param {string} originalString - The original string to modify.\n * @param {string} replaceTo - The string to insert at the specified index.\n *\n * ---\n * @returns {string} The modified string with the replacement applied.\n *\n * ---\n * @example\n * replaceAt(3, \"hello\", \"X\");\n * // ➔ \"helXo\"\n * replaceAt(1, \"world\", \"AB\");\n * // ➔ \"wABrld\"\n * replaceAt(0, \"cat\", \"br\");\n * // ➔ \"brat\"\n * replaceAt(2, \"12345\", \"-\");\n * // ➔ \"12-45\"\n * replaceAt(4, \"ABCDE\", \"Z\");\n * // ➔ \"ABCDZ\"\n *\n * // ❌ Examples that throw:\n * replaceAt(10, \"short\", \"X\");\n * // ➔ ❌ RangeError: First parameter (`index`) is out of range from second parameter `originalString`.\n * replaceAt(-1, \"test\", \"X\");\n * // ➔ ❌ RangeError: First parameter (`index`) is out of range from second parameter `originalString`.\n * replaceAt(\"1\", \"test\", \"X\");\n * // ➔ ❌ TypeError: First parameter `index` must be of type `number`, second parameter `originalString` and third parameter `replaceTo` must be of type `string`, but received: \"['index': `string`,...].\"\n * replaceAt(2, null, \"X\");\n * // ➔ ❌ TypeError: First parameter `index` must be of type `number`, second parameter `originalString` and third parameter `replaceTo` must be of type `string`, but received: \"['index': `string`,...].\"\n */\nexport const replaceAt = (\n  index: number,\n  originalString: string,\n  replaceTo: string\n): string => {\n  if (!isNumber(index) || !isString(replaceTo) || !isString(originalString)) {\n    throw new TypeError(\n      errorMsg(\n        `First parameter (\\`index\\`) must be of type \\`number\\`, second parameter (\\`originalString\\`) and third parameter (\\`replaceTo\\`) must be of type \\`string\\`, but received: \"['index': \\`${getPreciseType(\n          index\n        )}\\`, 'originalString': \\`${getPreciseType(\n          originalString\n        )}\\`, 'replaceTo': \\`${getPreciseType(replaceTo)}\\`]\".`\n      )\n    );\n  }\n\n  // Handle edge cases\n  if (index < 0 || index >= originalString.length) {\n    throw new RangeError(\n      errorMsg(\n        \"First parameter (`index`) is out of range from second parameter (`originalString`).\"\n      )\n    );\n  }\n\n  return (\n    originalString.slice(0, index) + // Extract before the index\n    replaceTo + // Insert replacement\n    originalString.slice(index + 1) // Extract after replacement\n  );\n};\n\n/**\n * @internal ***`Not part of the public API.`***\n */\nconst errorMsg = (msg: string) => createMessage(\"replaceAt\", msg);\n"],"mappings":"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"}