@stacksjs/strings 0.70.88 → 0.70.91

package/dist/utils.js

@@ -0,0 +1,46 @@
+import { slugify } from "./slug";
+export const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+export function slash(str) {
+  return str.replace(/\\/g, "/");
+}
+export function ensurePrefix(prefix, str) {
+  if (!str.startsWith(prefix))
+    return prefix + str;
+  return str;
+}
+export function ensureSuffix(suffix, str) {
+  return str.endsWith(suffix) ? str : str + suffix;
+}
+export function template(str, ...args) {
+  return str.replace(/\{(\d+)\}/g, (match, key) => {
+    const index = Number(key);
+    return Number.isNaN(index) || args[index] === void 0 ? match : args[index];
+  });
+}
+export function truncate(str, length, end = "...") {
+  if (str.length <= length)
+    return str;
+  return str.slice(0, length - end.length) + end;
+}
+export function random(size = 16, dict = urlAlphabet) {
+  const len = dict.length, g = globalThis;
+  if (!g.crypto?.getRandomValues)
+    throw Error("[strings.random] crypto.getRandomValues is not available; cannot generate secure random string.");
+  const bytes = new Uint8Array(size);
+  g.crypto.getRandomValues(bytes);
+  let id = "";
+  for (let i = 0;i < size; i++)
+    id += dict[(bytes[i] ?? 0) % len];
+  return id;
+}
+export function slug(str, options) {
+  if (options)
+    return slugify(str, options);
+  return slugify(str, {
+    lower: !0,
+    strict: !0
+  });
+}
+
+export * from "./detect-indent";
+export * from "./detect-newline";

package/dist/validators.d.ts

