string-tuner 1.0.3 → 1.0.5

package/dist/index.d.ts

@@ -1,14 +1,193 @@
-declare const st: {
-    capitalize: (str: string, fullSentence?: boolean) => string | undefined;
+/**
+ * Capitalizes a string or sentence
+ * @param str - The string to capitalize
+ * @param fullSentence - If true, capitalizes each word in the sentence. If false, only capitalizes the first character
+ * @returns The capitalized string, or empty string if input is falsy
+ * @example
+ * transform.capitalize('hello world') // 'Hello World'
+ * transform.capitalize('hello world', false) // 'Hello world'
+ */
+declare const capitalize: (str: string, fullSentence?: boolean) => string;
+/**
+ * String transformation utilities for converting strings to different formats and cases
+ * @property capitalize - Capitalizes a string or sentence
+ * @property camel - Converts to camelCase
+ * @property kebab - Converts to kebab-case
+ * @property pascal - Converts to PascalCase
+ * @property snake - Converts to snake_case
+ * @property snakeScream - Converts to SCREAMING_SNAKE_CASE
+ * @property reverse - Reverses a string
+ * @property slugify - Creates URL-friendly slugs
+ * @example
+ * transform.capitalize('hello world') // 'Hello World'
+ * transform.camel('hello world') // 'helloWorld'
+ * transform.kebab('helloWorld') // 'hello-world'
+ * transform.pascal('hello-world') // 'HelloWorld'
+ * transform.snake('helloWorld') // 'hello_world'
+ * transform.snakeScream('hello world') // 'HELLO_WORLD'
+ * transform.reverse('hello') // 'olleh'
+ * transform.slugify('Hello World!') // 'hello-world'
+ */
+declare const transform: {
+    capitalize: (str: string, fullSentence?: boolean) => string;
+    camel: (str: string) => string;
+    kebab: (str: string) => string;
+    pascal: (str: string) => string;
+    snake: (str: string) => string;
+    snakeScream: (str: string) => string;
+    reverse: (str: string) => string;
+    slugify: (str: string) => string;
+};
+declare const validate: {
+    email: (str: string, customRegex?: RegExp) => boolean;
+    url: (str: string, customRegex?: RegExp) => boolean;
+    phone: (str: string, customRegex?: RegExp) => boolean;
+};
+declare const edit: {
     trim: (str: string, maxLength?: number, trimChar?: string) => string;
+    repeat: (str: string, count: number) => string;
+    pad: (str: string, length: number, char?: string, position?: "start" | "end" | "both") => string;
+    wrap: (str: string, wrapper: string | {
+        start: string;
+        end: string;
+    }) => string;
+    unwrap: (str: string, wrapper: string | {
+        start: string;
+        end: string;
+    }) => string;
     prefix: (pf: string) => {
+        /**
+         * Adds the prefix to a string if it doesn't already start with it
+         * @param str - The string to add prefix to
+         * @returns The string with prefix, or empty string if input is falsy
+         */
         add: (str: string | undefined) => string;
+        /**
+         * Removes the prefix from a string if it starts with it
+         * @param str - The string to remove prefix from
+         * @returns The string without prefix, or empty string if input is falsy
+         */
         remove: (str: string | undefined) => string;
     };
     suffix: (sf: string) => {
+        /**
+         * Adds the suffix to a string if it doesn't already end with it
+         * @param str - The string to add suffix to
+         * @returns The string with suffix, or empty string if input is falsy
+         */
         add: (str: string | undefined) => string;
+        /**
+         * Removes the suffix from a string if it ends with it
+         * @param str - The string to remove suffix from
+         * @returns The string without suffix, or empty string if input is falsy
+         */
         remove: (str: string | undefined) => string;
     };
+    initials: (str: string, maxInitials?: number) => string;
+};
+declare const clean: {
+    whitespace: (str: string) => string;
+    normalizeWhitespace: (str: string) => string;
+    html: (str: string) => string;
+    escapeHtml: (str: string) => string;
+    unescapeHtml: (str: string) => string;
+};
+declare const format: {
+    mask: (str: string, visibleChars?: number, maskChar?: string) => string;
+    highlight: (str: string, search: string, wrapper?: string | {
+        start: string;
+        end: string;
+    }, caseSensitive?: boolean) => string;
+    quote: (type?: "single" | "double" | "backtick") => {
+        /**
+         * Adds quotes to a string
+         * @param str - The string to quote
+         * @returns The quoted string
+         */
+        add: (str: string) => string;
+        /**
+         * Removes quotes from a string
+         * @param str - The string to unquote
+         * @returns The unquoted string
+         */
+        remove: (str: string) => string;
+    };
+    bracket: (type?: "round" | "square" | "curly" | "angle") => {
+        /**
+         * Adds brackets to a string
+         * @param str - The string to wrap
+         * @returns The bracketed string
+         */
+        add: (str: string) => string;
+        /**
+         * Removes brackets from a string
+         * @param str - The string to unwrap
+         * @returns The unbracketted string
+         */
+        remove: (str: string) => string;
+    };
+};
+
+declare const st: {
+    transform: {
+        capitalize: (str: string, fullSentence?: boolean) => string;
+        camel: (str: string) => string;
+        kebab: (str: string) => string;
+        pascal: (str: string) => string;
+        snake: (str: string) => string;
+        snakeScream: (str: string) => string;
+        reverse: (str: string) => string;
+        slugify: (str: string) => string;
+    };
+    validate: {
+        email: (str: string, customRegex?: RegExp) => boolean;
+        url: (str: string, customRegex?: RegExp) => boolean;
+        phone: (str: string, customRegex?: RegExp) => boolean;
+    };
+    edit: {
+        trim: (str: string, maxLength?: number, trimChar?: string) => string;
+        repeat: (str: string, count: number) => string;
+        pad: (str: string, length: number, char?: string, position?: "start" | "end" | "both") => string;
+        wrap: (str: string, wrapper: string | {
+            start: string;
+            end: string;
+        }) => string;
+        unwrap: (str: string, wrapper: string | {
+            start: string;
+            end: string;
+        }) => string;
+        prefix: (pf: string) => {
+            add: (str: string | undefined) => string;
+            remove: (str: string | undefined) => string;
+        };
+        suffix: (sf: string) => {
+            add: (str: string | undefined) => string;
+            remove: (str: string | undefined) => string;
+        };
+        initials: (str: string, maxInitials?: number) => string;
+    };
+    clean: {
+        whitespace: (str: string) => string;
+        normalizeWhitespace: (str: string) => string;
+        html: (str: string) => string;
+        escapeHtml: (str: string) => string;
+        unescapeHtml: (str: string) => string;
+    };
+    format: {
+        mask: (str: string, visibleChars?: number, maskChar?: string) => string;
+        highlight: (str: string, search: string, wrapper?: string | {
+            start: string;
+            end: string;
+        }, caseSensitive?: boolean) => string;
+        quote: (type?: "single" | "double" | "backtick") => {
+            add: (str: string) => string;
+            remove: (str: string) => string;
+        };
+        bracket: (type?: "round" | "square" | "curly" | "angle") => {
+            add: (str: string) => string;
+            remove: (str: string) => string;
+        };
+    };
 };
 
-export { st as default };
+export { capitalize, clean, st as default, edit, format, transform, validate };

package/dist/index.js

@@ -20,37 +20,322 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  default: () => index_default
+  capitalize: () => capitalize,
+  clean: () => clean,
+  default: () => index_default,
+  edit: () => edit,
+  format: () => format,
+  transform: () => transform,
+  validate: () => validate
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/regex.ts
+var REGEX_CAMEL_CASE_SEPARATOR = /[^a-zA-Z0-9]+(.)/g;
+var REGEX_CAMEL_CASE_FIRST_CHAR = /^[A-Z]/;
+var REGEX_SNAKE_CASE_CAPITAL = /([A-Z])/g;
+var REGEX_SNAKE_CASE_NON_ALPHANUMERIC = /[^a-zA-Z0-9]+/g;
+var REGEX_SNAKE_CASE_LEADING_UNDERSCORE = /^_/;
+var REGEX_KEBAB_CASE_CAPITAL = /([A-Z])/g;
+var REGEX_KEBAB_CASE_NON_ALPHANUMERIC = /[^a-zA-Z0-9]+/g;
+var REGEX_KEBAB_CASE_LEADING_DASH = /^-/;
+var REGEX_PASCAL_CASE_SEPARATOR = /[^a-zA-Z0-9]+(.)/g;
+var REGEX_PASCAL_CASE_FIRST_CHAR = /^[a-z]/;
+var REGEX_SLUGIFY_NON_WORD = /[^\w\s-]/g;
+var REGEX_SLUGIFY_WHITESPACE = /[\s_-]+/g;
+var REGEX_SLUGIFY_TRIM_DASHES = /^-+|-+$/g;
+var REGEX_EMAIL_DEFAULT = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var REGEX_URL_DEFAULT = /^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$/;
+var REGEX_PHONE_DEFAULT = /^[\+]?[(]?[0-9]{1,4}[)]?[-\s\.]?[(]?[0-9]{1,4}[)]?[-\s\.]?[0-9]{1,9}$/;
+var REGEX_INITIALS_WHITESPACE = /\s+/;
+var REGEX_INITIALS_ALPHA = /[A-Z]/;
+var REGEX_WHITESPACE_ALL = /\s+/g;
+var REGEX_HTML_TAGS = /<[^>]*>/g;
+var REGEX_HTML_ESCAPE_CHARS = /[&<>"']/g;
+var REGEX_HTML_UNESCAPE_ENTITIES = /&(?:amp|lt|gt|quot|#39);/g;
+var REGEX_HIGHLIGHT_ESCAPE = /[.*+?^${}()|[\]\\]/g;
+
 // src/functions.ts
 var capitalize = (str, fullSentence = true) => {
   if (!str) return "";
   if (fullSentence) {
-    str.toLowerCase().split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ") || str;
+    return str.toLowerCase().split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ") || str;
   } else {
     return str.charAt(0).toUpperCase() + str.slice(1);
   }
 };
+var camelCase = (str) => {
+  if (!str) return "";
+  return str.replace(REGEX_CAMEL_CASE_SEPARATOR, (_, chr) => chr.toUpperCase()).replace(REGEX_CAMEL_CASE_FIRST_CHAR, (chr) => chr.toLowerCase());
+};
+var kebabCase = (str) => {
+  if (!str) return "";
+  return str.replace(REGEX_KEBAB_CASE_CAPITAL, "-$1").replace(REGEX_KEBAB_CASE_NON_ALPHANUMERIC, "-").replace(REGEX_KEBAB_CASE_LEADING_DASH, "").toLowerCase();
+};
+var pascalCase = (str) => {
+  if (!str) return "";
+  return str.replace(REGEX_PASCAL_CASE_SEPARATOR, (_, chr) => chr.toUpperCase()).replace(REGEX_PASCAL_CASE_FIRST_CHAR, (chr) => chr.toUpperCase());
+};
+var snakeCase = (str) => {
+  if (!str) return "";
+  return str.replace(REGEX_SNAKE_CASE_CAPITAL, "_$1").replace(REGEX_SNAKE_CASE_NON_ALPHANUMERIC, "_").replace(REGEX_SNAKE_CASE_LEADING_UNDERSCORE, "").toLowerCase();
+};
+var snakeScreamCase = (str) => {
+  if (!str) return "";
+  return str.replace(REGEX_SNAKE_CASE_CAPITAL, "_$1").replace(REGEX_SNAKE_CASE_NON_ALPHANUMERIC, "_").replace(REGEX_SNAKE_CASE_LEADING_UNDERSCORE, "").toUpperCase();
+};
+var reverse = (str) => {
+  if (!str) return "";
+  return str.split("").reverse().join("");
+};
+var slugify = (str) => {
+  if (!str) return "";
+  return str.toLowerCase().trim().replace(REGEX_SLUGIFY_NON_WORD, "").replace(REGEX_SLUGIFY_WHITESPACE, "-").replace(REGEX_SLUGIFY_TRIM_DASHES, "");
+};
+var transform = {
+  capitalize,
+  camel: camelCase,
+  kebab: kebabCase,
+  pascal: pascalCase,
+  snake: snakeCase,
+  snakeScream: snakeScreamCase,
+  reverse,
+  slugify
+};
+var isEmail = (str, customRegex) => {
+  if (!str) return false;
+  const regex = customRegex || REGEX_EMAIL_DEFAULT;
+  return regex.test(str);
+};
+var isUrl = (str, customRegex) => {
+  if (!str) return false;
+  const regex = customRegex || REGEX_URL_DEFAULT;
+  return regex.test(str);
+};
+var isPhone = (str, customRegex) => {
+  if (!str) return false;
+  const regex = customRegex || REGEX_PHONE_DEFAULT;
+  return regex.test(str);
+};
+var validate = {
+  email: isEmail,
+  url: isUrl,
+  phone: isPhone
+};
 var trim = (str, maxLength, trimChar = "...") => {
   if (!maxLength) return str;
   return str?.length > maxLength ? `${str?.slice(0, maxLength)}${trimChar}` : str;
 };
+var repeat = (str, count) => {
+  if (!str || count < 1) return "";
+  return str.repeat(count);
+};
+var pad = (str, length, char = " ", position = "both") => {
+  if (!str || str.length >= length) return str;
+  const padLength = length - str.length;
+  if (position === "start") {
+    return char.repeat(padLength) + str;
+  } else if (position === "end") {
+    return str + char.repeat(padLength);
+  } else {
+    const leftPad = Math.floor(padLength / 2);
+    const rightPad = padLength - leftPad;
+    return char.repeat(leftPad) + str + char.repeat(rightPad);
+  }
+};
+var wrap = (str, wrapper) => {
+  if (!str) return "";
+  if (typeof wrapper === "string") {
+    return `${wrapper}${str}${wrapper}`;
+  }
+  return `${wrapper.start}${str}${wrapper.end}`;
+};
+var unwrap = (str, wrapper) => {
+  if (!str) return "";
+  if (typeof wrapper === "string") {
+    if (str.startsWith(wrapper) && str.endsWith(wrapper)) {
+      return str.slice(wrapper.length, -wrapper.length);
+    }
+    return str;
+  }
+  if (str.startsWith(wrapper.start) && str.endsWith(wrapper.end)) {
+    return str.slice(wrapper.start.length, -wrapper.end.length);
+  }
+  return str;
+};
 var prefix = (pf) => ({
+  /**
+   * Adds the prefix to a string if it doesn't already start with it
+   * @param str - The string to add prefix to
+   * @returns The string with prefix, or empty string if input is falsy
+   */
   add: (str) => !str ? "" : str?.startsWith(pf) ? str : `${pf}${str}`,
-  remove: (str) => !str ? "" : str?.startsWith(pf) ? str?.slice(1) : str
+  /**
+   * Removes the prefix from a string if it starts with it
+   * @param str - The string to remove prefix from
+   * @returns The string without prefix, or empty string if input is falsy
+   */
+  remove: (str) => !str ? "" : str?.startsWith(pf) ? str?.slice(pf.length) : str
 });
 var suffix = (sf) => ({
+  /**
+   * Adds the suffix to a string if it doesn't already end with it
+   * @param str - The string to add suffix to
+   * @returns The string with suffix, or empty string if input is falsy
+   */
   add: (str) => !str ? "" : str?.endsWith(sf) ? str : `${str}${sf}`,
-  remove: (str) => !str ? "" : str?.endsWith(sf) ? str?.slice(0, -1) : str
+  /**
+   * Removes the suffix from a string if it ends with it
+   * @param str - The string to remove suffix from
+   * @returns The string without suffix, or empty string if input is falsy
+   */
+  remove: (str) => !str ? "" : str?.endsWith(sf) ? str?.slice(0, -sf.length) : str
 });
+var initials = (str, maxInitials) => {
+  if (!str) return "";
+  const words = str.trim().split(REGEX_INITIALS_WHITESPACE);
+  const initialsArray = words.map((word) => word.charAt(0).toUpperCase()).filter((char) => REGEX_INITIALS_ALPHA.test(char));
+  if (maxInitials) {
+    return initialsArray.slice(0, maxInitials).join("");
+  }
+  return initialsArray.join("");
+};
+var edit = {
+  trim,
+  repeat,
+  pad,
+  wrap,
+  unwrap,
+  prefix,
+  suffix,
+  initials
+};
+var removeWhitespace = (str) => {
+  if (!str) return "";
+  return str.replace(REGEX_WHITESPACE_ALL, "");
+};
+var normalizeWhitespace = (str) => {
+  if (!str) return "";
+  return str.replace(REGEX_WHITESPACE_ALL, " ").trim();
+};
+var stripHtml = (str) => {
+  if (!str) return "";
+  return str.replace(REGEX_HTML_TAGS, "");
+};
+var escapeHtml = (str) => {
+  if (!str) return "";
+  const htmlEscapes = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;"
+  };
+  return str.replace(REGEX_HTML_ESCAPE_CHARS, (char) => htmlEscapes[char]);
+};
+var unescapeHtml = (str) => {
+  if (!str) return "";
+  const htmlUnescapes = {
+    "&amp;": "&",
+    "&lt;": "<",
+    "&gt;": ">",
+    "&quot;": '"',
+    "&#39;": "'"
+  };
+  return str.replace(
+    REGEX_HTML_UNESCAPE_ENTITIES,
+    (entity) => htmlUnescapes[entity]
+  );
+};
+var clean = {
+  whitespace: removeWhitespace,
+  normalizeWhitespace,
+  html: stripHtml,
+  escapeHtml,
+  unescapeHtml
+};
+var mask = (str, visibleChars = 4, maskChar = "*") => {
+  if (!str) return "";
+  if (str.length <= visibleChars) return str;
+  const maskLength = str.length - visibleChars;
+  return maskChar.repeat(maskLength) + str.slice(-visibleChars);
+};
+var highlight = (str, search, wrapper = {
+  start: "<mark>",
+  end: "</mark>"
+}, caseSensitive = false) => {
+  if (!str || !search) return str;
+  const wrapStart = typeof wrapper === "string" ? wrapper : wrapper.start;
+  const wrapEnd = typeof wrapper === "string" ? wrapper : wrapper.end;
+  const flags = caseSensitive ? "g" : "gi";
+  const regex = new RegExp(
+    search.replace(REGEX_HIGHLIGHT_ESCAPE, "\\$&"),
+    flags
+  );
+  return str.replace(regex, (match) => `${wrapStart}${match}${wrapEnd}`);
+};
+var quote = (type = "double") => {
+  const quoteChar = type === "single" ? "'" : type === "backtick" ? "`" : '"';
+  return {
+    /**
+     * Adds quotes to a string
+     * @param str - The string to quote
+     * @returns The quoted string
+     */
+    add: (str) => wrap(str, quoteChar),
+    /**
+     * Removes quotes from a string
+     * @param str - The string to unquote
+     * @returns The unquoted string
+     */
+    remove: (str) => unwrap(str, quoteChar)
+  };
+};
+var bracket = (type = "round") => {
+  const brackets = {
+    round: { start: "(", end: ")" },
+    square: { start: "[", end: "]" },
+    curly: { start: "{", end: "}" },
+    angle: { start: "<", end: ">" }
+  };
+  const bracketPair = brackets[type];
+  return {
+    /**
+     * Adds brackets to a string
+     * @param str - The string to wrap
+     * @returns The bracketed string
+     */
+    add: (str) => wrap(str, bracketPair),
+    /**
+     * Removes brackets from a string
+     * @param str - The string to unwrap
+     * @returns The unbracketted string
+     */
+    remove: (str) => unwrap(str, bracketPair)
+  };
+};
+var format = {
+  mask,
+  highlight,
+  quote,
+  bracket
+};
 
 // src/index.ts
 var st = {
-  capitalize,
-  trim,
-  prefix,
-  suffix
+  transform,
+  validate,
+  edit,
+  clean,
+  format
 };
 var index_default = st;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  capitalize,
+  clean,
+  edit,
+  format,
+  transform,
+  validate
+});