@stacksjs/strings 0.59.10 → 0.61.0

package/dist/index.js

@@ -248,14 +248,18 @@ split
 import {titleCase} from "title-case";
 // src/pluralize.ts
 import * as pluralize from "pluralize";
-var plural2 = (...args) => pluralize.plural(...args);
-var singular2 = (...args) => pluralize.singular(...args);
-var isPlural2 = (...args) => pluralize.isPlural(...args);
-var isSingular2 = (...args) => pluralize.isSingular(...args);
-var addPluralRule2 = (...args) => pluralize.addPluralRule(...args);
-var addSingularRule2 = (...args) => pluralize.addSingularRule(...args);
-var addIrregularRule2 = (...args) => pluralize.addIrregularRule(...args);
-var addUncountableRule2 = (...args) => pluralize.addUncountableRule(...args);
+var plural2 = (word, count, inclusive) => {
+  if (count !== undefined && inclusive)
+    return `${count} ${pluralize.plural(word)}`;
+  return pluralize.plural(word);
+};
+var singular2 = (word) => pluralize.singular(word);
+var isPlural2 = (word) => pluralize.isPlural(word);
+var isSingular2 = (word) => pluralize.isSingular(word);
+var addPluralRule2 = (rule, replacement) => pluralize.addPluralRule(rule, replacement);
+var addSingularRule2 = (rule, replacement) => pluralize.addSingularRule(rule, replacement);
+var addIrregularRule2 = (single, plural3) => pluralize.addIrregularRule(single, plural3);
+var addUncountableRule2 = (word) => pluralize.addUncountableRule(word);
 // src/macro.ts
 var Str = {
   slash(str) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/strings",
   "type": "module",
-  "version": "0.59.10",
+  "version": "0.61.0",
   "description": "The Stacks string utilities.",
   "author": "Chris Breuer",
   "license": "MIT",
@@ -65,18 +65,19 @@
   "dependencies": {
     "@stacksjs/alias": "latest",
     "@stacksjs/types": "latest",
-    "change-case": "^5.4.3",
+    "change-case": "^5.4.4",
     "detect-indent": "^7.0.1",
     "detect-newline": "^4.0.1",
     "macroable": "^7.0.2",
     "pluralize": "^8.0.0",
     "slugify": "^1.6.6",
-    "string-ts": "^2.0.0",
+    "string-ts": "^2.1.1",
     "title-case": "^4.3.1",
-    "validator": "^13.11.0"
+    "validator": "^13.12.0"
   },
   "devDependencies": {
     "@stacksjs/development": "latest",
-    "@types/validator": "^13.11.9"
+    "@types/pluralize": "^0.0.33",
+    "@types/validator": "^13.11.10"
   }
 }

package/src/is.ts

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

package/src/pluralize.ts

@@ -16,11 +16,19 @@ export interface Pluralize {
   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)
+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/utils.ts