@@ -0,0 +1,170 @@
+import type { HashAlgorithm } from '@stacksjs/types';
+/**
+ * Email validation
+ */
+export declare function isEmail(email: string): boolean;
+/**
+ * Strong password validation
+ * Must contain: min 8 chars, uppercase, lowercase, number, symbol
+ */
+export declare function isStrongPassword(password: string): boolean;
+/**
+ * Alphanumeric validation (letters and numbers only)
+ */
+export declare function isAlphanumeric(str: string): boolean;
+/**
+ * URL validation
+ */
+export declare function isURL(url: string): boolean;
+/**
+ * Mobile phone validation (international format)
+ */
+export declare function isMobilePhone(phoneNumber: string): boolean;
+/**
+ * Alphabetic characters only
+ */
+export declare function isAlpha(str: string): boolean;
+/**
+ * Postal code validation (supports multiple formats)
+ */
+export declare function isPostalCode(zipCode: string): boolean;
+/**
+ * Numeric string validation
+ */
+export declare function isNumeric(str: string): boolean;
+/**
+ * Hex color validation
+ */
+export declare function isHexColor(color: string): boolean;
+/**
+ * Hexadecimal validation
+ */
+export declare function isHexadecimal(hex: string): boolean;
+/**
+ * Base64 validation
+ */
+export declare function isBase64(base64: string): boolean;
+/**
+ * UUID validation (v1-v5)
+ */
+export declare function isUUID(uuid: string): boolean;
+/**
+ * JSON validation
+ */
+export declare function isJSON(json: string): boolean;
+/**
+ * Credit card validation (Luhn algorithm)
+ */
+export declare function isCreditCard(creditCard: string): boolean;
+/**
+ * ISBN validation (ISBN-10 and ISBN-13)
+ */
+export declare function isISBN(isbn: string): boolean;
+/**
+ * IP address validation (IPv4 and IPv6)
+ */
+export declare function isIP(ip: string): boolean;
+/**
+ * IP range validation (CIDR notation)
+ */
+export declare function isIPRange(ip: string): boolean;
+/**
+ * MAC address validation
+ */
+export declare function isMACAddress(macAddress: string): boolean;
+/**
+ * Latitude/Longitude validation
+ */
+export declare function isLatLong(latlong: string): boolean;
+/**
+ * Currency validation
+ */
+export declare function isCurrency(currency: string): boolean;
+/**
+ * Data URI validation
+ */
+export declare function isDataURI(dataURI: string): boolean;
+/**
+ * MIME type validation
+ */
+export declare function isMimeType(mimeType: string): boolean;
+/**
+ * JWT validation
+ */
+export declare function isJWT(jwt: string): boolean;
+/**
+ * ASCII validation
+ */
+export declare function isAscii(ascii: string): boolean;
+/**
+ * Base32 validation
+ */
+export declare function isBase32(base32: string): boolean;
+/**
+ * Byte length validation
+ */
+export declare function isByteLength(str: string, options?: { min?: number, max?: number }): boolean;
+/**
+ * FQDN validation (Fully Qualified Domain Name)
+ */
+export declare function isFQDN(fqdn: string): boolean;
+/**
+ * Full width character validation
+ */
+export declare function isFullWidth(fullWidth: string): boolean;
+/**
+ * Half width character validation
+ */
+export declare function isHalfWidth(halfWidth: string): boolean;
+/**
+ * Hash validation for various algorithms
+ */
+export declare function isHash(hash: string, algorithm: HashAlgorithm): boolean;
+/**
+ * HSL color validation
+ */
+export declare function isHSL(hsl: string): boolean;
+/**
+ * IBAN validation
+ */
+export declare function isIBAN(iban: string): boolean;
+/**
+ * Identity card validation
+ */
+export declare function isIdentityCard(identityCard: string): boolean;
+/**
+ * ISIN validation
+ */
+export declare function isISIN(isin: string): boolean;
+/**
+ * ISO 8601 date validation
+ */
+export declare function isISO8601(iso8601: string): boolean;
+/**
+ * ISRC validation
+ */
+export declare function isISRC(isrc: string): boolean;
+/**
+ * ISSN validation
+ */
+export declare function isISSN(issn: string): boolean;
+/**
+ * ISO 3166-1 alpha-2 country code validation
+ */
+export declare function isISO31661Alpha2(iso31661Alpha2: string): boolean;
+/**
+ * ISO 3166-1 alpha-3 country code validation
+ */
+export declare function isISO31661Alpha3(iso31661Alpha3: string): boolean;
+/**
+ * Username validation
+ */
+export declare function validateUsername(username: string): boolean;
+/**
+ * Latitude validation
+ */
+export declare function isLatitude(latitude: string): boolean;
+/**
+ * Longitude validation
+ */
+export declare function isLongitude(longitude: string): boolean;

package/dist/validators.js

