@zairakai/js-utils 1.0.0

package/dist/str.cjs

@@ -0,0 +1,499 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/str.ts
+var str_exports = {};
+__export(str_exports, {
+  Str: () => Str,
+  Stringable: () => Stringable,
+  str: () => str
+});
+module.exports = __toCommonJS(str_exports);
+
+// src/formatters.ts
+var capitalize = (value) => {
+  if (value == null) {
+    return "";
+  }
+  const stringValue = String(value);
+  return stringValue.charAt(0).toUpperCase() + stringValue.slice(1).toLowerCase();
+};
+var slugify = (text) => {
+  if (!text) {
+    return "";
+  }
+  return text.toString().normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().trim().replace(/\s+/g, "-").replace(/[^\w-]+/g, "").replace(/--+/g, "-");
+};
+var strLimit = (value, size) => {
+  if (!value) {
+    return "";
+  }
+  const stringValue = String(value);
+  return stringValue.length <= size ? stringValue : `${stringValue.slice(0, size)}\u2026`;
+};
+var strContainsAll = (haystack, needles) => {
+  if (!haystack || !Array.isArray(needles)) {
+    return false;
+  }
+  return needles.every((needle) => haystack.includes(needle));
+};
+var strContainsAny = (haystack, needles) => {
+  if (!haystack || !Array.isArray(needles)) {
+    return false;
+  }
+  return needles.some((needle) => haystack.includes(needle));
+};
+var strFinish = (value, cap) => {
+  if (!value) {
+    return cap;
+  }
+  if (!cap) {
+    return value;
+  }
+  return value.endsWith(cap) ? value : value + cap;
+};
+var strStart = (value, prefix) => {
+  if (!value) {
+    return prefix;
+  }
+  if (!prefix) {
+    return value;
+  }
+  return value.startsWith(prefix) ? value : prefix + value;
+};
+var strReverse = (value) => {
+  return value.split("").reverse().join("");
+};
+var strMask = (str2, character, index, length) => {
+  if (!str2) {
+    return str2;
+  }
+  const start = Math.max(0, index);
+  const end = length !== void 0 ? start + length : str2.length;
+  return str2.substring(0, start) + character.repeat(end - start) + str2.substring(end);
+};
+var camelCase = (value) => {
+  const studly = studlyCase(value);
+  return studly.charAt(0).toLowerCase() + studly.slice(1);
+};
+var snakeCase = (value) => {
+  return value.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[\s-]+/g, "_").toLowerCase();
+};
+var kebabCase = (value) => {
+  return value.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+};
+var studlyCase = (value) => {
+  return value.replace(/[_-]/g, " ").replace(/\s+(.)/g, (_, c) => c.toUpperCase()).replace(/^(.)/, (_, c) => c.toUpperCase()).replace(/\s+/g, "");
+};
+var titleCase = (value) => {
+  return value.replace(/\w\S*/g, (txt) => {
+    return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
+  });
+};
+
+// src/str.ts
+var Stringable = class {
+  constructor(value) {
+    this.value = String(value ?? "");
+  }
+  /**
+   * Get the raw string value
+   *
+   * @returns {string} The raw string
+   */
+  toString() {
+    return this.value;
+  }
+  /**
+   * Alias for toString()
+   *
+   * @returns {string} The raw string
+   */
+  get() {
+    return this.value;
+  }
+  /**
+   * Convert to title case
+   *
+   * @returns {this} The Stringable instance
+   */
+  title() {
+    this.value = titleCase(this.value);
+    return this;
+  }
+  /**
+   * Convert to slug
+   *
+   * @returns {this} The Stringable instance
+   */
+  slug() {
+    this.value = slugify(this.value);
+    return this;
+  }
+  /**
+   * Convert to snake_case
+   *
+   * @returns {this} The Stringable instance
+   */
+  snake() {
+    this.value = snakeCase(this.value);
+    return this;
+  }
+  /**
+   * Convert to kebab-case
+   *
+   * @returns {this} The Stringable instance
+   */
+  kebab() {
+    this.value = kebabCase(this.value);
+    return this;
+  }
+  /**
+   * Convert to camelCase
+   *
+   * @returns {this} The Stringable instance
+   */
+  camel() {
+    this.value = camelCase(this.value);
+    return this;
+  }
+  /**
+   * Convert to StudlyCase
+   *
+   * @returns {this} The Stringable instance
+   */
+  studly() {
+    this.value = studlyCase(this.value);
+    return this;
+  }
+  /**
+   * Limit the string length
+   *
+   * @param {number} size The maximum length
+   * @param {string} [end='…'] The string to append if limited
+   * @returns {this} The Stringable instance
+   */
+  limit(size, end = "\u2026") {
+    this.value = strLimit(this.value, size);
+    if (this.value.endsWith("\u2026") && "\u2026" !== end) {
+      this.value = this.value.slice(0, -1) + end;
+    }
+    return this;
+  }
+  /**
+   * Append a value to the string
+   *
+   * @param {...unknown[]} values The values to append
+   * @returns {this} The Stringable instance
+   */
+  append(...values) {
+    this.value += values.join("");
+    return this;
+  }
+  /**
+   * Prepend a value to the string
+   *
+   * @param {...unknown[]} values The values to prepend
+   * @returns {this} The Stringable instance
+   */
+  prepend(...values) {
+    this.value = values.join("") + this.value;
+    return this;
+  }
+  /**
+   * Cap the string with a value if it doesn't already end with it
+   *
+   * @param {string} cap The string to end with
+   * @returns {this} The Stringable instance
+   */
+  finish(cap) {
+    this.value = strFinish(this.value, cap);
+    return this;
+  }
+  /**
+   * Start the string with a value if it doesn't already start with it
+   *
+   * @param {string} prefix The string to start with
+   * @returns {this} The Stringable instance
+   */
+  start(prefix) {
+    this.value = strStart(this.value, prefix);
+    return this;
+  }
+  /**
+   * Replace the first occurrence of a value
+   *
+   * @param {string | RegExp} search The value to search for
+   * @param {string} replace The value to replace with
+   * @returns {this} The Stringable instance
+   */
+  replace(search, replace) {
+    this.value = this.value.replace(search, replace);
+    return this;
+  }
+  /**
+   * Replace all occurrences of a value
+   *
+   * @param {string | RegExp} search The value to search for
+   * @param {string} replace The value to replace with
+   * @returns {this} The Stringable instance
+   */
+  replaceAll(search, replace) {
+    if ("string" === typeof search) {
+      this.value = this.value.split(search).join(replace);
+    } else {
+      const flags = search.flags.includes("g") ? search.flags : `${search.flags}g`;
+      this.value = this.value.replace(new RegExp(search.source, flags), replace);
+    }
+    return this;
+  }
+  /**
+   * Reverse the string
+   *
+   * @returns {this} The Stringable instance
+   */
+  reverse() {
+    this.value = strReverse(this.value);
+    return this;
+  }
+  /**
+   * Mask a portion of the string
+   *
+   * @param {string} character The masking character
+   * @param {number} index The starting index
+   * @param {number} [length] The number of characters to mask
+   * @returns {this} The Stringable instance
+   */
+  mask(character, index, length) {
+    this.value = strMask(this.value, character, index, length);
+    return this;
+  }
+  /**
+   * Trim the string
+   *
+   * @param {string} [chars] The characters to trim (defaults to whitespace)
+   * @returns {this} The Stringable instance
+   */
+  trim(chars) {
+    if (!chars) {
+      this.value = this.value.trim();
+    } else {
+      const pattern = new RegExp(`^[${chars}]+|[${chars}]+$`, "g");
+      this.value = this.value.replace(pattern, "");
+    }
+    return this;
+  }
+  /**
+   * Convert to lower case
+   *
+   * @returns {this} The Stringable instance
+   */
+  lower() {
+    this.value = this.value.toLowerCase();
+    return this;
+  }
+  /**
+   * Convert to upper case
+   *
+   * @returns {this} The Stringable instance
+   */
+  upper() {
+    this.value = this.value.toUpperCase();
+    return this;
+  }
+  /**
+   * Capitalize the first letter
+   *
+   * @returns {this} The Stringable instance
+   */
+  capitalize() {
+    this.value = capitalize(this.value);
+    return this;
+  }
+  /**
+   * Check if string contains a value
+   *
+   * @param {string | string[]} needles The values to search for
+   * @returns {boolean} True if the string contains any of the values
+   */
+  contains(needles) {
+    if (Array.isArray(needles)) {
+      return strContainsAny(this.value, needles);
+    }
+    return this.value.includes(needles);
+  }
+  /**
+   * Check if string contains all values
+   *
+   * @param {string[]} needles The values to search for
+   * @returns {boolean} True if the string contains all values
+   */
+  containsAll(needles) {
+    return strContainsAll(this.value, needles);
+  }
+  /**
+   * Check if string starts with a value
+   *
+   * @param {string | string[]} needles The values to check
+   * @returns {boolean} True if the string starts with any of the values
+   */
+  startsWith(needles) {
+    if (Array.isArray(needles)) {
+      return needles.some((needle) => this.value.startsWith(needle));
+    }
+    return this.value.startsWith(needles);
+  }
+  /**
+   * Check if string ends with a value
+   *
+   * @param {string | string[]} needles The values to check
+   * @returns {boolean} True if the string ends with any of the values
+   */
+  endsWith(needles) {
+    if (Array.isArray(needles)) {
+      return needles.some((needle) => this.value.endsWith(needle));
+    }
+    return this.value.endsWith(needles);
+  }
+  /**
+   * Execute a callback with the stringable and return the result
+   *
+   * @param {(str: this) => U} callback The callback to execute
+   * @returns {U} The result of the callback
+   */
+  pipe(callback) {
+    return callback(this);
+  }
+  /**
+   * Conditionally execute a callback
+   *
+   * @param {boolean | (() => boolean)} condition The condition to check
+   * @param {(str: this) => void} callback The callback to execute
+   * @returns {this} The Stringable instance
+   */
+  when(condition, callback) {
+    const shouldExecute = "function" === typeof condition ? condition() : condition;
+    if (shouldExecute) {
+      callback(this);
+    }
+    return this;
+  }
+  /**
+   * Execute a callback and return the stringable (for side effects)
+   *
+   * @param {(str: this) => void} callback The callback to execute
+   * @returns {this} The Stringable instance
+   */
+  tap(callback) {
+    callback(this);
+    return this;
+  }
+};
+var str = (value) => {
+  return new Stringable(value);
+};
+var Str = {
+  /**
+   * Create a new fluent stringable instance
+   *
+   * @param {unknown} value The initial string value
+   * @returns {Stringable} A new Stringable instance
+   */
+  of: (value) => new Stringable(value),
+  /**
+   * Convert a string to a slug
+   *
+   * @param {string} value The string to slugify
+   * @returns {string} The slugified string
+   */
+  slug: (value) => slugify(value),
+  /**
+   * Convert a string to snake_case
+   *
+   * @param {string} value The string to convert
+   * @returns {string} The snake_case string
+   */
+  snake: (value) => snakeCase(value),
+  /**
+   * Convert a string to kebab-case
+   *
+   * @param {string} value The string to convert
+   * @returns {string} The kebab-case string
+   */
+  kebab: (value) => kebabCase(value),
+  /**
+   * Convert a string to camelCase
+   *
+   * @param {string} value The string to convert
+   * @returns {string} The camelCase string
+   */
+  camel: (value) => camelCase(value),
+  /**
+   * Convert a string to StudlyCase
+   *
+   * @param {string} value The string to convert
+   * @returns {string} The StudlyCase string
+   */
+  studly: (value) => studlyCase(value),
+  /**
+   * Convert a string to title case
+   *
+   * @param {string} value The string to convert
+   * @returns {string} The title case string
+   */
+  title: (value) => titleCase(value),
+  /**
+   * Limit the length of a string
+   *
+   * @param {string} value The string to limit
+   * @param {number} size The maximum length
+   * @param {string} [end='…'] The string to append if limited
+   * @returns {string} The limited string
+   */
+  limit: (value, size, end = "\u2026") => {
+    const result = strLimit(value, size);
+    return result.endsWith("\u2026") && "\u2026" !== end ? result.slice(0, -1) + end : result;
+  },
+  /**
+   * Generate a random alphanumeric string
+   *
+   * @param {number} [length=16] The length of the random string
+   * @returns {string} The random string
+   */
+  random: (length = 16) => {
+    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    let result = "";
+    for (let i = 0; i < length; i++) {
+      result += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return result;
+  },
+  /**
+   * Generate a UUID (version 4)
+   *
+   * @returns {string} The generated UUID
+   */
+  uuid: () => crypto.randomUUID()
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Str,
+  Stringable,
+  str
+});