@@ -36,8 +36,7 @@ export function slash(str: string) {
  * ensurePrefix('https://', 'http://google.com') => 'https://google.com'
  */
 export function ensurePrefix(prefix: string, str: string) {
-  if (!str.startsWith(prefix))
-    return prefix + str
+  if (!str.startsWith(prefix)) return prefix + str
   return str
 }
 
@@ -76,8 +75,7 @@ export function template(str: string, ...args: any[]): string {
 }
 
 export function truncate(str: string, length: number, end = '...') {
-  if (str.length <= length)
-    return str
+  if (str.length <= length) return str
 
   return str.slice(0, length - end.length) + end
 }
@@ -90,8 +88,7 @@ export function random(size = 16, dict = urlAlphabet) {
   let id = ''
   let i = size
   const len = dict.length
-  while (i--)
-    id += dict[(Math.random() * len) | 0]
+  while (i--) id += dict[(Math.random() * len) | 0]
   return id
 }
 
@@ -104,8 +101,7 @@ export function random(size = 16, dict = urlAlphabet) {
  * ```
  */
 export function slug(str: string, options?: SlugOptions): string {
-  if (options)
-    return slugify(str, options)
+  if (options) return slugify(str, options)
 
   return slugify(str, {
     lower: true,

package/dist/case.d.ts

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

package/dist/helpers.d.ts

@@ -1 +0,0 @@
-export declare function toString(v: any): string;

package/dist/index.d.ts

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

package/dist/macro.d.ts

@@ -1,70 +0,0 @@
-export declare const Str: {
-    slash(str: string): string;
-    ensurePrefix(prefix: string, str: string): string;
-    ensureSuffix(suffix: string, str: string): string;
-    template(str: string, ...args: any[]): string;
-    /**
-     * Truncate a string
-     */
-    truncate(str: string, length: number, end?: string): string;
-    random(length?: number): string;
-    capitalize(str: string): string;
-    slug(str: string): string;
-    detectIndent(str: string): import("detect-indent").Indent;
-    detectNewline(str: string): "\r\n" | "\n" | undefined;
-    camelCase(str: string): string;
-    capitalCase(str: string): string;
-    constantCase(str: string): string;
-    dotCase(str: string): string;
-    noCase(str: string): string;
-    paramCase(str: string): string;
-    pascalCase(str: string): string;
-    pathCase(str: string): string;
-    sentenceCase(str: string): string;
-    snakeCase(str: string): string;
-    titleCase(str: string): string;
-    kebabCase(str: string): string;
-    plural(str: string): string;
-    singular(str: string): string;
-    isPlural(str: string): boolean;
-    isSingular(str: string): boolean;
-    addPluralRule(rule: string | RegExp, repl: string): void;
-    addSingularRule(rule: string | RegExp, repl: string): void;
-    addIrregularRule(single: string, plural: string): void;
-    addUncountableRule(word: string | RegExp): void;
-};
-export declare const str: {
-    slash(str: string): string;
-    ensurePrefix(prefix: string, str: string): string;
-    ensureSuffix(suffix: string, str: string): string;
-    template(str: string, ...args: any[]): string;
-    /**
-     * Truncate a string
-     */
-    truncate(str: string, length: number, end?: string): string;
-    random(length?: number): string;
-    capitalize(str: string): string;
-    slug(str: string): string;
-    detectIndent(str: string): import("detect-indent").Indent;
-    detectNewline(str: string): "\r\n" | "\n" | undefined;
-    camelCase(str: string): string;
-    capitalCase(str: string): string;
-    constantCase(str: string): string;
-    dotCase(str: string): string;
-    noCase(str: string): string;
-    paramCase(str: string): string;
-    pascalCase(str: string): string;
-    pathCase(str: string): string;
-    sentenceCase(str: string): string;
-    snakeCase(str: string): string;
-    titleCase(str: string): string;
-    kebabCase(str: string): string;
-    plural(str: string): string;
-    singular(str: string): string;
-    isPlural(str: string): boolean;
-    isSingular(str: string): boolean;
-    addPluralRule(rule: string | RegExp, repl: string): void;
-    addSingularRule(rule: string | RegExp, repl: string): void;
-    addIrregularRule(single: string, plural: string): void;
-    addUncountableRule(word: string | RegExp): void;
-};

package/dist/pluralize.d.ts

@@ -1,23 +0,0 @@
-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 declare const plural: Pluralize['plural'];
-export declare const singular: Pluralize['singular'];
-export declare const isPlural: Pluralize['isPlural'];
-export declare const isSingular: Pluralize['isSingular'];
-export declare const addPluralRule: Pluralize['addPluralRule'];
-export declare const addSingularRule: Pluralize['addSingularRule'];
-export declare const addIrregularRule: Pluralize['addIrregularRule'];
-export declare const addUncountableRule: Pluralize['addUncountableRule'];
-export {};

package/dist/string.d.ts

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

package/dist/utils.d.ts

@@ -1,69 +0,0 @@
-interface SlugOptions {
-    replacement?: string;
-    remove?: RegExp;
-    lower?: boolean;
-    strict?: boolean;
-    locale?: string;
-    trim?: boolean;
-}
-/**
- * Replace backslash to slash
- *
- * @category String
- * @example
- * ```
- * slash('C:\\Users\\Chris') => 'C:/Users/Chris'
- * ```
- */
-export declare function slash(str: string): string;
-/**
- * Ensure prefix of a string
- *
- * @category String
- * @example
- * ```
- * ensurePrefix('https://', 'google.com') => 'https://google.com'
- * ensurePrefix('https://', 'http://google.com') => 'https://google.com'
- */
-export declare function ensurePrefix(prefix: string, str: string): string;
-/**
- * Ensure suffix of a string
- *
- * @category String
- * @example
- * ```
- * ensureSuffix('.js', 'index') => 'index.js'
- * ensureSuffix('.js', 'index.js') => 'index.js'
- * ```
- */
-export declare function ensureSuffix(suffix: string, str: string): string;
-/**
- * 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 declare function template(str: string, ...args: any[]): string;
-export declare function truncate(str: string, length: number, end?: string): string;
-/**
- * Generate a random string
- * @category String
- */
-export declare function random(size?: number, dict?: string): string;
-/**
- * Slugify a string
- * @category string
- * @example
- * ```
- * slug('Hello World') => 'hello-world'
- * ```
- */
-export declare function slug(str: string, options?: SlugOptions): string;
-export { default as detectIndent } from 'detect-indent';
-export { detectNewline } from 'detect-newline';