@stacksjs/strings 0.64.6 → 0.65.0

package/dist/is.d.ts

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

package/dist/macro.d.ts

@@ -0,0 +1,37 @@
+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(str: string, length: number, end?: string): string;
+	random(length?: number, dict?: string): string;
+	capitalize(str: string): string;
+	slug(str: string): string;
+	detectIndent(str: string): {
+		amount: number;
+		type: string | undefined;
+		indent: string;
+	};
+	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: typeof Str;

package/dist/pluralize.d.ts

@@ -0,0 +1,23 @@
+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

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

package/dist/types.d.ts

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

package/dist/utils.d.ts

@@ -0,0 +1,70 @@
+interface SlugOptions {
+	replacement?: string;
+	remove?: RegExp;
+	lower?: boolean;
+	strict?: boolean;
+	locale?: string;
+	trim?: boolean;
+}
+export declare const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+/**
+* 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";

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@stacksjs/strings",
   "type": "module",
-  "version": "0.64.6",
+  "version": "0.65.0",
   "description": "The Stacks string utilities.",
   "author": "Chris Breuer",
+  "contributors": ["Chris Breuer <chris@stacksjs.org>"],
   "license": "MIT",
   "funding": "https://github.com/sponsors/chrisbbreuer",
   "homepage": "https://github.com/stacksjs/stacks/tree/main/storage/framework/core/strings#readme",
@@ -45,22 +46,16 @@
   },
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
-  "contributors": [
-    "Chris Breuer <chris@stacksjs.org>"
-  ],
-  "files": [
-    "README.md",
-    "dist",
-    "src"
-  ],
+  "files": ["README.md", "dist", "src"],
   "scripts": {
-    "build": "bun --bun build.ts",
-    "typecheck": "bun --bun tsc --noEmit",
+    "build": "bun build.ts",
+    "typecheck": "bun tsc --noEmit",
+    "test": "bun test",
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@stacksjs/alias": "latest",
-    "@stacksjs/types": "latest",
+    "@stacksjs/alias": "0.64.6",
+    "@stacksjs/types": "0.64.6",
     "change-case": "^5.4.4",
     "detect-indent": "^7.0.1",
     "detect-newline": "^4.0.1",
@@ -68,12 +63,12 @@
     "pluralize": "^8.0.0",
     "slugify": "^1.6.6",
     "string-ts": "^2.2.0",
-    "title-case": "^4.3.1",
+    "title-case": "^4.3.2",
     "validator": "^13.12.0"
   },
   "devDependencies": {
-    "@stacksjs/development": "latest",
+    "@stacksjs/development": "0.64.6",
     "@types/pluralize": "^0.0.33",
-    "@types/validator": "^13.12.1"
+    "@types/validator": "^13.12.2"
   }
 }

package/src/case.ts

@@ -19,9 +19,9 @@ export {
   capitalCase,
   constantCase,
   dotCase,
-  noCase,
   kebabCase,
   kebabCase as paramCase,
+  noCase,
   pascalCase,
   pathCase,
   sentenceCase,

package/src/helpers.ts

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

package/src/is.ts

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

package/src/macro.ts

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

package/src/pluralize.ts

@@ -17,18 +17,19 @@ export interface Pluralize {
 }
 
 export const plural: Pluralize['plural'] = (word, count, inclusive) => {
-  if (count !== undefined && inclusive) return `${count} ${pluralize.plural(word)}`
+  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 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)
+export const addUncountableRule: Pluralize['addUncountableRule'] = word => pluralize.addUncountableRule(word)

package/src/string.ts

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