@stacksjs/strings 0.58.48 → 0.58.49

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/strings",
   "type": "module",
-  "version": "0.58.48",
+  "version": "0.58.49",
   "description": "The Stacks string utilities.",
   "author": "Chris Breuer",
   "license": "MIT",
@@ -50,7 +50,8 @@
   ],
   "files": [
     "README.md",
-    "dist"
+    "dist",
+    "src"
   ],
   "scripts": {
     "build": "bun --bun build.ts",

package/src/case.ts

@@ -0,0 +1,27 @@
+/**
+ * First letter uppercase, other lowercase
+ * @category string
+ * @example
+ * ```
+ * capitalize('hello world') => 'Hello world'
+ * ```
+ */
+export function capitalize(str: string): string {
+  return str[0] ? str[0].toUpperCase() + str.slice(1).toLowerCase() : ''
+}
+
+export {
+  camelCase,
+  capitalCase,
+  constantCase,
+  dotCase,
+  noCase,
+  kebabCase,
+  kebabCase as paramCase,
+  pascalCase,
+  pathCase,
+  sentenceCase,
+  snakeCase,
+  split,
+} from 'change-case'
+export { titleCase } from 'title-case'

package/src/helpers.ts

@@ -0,0 +1,3 @@
+export function toString(v: any) {
+  return Object.prototype.toString.call(v)
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './string'
+export * as string from './string'

package/src/is.ts

@@ -0,0 +1,170 @@
+import type { HashAlgorithm } from '@stacksjs/types'
+import v from 'validator'
+
+export function isEmail(email: string) {
+  return v.isEmail(email)
+}
+
+export function isStrongPassword(password: string) {
+  return v.isStrongPassword(password)
+}
+
+export function isAlphanumeric(username: string) {
+  return v.isAlphanumeric(username)
+}
+
+export function validateUsername(username: string) {
+  return isAlphanumeric(username)
+}
+
+export function isURL(url: string) {
+  return v.isURL(url)
+}
+
+export function isMobilePhone(phoneNumber: string) {
+  return v.isMobilePhone(phoneNumber)
+}
+
+export function isAlpha(name: string) {
+  return v.isAlpha(name)
+}
+
+export function isPostalCode(zipCode: string) {
+  return v.isPostalCode(zipCode, 'any')
+}
+
+export function isNumeric(number: string) {
+  return v.isNumeric(number)
+}
+
+export function isHexColor(color: string) {
+  return v.isHexColor(color)
+}
+
+export function isHexadecimal(hex: string) {
+  return v.isHexadecimal(hex)
+}
+
+export function isBase64(base64: string) {
+  return v.isBase64(base64)
+}
+
+export function isUUID(uuid: string) {
+  return v.isUUID(uuid)
+}
+
+export function isJSON(json: string) {
+  return v.isJSON(json)
+}
+
+export function isCreditCard(creditCard: string) {
+  return v.isCreditCard(creditCard)
+}
+
+export function isISBN(isbn: string) {
+  return v.isISBN(isbn)
+}
+
+export function isIP(ip: string) {
+  return v.isIP(ip)
+}
+
+export function isIPRange(ip: string) {
+  return v.isIPRange(ip)
+}
+
+export function isMACAddress(macAddress: string) {
+  return v.isMACAddress(macAddress)
+}
+
+export function isLatLong(latitude: string) {
+  return v.isLatLong(latitude)
+}
+
+export function isLatitude(longitude: string) {
+  return v.isLatLong(longitude)
+}
+
+export function isLongitude(longitude: string) {
+  return v.isLatLong(longitude)
+}
+
+export function isCurrency(currency: string) {
+  return v.isCurrency(currency)
+}
+
+export function isDataURI(dataURI: string) {
+  return v.isDataURI(dataURI)
+}
+
+export function isMimeType(mimeType: string) {
+  return v.isMimeType(mimeType)
+}
+
+export function isJWT(jwt: string) {
+  return v.isJWT(jwt)
+}
+
+export function isAscii(ascii: string) {
+  return v.isAscii(ascii)
+}
+
+export function isBase32(base32: string) {
+  return v.isBase32(base32)
+}
+
+export function isByteLength(byteLength: string) {
+  return v.isByteLength(byteLength)
+}
+
+export function isFQDN(fqdn: string) {
+  return v.isFQDN(fqdn)
+}
+
+export function isFullWidth(fullWidth: string) {
+  return v.isFullWidth(fullWidth)
+}
+
+export function isHalfWidth(halfWidth: string) {
+  return v.isHalfWidth(halfWidth)
+}
+
+export function isHash(hash: string, algorithm: HashAlgorithm) {
+  return v.isHash(hash, algorithm)
+}
+
+export function isHSL(hsl: string) {
+  return v.isHSL(hsl)
+}
+
+export function isIBAN(iban: string) {
+  return v.isIBAN(iban)
+}
+
+export function isIdentityCard(identityCard: string) {
+  return v.isIdentityCard(identityCard)
+}
+
+export function isISIN(isin: string) {
+  return v.isISIN(isin)
+}
+
+export function isISO8601(iso8601: string) {
+  return v.isISO8601(iso8601)
+}
+
+export function isISRC(isrc: string) {
+  return v.isISRC(isrc)
+}
+
+export function isISSN(issn: string) {
+  return v.isISSN(issn)
+}
+
+export function isISO31661Alpha2(iso31661Alpha2: string) {
+  return v.isISO31661Alpha2(iso31661Alpha2)
+}
+
+export function isISO31661Alpha3(iso31661Alpha3: string) {
+  return v.isISO31661Alpha3(iso31661Alpha3)
+}

package/src/macro.ts

@@ -0,0 +1,131 @@
+import * as c from './case'
+import * as p from './pluralize'
+import * as u from './utils'
+
+export const Str = {
+  slash(str: string) {
+    return u.slash(str)
+  },
+
+  ensurePrefix(prefix: string, str: string) {
+    return u.ensurePrefix(prefix, str)
+  },
+
+  ensureSuffix(suffix: string, str: string) {
+    return u.ensureSuffix(suffix, str)
+  },
+
+  template(str: string, ...args: any[]): string {
+    return u.template(str, ...args)
+  },
+
+  /**
+   * Truncate a string
+   */
+  truncate(str: string, length: number, end = '...') {
+    return u.truncate(str, length, end)
+  },
+
+  random(length = 16) {
+    return u.random(length)
+  },
+
+  capitalize(str: string) {
+    return c.capitalize(str)
+  },
+
+  slug(str: string) {
+    return u.slug(str)
+  },
+
+  detectIndent(str: string) {
+    return u.detectIndent(str)
+  },
+
+  detectNewline(str: string) {
+    return u.detectNewline(str)
+  },
+
+  camelCase(str: string) {
+    return c.camelCase(str)
+  },
+
+  capitalCase(str: string) {
+    return c.capitalCase(str)
+  },
+
+  constantCase(str: string) {
+    return c.constantCase(str)
+  },
+
+  dotCase(str: string) {
+    return c.dotCase(str)
+  },
+
+  noCase(str: string) {
+    return c.noCase(str)
+  },
+
+  paramCase(str: string) {
+    return c.paramCase(str)
+  },
+
+  pascalCase(str: string) {
+    return c.pascalCase(str)
+  },
+
+  pathCase(str: string) {
+    return c.pathCase(str)
+  },
+
+  sentenceCase(str: string) {
+    return c.sentenceCase(str)
+  },
+
+  snakeCase(str: string) {
+    return c.snakeCase(str)
+  },
+
+  titleCase(str: string) {
+    return c.titleCase(str)
+  },
+
+  kebabCase(str: string) {
+    return c.kebabCase(str)
+  },
+
+  plural(str: string) {
+    // plural, singular, isPlural, isSingular, addPluralRule, addSingularRule, addIrregularRule, addUncountableRule
+    return p.plural(str)
+  },
+
+  singular(str: string) {
+    return p.singular(str)
+  },
+
+  isPlural(str: string) {
+    return p.isPlural(str)
+  },
+
+  isSingular(str: string) {
+    return p.isSingular(str)
+  },
+
+  addPluralRule(rule: string | RegExp, repl: string) {
+    return p.addPluralRule(rule, repl)
+  },
+
+  addSingularRule(rule: string | RegExp, repl: string) {
+    return p.addSingularRule(rule, repl)
+  },
+
+  addIrregularRule(single: string, plural: string) {
+    return p.addIrregularRule(single, plural)
+  },
+
+  addUncountableRule(word: string | RegExp) {
+    return p.addUncountableRule(word)
+  },
+}
+
+export const str = Str

package/src/pluralize.ts

@@ -0,0 +1,26 @@
+import * as pluralize from 'pluralize'
+
+type Rule = string | RegExp
+type Replacement = string
+type Word = string
+export type PluralizeTest = (word: Word) => boolean
+
+export interface Pluralize {
+  plural: (word: Word, count?: number, inclusive?: boolean) => Word
+  singular: (word: Word) => Word
+  isPlural: (word: Word) => boolean
+  isSingular: (word: Word) => boolean
+  addPluralRule: (rule: Rule, replacement: Replacement) => void
+  addSingularRule: (rule: Rule, replacement: Replacement) => void
+  addIrregularRule: (single: Word, plural: Word) => void
+  addUncountableRule: (word: Word | RegExp) => void
+}
+
+export const plural: Pluralize['plural'] = (...args) => pluralize.plural(...args)
+export const singular: Pluralize['singular'] = (...args) => pluralize.singular(...args)
+export const isPlural: Pluralize['isPlural'] = (...args) => pluralize.isPlural(...args)
+export const isSingular: Pluralize['isSingular'] = (...args) => pluralize.isSingular(...args)
+export const addPluralRule: Pluralize['addPluralRule'] = (...args) => pluralize.addPluralRule(...args)
+export const addSingularRule: Pluralize['addSingularRule'] = (...args) => pluralize.addSingularRule(...args)
+export const addIrregularRule: Pluralize['addIrregularRule'] = (...args) => pluralize.addIrregularRule(...args)
+export const addUncountableRule: Pluralize['addUncountableRule'] = (...args) => pluralize.addUncountableRule(...args)

package/src/string.ts

@@ -0,0 +1,5 @@
+export * from './utils'
+export * from './case'
+export * from './pluralize'
+export * from './macro'
+export * from './helpers'

package/src/types.ts

@@ -0,0 +1,4 @@
+declare function pluralize(word: string, count?: number, inclusive?: boolean): string
+
+export { pluralize }
+// export as namespace pluralize;

package/src/utils.ts

@@ -0,0 +1,117 @@
+import slugify from 'slugify'
+
+interface SlugOptions {
+  replacement?: string
+  remove?: RegExp
+  lower?: boolean
+  strict?: boolean
+  locale?: string
+  trim?: boolean
+}
+
+// port from nanoid
+// https://github.com/ai/nanoid
+const urlAlphabet = 'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'
+
+/**
+ * Replace backslash to slash
+ *
+ * @category String
+ * @example
+ * ```
+ * slash('C:\\Users\\Chris') => 'C:/Users/Chris'
+ * ```
+ */
+export function slash(str: string) {
+  return str.replace(/\\/g, '/')
+}
+
+/**
+ * Ensure prefix of a string
+ *
+ * @category String
+ * @example
+ * ```
+ * ensurePrefix('https://', 'google.com') => 'https://google.com'
+ * ensurePrefix('https://', 'http://google.com') => 'https://google.com'
+ */
+export function ensurePrefix(prefix: string, str: string) {
+  if (!str.startsWith(prefix))
+    return prefix + str
+  return str
+}
+
+/**
+ * Ensure suffix of a string
+ *
+ * @category String
+ * @example
+ * ```
+ * ensureSuffix('.js', 'index') => 'index.js'
+ * ensureSuffix('.js', 'index.js') => 'index.js'
+ * ```
+ */
+export function ensureSuffix(suffix: string, str: string) {
+  return str.endsWith(suffix) ? str : str + suffix
+}
+
+/**
+ * Dead simple template engine, just like Python's `.format()`
+ *
+ * @category String
+ * @example
+ * ```
+ * const result = template('Hello {0}! My name is {1}.',
+ *   'Buddy',
+ *   'Chris'
+ * ) // Hello Buddy! My name is Chris.
+ * ```
+ */
+export function template(str: string, ...args: any[]): string {
+  return str.replace(/{(\d+)}/g, (match, key) => {
+    const index = Number(key)
+
+    return Number.isNaN(index) ? match : args[index]
+  })
+}
+
+export function truncate(str: string, length: number, end = '...') {
+  if (str.length <= length)
+    return str
+
+  return str.slice(0, length - end.length) + end
+}
+
+/**
+ * Generate a random string
+ * @category String
+ */
+export function random(size = 16, dict = urlAlphabet) {
+  let id = ''
+  let i = size
+  const len = dict.length
+  while (i--)
+    id += dict[(Math.random() * len) | 0]
+  return id
+}
+
+/**
+ * Slugify a string
+ * @category string
+ * @example
+ * ```
+ * slug('Hello World') => 'hello-world'
+ * ```
+ */
+export function slug(str: string, options?: SlugOptions): string {
+  if (options)
+    return slugify(str, options)
+
+  return slugify(str, {
+    lower: true,
+    strict: true,
+  })
+}
+
+export { default as detectIndent } from 'detect-indent'
+export { detectNewline } from 'detect-newline'