@@ -0,0 +1,272 @@
+export function isEmail(email) {
+  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
+}
+export function isStrongPassword(password) {
+  if (password.length < 8)
+    return !1;
+  const hasUpperCase = /[A-Z]/.test(password), hasLowerCase = /[a-z]/.test(password), hasNumber = /\d/.test(password), hasSymbol = /[!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?]/.test(password);
+  return hasUpperCase && hasLowerCase && hasNumber && hasSymbol;
+}
+export function isAlphanumeric(str) {
+  return /^[a-zA-Z0-9]+$/.test(str);
+}
+export function isURL(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.protocol === "http:" || parsed.protocol === "https:";
+  } catch {
+    return !1;
+  }
+}
+export function isMobilePhone(phoneNumber) {
+  const phoneRegex = /^\+?[1-9]\d{6,14}$/, cleaned = phoneNumber.replace(/[\s()-]/g, "");
+  return phoneRegex.test(cleaned);
+}
+export function isAlpha(str) {
+  return /^[a-zA-Z]+$/.test(str);
+}
+export function isPostalCode(zipCode) {
+  const usZip = /^\d{5}(?:-\d{4})?$/, ukPostcode = /^[A-Z]{1,2}\d{1,2}[A-Z]?\s?\d[A-Z]{2}$/i, canadaPostcode = /^[A-Z]\d[A-Z]\s?\d[A-Z]\d$/i, generic = /^[a-zA-Z0-9]{3,10}$/;
+  return usZip.test(zipCode) || ukPostcode.test(zipCode) || canadaPostcode.test(zipCode) || generic.test(zipCode);
+}
+export function isNumeric(str) {
+  return /^\d+$/.test(str);
+}
+export function isHexColor(color) {
+  return /^#(?:[A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/.test(color);
+}
+export function isHexadecimal(hex) {
+  return /^[A-Fa-f0-9]+$/.test(hex);
+}
+export function isBase64(base64) {
+  try {
+    return btoa(atob(base64)) === base64;
+  } catch {
+    return !1;
+  }
+}
+export function isUUID(uuid) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(uuid);
+}
+export function isJSON(json) {
+  try {
+    JSON.parse(json);
+    return !0;
+  } catch {
+    return !1;
+  }
+}
+export function isCreditCard(creditCard) {
+  const cleaned = creditCard.replace(/[\s-]/g, "");
+  if (!/^\d{13,19}$/.test(cleaned))
+    return !1;
+  let sum = 0, isEven = !1;
+  for (let i = cleaned.length - 1;i >= 0; i--) {
+    let digit = parseInt(cleaned.charAt(i), 10);
+    if (isEven) {
+      digit *= 2;
+      if (digit > 9)
+        digit -= 9;
+    }
+    sum += digit;
+    isEven = !isEven;
+  }
+  return sum % 10 === 0;
+}
+export function isISBN(isbn) {
+  const cleaned = isbn.replace(/[\s-]/g, "");
+  if (cleaned.length === 10) {
+    let sum = 0;
+    for (let i = 0;i < 9; i++) {
+      const digit = parseInt(cleaned.charAt(i), 10);
+      if (isNaN(digit))
+        return !1;
+      sum += digit * (10 - i);
+    }
+    const checkChar = cleaned.charAt(9), checkDigit = checkChar === "X" ? 10 : parseInt(checkChar, 10);
+    if (isNaN(checkDigit) && checkChar !== "X")
+      return !1;
+    sum += checkDigit;
+    return sum % 11 === 0;
+  }
+  if (cleaned.length === 13) {
+    let sum = 0;
+    for (let i = 0;i < 12; i++) {
+      const digit = parseInt(cleaned.charAt(i), 10);
+      if (isNaN(digit))
+        return !1;
+      sum += digit * (i % 2 === 0 ? 1 : 3);
+    }
+    const checkDigit = parseInt(cleaned.charAt(12), 10);
+    if (isNaN(checkDigit))
+      return !1;
+    return (10 - sum % 10) % 10 === checkDigit;
+  }
+  return !1;
+}
+export function isIP(ip) {
+  if (/^(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/.test(ip))
+    return !0;
+  return /^(?:(?:[0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|(?:[0-9a-fA-F]{1,4}:){1,7}:|(?:[0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|(?:[0-9a-fA-F]{1,4}:){1,5}(?::[0-9a-fA-F]{1,4}){1,2}|(?:[0-9a-fA-F]{1,4}:){1,4}(?::[0-9a-fA-F]{1,4}){1,3}|(?:[0-9a-fA-F]{1,4}:){1,3}(?::[0-9a-fA-F]{1,4}){1,4}|(?:[0-9a-fA-F]{1,4}:){1,2}(?::[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:(?:(?::[0-9a-fA-F]{1,4}){1,6})|:(?:(?::[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(?::[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(?:ffff(?::0{1,4}){0,1}:){0,1}(?:(?:25[0-5]|(?:2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(?:25[0-5]|(?:2[0-4]|1{0,1}[0-9]){0,1}[0-9])|(?:[0-9a-fA-F]{1,4}:){1,4}:(?:(?:25[0-5]|(?:2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(?:25[0-5]|(?:2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/.test(ip);
+}
+export function isIPRange(ip) {
+  const parts = ip.split("/");
+  if (parts.length !== 2)
+    return !1;
+  const [address, cidr] = parts;
+  if (address === void 0 || cidr === void 0)
+    return !1;
+  const cidrNum = parseInt(cidr, 10);
+  if (!isIP(address))
+    return !1;
+  if (address.includes(":"))
+    return cidrNum >= 0 && cidrNum <= 128;
+  else
+    return cidrNum >= 0 && cidrNum <= 32;
+}
+export function isMACAddress(macAddress) {
+  return /^(?:[0-9A-Fa-f]{2}[:-]){5}(?:[0-9A-Fa-f]{2})$/.test(macAddress);
+}
+export function isLatLong(latlong) {
+  const parts = latlong.split(",");
+  if (parts.length !== 2)
+    return !1;
+  const lat = parseFloat((parts[0] ?? "").trim()), long = parseFloat((parts[1] ?? "").trim());
+  return !isNaN(lat) && !isNaN(long) && lat >= -90 && lat <= 90 && long >= -180 && long <= 180;
+}
+export function isCurrency(currency) {
+  return /^[$\u00A3\u20AC\u00A5]?\d{1,3}(?:,?\d{3})*(?:\.\d{2})?$/.test(currency.trim());
+}
+export function isDataURI(dataURI) {
+  return /^data:(?:[a-z]+\/[a-z0-9-+.]+(?:;[a-z-]+=[a-z0-9-]+)*)?;base64,(?:[a-z0-9+/]+=*)/i.test(dataURI) || /^data:,/.test(dataURI);
+}
+export function isMimeType(mimeType) {
+  return /^[a-z]+\/[a-z0-9\-+.]+$/i.test(mimeType);
+}
+export function isJWT(jwt) {
+  const parts = jwt.split(".");
+  if (parts.length !== 3)
+    return !1;
+  try {
+    parts.forEach((part) => {
+      atob(part.replace(/-/g, "+").replace(/_/g, "/"));
+    });
+    return !0;
+  } catch {
+    return !1;
+  }
+}
+export function isAscii(ascii) {
+  return /^[\x00-\x7F]*$/.test(ascii);
+}
+export function isBase32(base32) {
+  return /^[A-Z2-7]+=*$/.test(base32.toUpperCase());
+}
+export function isByteLength(str, options) {
+  const min = options?.min ?? 0, max = options?.max ?? 1 / 0, byteLength = new TextEncoder().encode(str).length;
+  return byteLength >= min && byteLength <= max;
+}
+export function isFQDN(fqdn) {
+  return /^(?=.{1,253}$)(?:(?!-)[A-Za-z0-9-]{1,63}(?<!-)\.)+[A-Za-z]{2,}$/.test(fqdn);
+}
+export function isFullWidth(fullWidth) {
+  return /^[\uFF00-\uFFEF]+$/.test(fullWidth);
+}
+export function isHalfWidth(halfWidth) {
+  return /^[\u0020-\u007E\uFF61-\uFF9F]+$/.test(halfWidth);
+}
+export function isHash(hash, algorithm) {
+  const expectedLength = {
+    md5: 32,
+    sha1: 40,
+    sha256: 64,
+    sha384: 96,
+    sha512: 128
+  }[algorithm];
+  if (!expectedLength)
+    return !1;
+  return hash.length === expectedLength && /^[a-f0-9]+$/i.test(hash);
+}
+export function isHSL(hsl) {
+  return /^hsl\(?:\s*(?:\d+)\s*,\s*(?:\d+(?:\.\d+)?%)\s*,\s*(?:\d+(?:\.\d+)?%)\s*\)$/.test(hsl);
+}
+export function isIBAN(iban) {
+  const cleaned = iban.replace(/\s/g, "").toUpperCase();
+  if (!/^[A-Z]{2}\d{2}[A-Z0-9]+$/.test(cleaned))
+    return !1;
+  if (cleaned.length < 15 || cleaned.length > 34)
+    return !1;
+  const digits = (cleaned.slice(4) + cleaned.slice(0, 4)).split("").map((char) => {
+    const code = char.charCodeAt(0);
+    return code >= 65 && code <= 90 ? (code - 55).toString() : char;
+  }).join("");
+  let remainder = digits.slice(0, 2);
+  for (let i = 2;i < digits.length; i += 7)
+    remainder = (parseInt(remainder + digits.slice(i, i + 7), 10) % 97).toString();
+  return parseInt(remainder, 10) === 1;
+}
+export function isIdentityCard(identityCard) {
+  const cleaned = identityCard.replace(/[\s-]/g, "");
+  return /^[A-Z0-9]{5,20}$/i.test(cleaned);
+}
+export function isISIN(isin) {
+  if (!/^[A-Z]{2}[A-Z0-9]{9}\d$/.test(isin))
+    return !1;
+  const digits = isin.split("").map((char) => {
+    const code = char.charCodeAt(0);
+    return code >= 65 && code <= 90 ? (code - 55).toString() : char;
+  }).join("");
+  let sum = 0, isEven = !0;
+  for (let i = digits.length - 1;i >= 0; i--) {
+    let digit = parseInt(digits.charAt(i), 10);
+    if (isEven) {
+      digit *= 2;
+      if (digit > 9)
+        digit -= 9;
+    }
+    sum += digit;
+    isEven = !isEven;
+  }
+  return sum % 10 === 0;
+}
+export function isISO8601(iso8601) {
+  if (!/^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d{3})?(?:Z|[+-]\d{2}:\d{2})?)?$/.test(iso8601))
+    return !1;
+  try {
+    const date = new Date(iso8601);
+    return !isNaN(date.getTime());
+  } catch {
+    return !1;
+  }
+}
+export function isISRC(isrc) {
+  return /^[A-Z]{2}[A-Z0-9]{3}\d{2}\d{5}$/.test(isrc.replace(/-/g, ""));
+}
+export function isISSN(issn) {
+  const cleaned = issn.replace(/[\s-]/g, "");
+  if (!/^\d{7}[\dX]$/.test(cleaned))
+    return !1;
+  let sum = 0;
+  for (let i = 0;i < 7; i++)
+    sum += parseInt(cleaned.charAt(i), 10) * (8 - i);
+  const checkChar = cleaned.charAt(7), checkDigit = checkChar === "X" ? 10 : parseInt(checkChar, 10);
+  sum += checkDigit;
+  return sum % 11 === 0;
+}
+export function isISO31661Alpha2(iso31661Alpha2) {
+  return /^[A-Z]{2}$/.test(iso31661Alpha2);
+}
+export function isISO31661Alpha3(iso31661Alpha3) {
+  return /^[A-Z]{3}$/.test(iso31661Alpha3);
+}
+export function validateUsername(username) {
+  return isAlphanumeric(username);
+}
+export function isLatitude(latitude) {
+  const lat = parseFloat(latitude);
+  return !isNaN(lat) && lat >= -90 && lat <= 90;
+}
+export function isLongitude(longitude) {
+  const long = parseFloat(longitude);
+  return !isNaN(long) && long >= -180 && long <= 180;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/strings",
   "type": "module",
-  "version": "0.70.88",
+  "version": "0.70.91",
   "description": "The Stacks string utilities.",
   "author": "Chris Breuer",
   "contributors": [
@@ -64,9 +64,9 @@
     "prepublishOnly": "bun run build"
   },
   "devDependencies": {
-    "@stacksjs/alias": "0.70.88",
+    "@stacksjs/alias": "0.70.91",
     "better-dx": "^0.2.16",
-    "@stacksjs/types": "0.70.88"
+    "@stacksjs/types": "0.70.91"
   },
   "sideEffects": false
 }