@stacksjs/strings 0.65.0 → 0.68.0

package/dist/types.d.ts

@@ -1 +0,0 @@
-export { pluralize };

package/src/case.ts

@@ -1,31 +0,0 @@
-/**
- * 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 function lowercase(str: string): string {
-  return str.toLowerCase()
-}
-
-export {
-  camelCase,
-  capitalCase,
-  constantCase,
-  dotCase,
-  kebabCase,
-  kebabCase as paramCase,
-  noCase,
-  pascalCase,
-  pathCase,
-  sentenceCase,
-  snakeCase,
-  split,
-} from 'change-case'
-export { titleCase } from 'title-case'

package/src/helpers.ts

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

package/src/index.ts

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

package/src/is.ts

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

package/src/macro.ts

@@ -1,135 +0,0 @@
-import * as c from './case'
-import * as p from './pluralize'
-import * as u from './utils'
-
-export const Str = {
-  slash(str: string): string {
-    return u.slash(str)
-  },
-
-  ensurePrefix(prefix: string, str: string): string {
-    return u.ensurePrefix(prefix, str)
-  },
-
-  ensureSuffix(suffix: string, str: string): 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 = '...'): string {
-    return u.truncate(str, length, end)
-  },
-
-  random(length = 16, dict?: string): string {
-    return u.random(length, dict)
-  },
-
-  capitalize(str: string): string {
-    return c.capitalize(str)
-  },
-
-  slug(str: string): string {
-    return u.slug(str)
-  },
-
-  detectIndent(str: string): {
-    amount: number
-    type: string | undefined
-    indent: string
-  } {
-    return u.detectIndent(str)
-  },
-
-  detectNewline(str: string): '\r\n' | '\n' | undefined {
-    return u.detectNewline(str)
-  },
-
-  camelCase(str: string): string {
-    return c.camelCase(str)
-  },
-
-  capitalCase(str: string): string {
-    return c.capitalCase(str)
-  },
-
-  constantCase(str: string): string {
-    return c.constantCase(str)
-  },
-
-  dotCase(str: string): string {
-    return c.dotCase(str)
-  },
-
-  noCase(str: string): string {
-    return c.noCase(str)
-  },
-
-  paramCase(str: string): string {
-    return c.paramCase(str)
-  },
-
-  pascalCase(str: string): string {
-    return c.pascalCase(str)
-  },
-
-  pathCase(str: string): string {
-    return c.pathCase(str)
-  },
-
-  sentenceCase(str: string): string {
-    return c.sentenceCase(str)
-  },
-
-  snakeCase(str: string): string {
-    return c.snakeCase(str)
-  },
-
-  titleCase(str: string): string {
-    return c.titleCase(str)
-  },
-
-  kebabCase(str: string): string {
-    return c.kebabCase(str)
-  },
-
-  plural(str: string): string {
-    // plural, singular, isPlural, isSingular, addPluralRule, addSingularRule, addIrregularRule, addUncountableRule
-    return p.plural(str)
-  },
-
-  singular(str: string): string {
-    return p.singular(str)
-  },
-
-  isPlural(str: string): boolean {
-    return p.isPlural(str)
-  },
-
-  isSingular(str: string): boolean {
-    return p.isSingular(str)
-  },
-
-  addPluralRule(rule: string | RegExp, repl: string): void {
-    p.addPluralRule(rule, repl)
-  },
-
-  addSingularRule(rule: string | RegExp, repl: string): void {
-    p.addSingularRule(rule, repl)
-  },
-
-  addIrregularRule(single: string, plural: string): void {
-    p.addIrregularRule(single, plural)
-  },
-
-  addUncountableRule(word: string | RegExp): void {
-    p.addUncountableRule(word)
-  },
-}
-
-export const str: typeof Str = Str

package/src/pluralize.ts

@@ -1,35 +0,0 @@
-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'] = (word, count, inclusive) => {
-  if (count !== undefined && inclusive)
-    return `${count} ${pluralize.plural(word)}`
-
-  return pluralize.plural(word)
-}
-
-export const singular: Pluralize['singular'] = word => pluralize.singular(word)
-export const isPlural: Pluralize['isPlural'] = word => pluralize.isPlural(word)
-export const isSingular: Pluralize['isSingular'] = word => pluralize.isSingular(word)
-export const addPluralRule: Pluralize['addPluralRule'] = (rule, replacement) =>
-  pluralize.addPluralRule(rule, replacement)
-export const addSingularRule: Pluralize['addSingularRule'] = (rule, replacement) =>
-  pluralize.addSingularRule(rule, replacement)
-export const addIrregularRule: Pluralize['addIrregularRule'] = (single, plural) =>
-  pluralize.addIrregularRule(single, plural)
-export const addUncountableRule: Pluralize['addUncountableRule'] = word => pluralize.addUncountableRule(word)

package/src/string.ts

@@ -1,7 +0,0 @@
-export * from './case'
-export * from './helpers'
-export * from './macro'
-export * from './pluralize'
-export * from './utils'
-
-export { isString } from '@stacksjs/validation'

package/src/types.ts

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

package/src/utils.ts

@@ -1,116 +0,0 @@
-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
-export const urlAlphabet = 'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'
-
-/**
- * Replace backslash to slash
- *
- * @category String
- * @example
- * ```
- * slash('C:\\Users\\Chris') => 'C:/Users/Chris'
- * ```
- */
-export function slash(str: string): 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): 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): 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 = '...'): string {
-  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: string = urlAlphabet): string {
-  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'