@stacksjs/strings 0.70.23 → 0.70.26

package/dist/{case.d.ts → src/case.d.ts}

@@ -1,36 +1,91 @@
+/**
+ * First letter uppercase, other lowercase
+ * @category string
+ * @example
+ * ```
+ * capitalize('hello world') => 'Hello world'
+ * ```
+ */
 export declare function capitalize(str: string): string;
 export declare function lowercase(str: string): string;
-declare const DEFAULT_PREFIX_SUFFIX_CHARACTERS: unknown;
-export declare type Locale = string[] | string | false | undefined
-
-export interface PascalCaseOptions extends CaseOptions {
-  mergeAmbiguousCharacters?: boolean
-}
-
-export interface CaseOptions {
-  locale?: Locale
-  split?: (value: string) => string[]
-  delimiter?: string
-  prefixCharacters?: string
-  suffixCharacters?: string
-}
+/**
+ * Split any cased input strings into an array of words.
+ */
 export declare function split(value: string): string[];
+/**
+ * Split the input string into an array of words, separating numbers.
+ */
 export declare function splitSeparateNumbers(value: string): string[];
+/**
+ * Convert a string to space separated lower case (`foo bar`).
+ */
 export declare function noCase(input: string, options?: CaseOptions): string;
+/**
+ * Convert a string to camel case (`fooBar`).
+ */
 export declare function camelCase(input: string, options?: PascalCaseOptions): string;
+/**
+ * Convert a string to pascal case (`FooBar`).
+ */
 export declare function pascalCase(input: string, options?: PascalCaseOptions): string;
+/**
+ * Convert a string to pascal snake case (`Foo_Bar`).
+ */
 export declare function pascalSnakeCase(input: string, options?: CaseOptions): string;
+/**
+ * Convert a string to capital case (`Foo Bar`).
+ */
 export declare function capitalCase(input: string, options?: CaseOptions): string;
+/**
+ * Convert a string to constant case (`FOO_BAR`).
+ */
 export declare function constantCase(input: string, options?: CaseOptions): string;
+/**
+ * Convert a string to dot case (`foo.bar`).
+ */
 export declare function dotCase(input: string, options?: CaseOptions): string;
+/**
+ * Convert a string to kebab case (`foo-bar`).
+ */
 export declare function kebabCase(input: string, options?: CaseOptions): string;
+/**
+ * Convert a string to path case (`foo/bar`).
+ */
 export declare function pathCase(input: string, options?: CaseOptions): string;
+/**
+ * Convert a string to path case (`Foo bar`).
+ */
 export declare function sentenceCase(input: string, options?: CaseOptions): string;
+/**
+ * Convert a string to snake case (`foo_bar`).
+ */
 export declare function snakeCase(input: string, options?: CaseOptions): string;
+/**
+ * Convert a string to header case (`Foo-Bar`).
+ */
 export declare function trainCase(input: string, options?: CaseOptions): string;
 export declare function paramCase(input: string, options?: CaseOptions): string;
-declare function lowerFactory(locale: Locale): (input: string) => string;
-declare function upperFactory(locale: Locale): (input: string) => string;
-declare function capitalCaseTransformFactory(lower: (input: string)): void;
-declare function pascalCaseTransformFactory(lower: (input: string)): void;
-declare function splitPrefixSuffix(input: string, options: CaseOptions): [string, string[], string];
+/**
+ * Options used for converting strings to pascal/camel case.
+ */
+export declare interface PascalCaseOptions extends CaseOptions {
+  mergeAmbiguousCharacters?: boolean
+}
+/**
+ * Options used for converting strings to any case.
+ */
+export declare interface CaseOptions {
+  locale?: Locale
+  split?: (value: string) => string[]
+  delimiter?: string
+  prefixCharacters?: string
+  suffixCharacters?: string
+}
+/**
+ * Supported locale values. Use `false` to ignore locale.
+ * Defaults to `undefined`, which uses the host environment.
+ */
+export type Locale = string[] | string | false | undefined;
+export * from './sponge-case';
+export * from './swap-case';
+export * from './title-case';

package/dist/src/detect-indent.d.ts

@@ -0,0 +1,2 @@
+export declare function detectIndent(string: string): { amount: number, type?: string, indent: string };
+export default detectIndent;

package/dist/{detect-newline.d.ts → src/detect-newline.d.ts}

@@ -1,2 +1,2 @@
 export declare function detectNewline(string: string): string | undefined;
-export declare function detectNewlineGraceful(string: string): string;
+export declare function detectNewlineGraceful(string: string): string;

package/dist/src/helpers.d.ts

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

package/dist/src/index.d.ts

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

package/dist/src/macro.d.ts

@@ -0,0 +1,36 @@
+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, dict?: string) => string;
+  capitalize: (str: string) => string;
+  slug: (str: string) => string;
+  detectIndent: (str: string) => ;
+  detectNewline: (str: string) => string | 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/src/pluralize.d.ts

@@ -0,0 +1,20 @@
+export declare const pluralize: PluralizeFunction;
+export declare const singular: PluralizeFunction;
+export declare const plural: PluralizeFunction;
+export declare interface PluralizeOptions {
+  count?: number
+  inclusive?: boolean
+}
+declare interface PluralizeFunction {
+  (word: string, options?: PluralizeOptions): string
+  plural: (word: string) => string
+  isPlural: (word: string) => boolean
+  singular: (word: string) => string
+  isSingular: (word: string) => boolean
+  addPluralRule: (rule: StringOrRegExp, replacement: string) => void
+  addSingularRule: (rule: StringOrRegExp, replacement: string) => void
+  addUncountableRule: (word: string | RegExp) => void
+  addIrregularRule: (single: string, plural: string) => void
+}
+declare type Rule = [RegExp, string];
+declare type StringOrRegExp = string | RegExp;

package/dist/src/slug.d.ts

@@ -0,0 +1,13 @@
+export declare function slugify(string: string, options?: SlugifyOptions): string;
+export declare function extendCharMap(customMap: CharMap): void;
+// thanks to https://github.com/simov/slugify for much of this code
+export declare interface SlugifyOptions {
+  replacement?: string
+  remove?: RegExp
+  lower?: boolean
+  strict?: boolean
+  locale?: string
+  trim?: boolean
+}
+declare type CharMap = Record<string, string>;
+declare type LocaleMap = Record<string, CharMap>;

package/dist/src/sponge-case.d.ts

@@ -0,0 +1,2 @@
+// thanks to https://github.com/blakeembrey/change-case/blob/main/packages/sponge-case/src/index.ts
+export declare function spongeCase(input: string, locale?: string[] | string): string;

package/dist/src/string.d.ts

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

package/dist/src/swap-case.d.ts

@@ -0,0 +1,2 @@
+// thanks to https://github.com/blakeembrey/change-case/blob/main/packages/swap-case/src/index.ts
+export declare function swapCase(input: string, locale?: string[] | string): string;

package/dist/{title-case.d.ts → src/title-case.d.ts}

@@ -1,3 +1,4 @@
+export declare function titleCase(input: string, options?: TitleCaseOptions | string[] | string): string;
 export declare const WORD_SEPARATORS: Set<string>;
 export declare const SENTENCE_TERMINATORS: Set<string>;
 export declare const TITLE_TERMINATORS: Set<string>;
@@ -10,5 +11,3 @@ export declare interface TitleCaseOptions {
   titleTerminators?: Set<string>
   wordSeparators?: Set<string>
 }
-export declare function titleCase(input: string, options: TitleCaseOptions | string[] | string): string;
-declare function upperAt(input: string, index: number, locale: string | string[] | undefined): void;

package/dist/src/utils.d.ts

@@ -0,0 +1,78 @@
+/**
+ * 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.
+ *
+ * Uses `crypto.getRandomValues()` so the result is suitable for tokens,
+ * password reset codes, API keys, and any other security-sensitive use —
+ * `Math.random()` is predictable and would let an attacker reproduce
+ * "random" tokens given enough sample output.
+ *
+ * @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;
+// port from nanoid
+// https://github.com/ai/nanoid
+export declare const urlAlphabet: 'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict';
+declare interface SlugOptions {
+  replacement?: string
+  remove?: RegExp
+  lower?: boolean
+  strict?: boolean
+  locale?: string
+  trim?: boolean
+}
+export * from './detect-indent';
+export * from './detect-newline';

package/dist/{is.d.ts → src/validators.d.ts}

@@ -1,44 +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;
-export declare function isAlphanumeric(username: string): boolean;
-export declare function validateUsername(username: 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;
-export declare function isAlpha(name: 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;
-export declare function isNumeric(number: 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;
-export declare function isLatLong(latitude: string): boolean;
-export declare function isLatitude(longitude: string): boolean;
-export declare function isLongitude(longitude: 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;
-export declare function isByteLength(byteLength: 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;
-export declare function isISO31661Alpha3(iso31661Alpha3: 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/package.json

@@ -1,10 +1,12 @@
 {
   "name": "@stacksjs/strings",
   "type": "module",
-  "version": "0.70.23",
+  "version": "0.70.26",
   "description": "The Stacks string utilities.",
   "author": "Chris Breuer",
-  "contributors": ["Chris Breuer <chris@stacksjs.org>"],
+  "contributors": [
+    "Chris Breuer <chris@stacksjs.com>"
+  ],
   "license": "MIT",
   "funding": "https://github.com/sponsors/chrisbbreuer",
   "homepage": "https://github.com/stacksjs/stacks/tree/main/storage/framework/core/strings#readme",
@@ -36,15 +38,21 @@
   ],
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
+      "bun": "./src/index.ts",
       "import": "./dist/index.js"
     },
     "./*": {
+      "bun": "./src/*",
       "import": "./dist/*"
     }
   },
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
-  "files": ["README.md", "dist"],
+  "files": [
+    "README.md",
+    "dist"
+  ],
   "scripts": {
     "build": "bun build.ts",
     "typecheck": "bun tsc --noEmit",
@@ -52,11 +60,9 @@
     "prepublishOnly": "bun run build"
   },
   "devDependencies": {
-    "@stacksjs/alias": "0.70.22",
-    "@stacksjs/development": "0.70.22",
-    "@stacksjs/types": "0.70.22",
-    "@types/validator": "^13.12.3",
-    "macroable": "^7.0.2",
-    "validator": "^13.15.0"
-  }
+    "@stacksjs/alias": "0.70.23",
+    "better-dx": "^0.2.12",
+    "@stacksjs/types": "0.70.23"
+  },
+  "sideEffects": false
 }

package/dist/detect-indent.d.ts

@@ -1,9 +0,0 @@
-declare const INDENT_TYPE_SPACE: 'space' const INDENT_TYPE_TAB = 'tab';
-declare function makeIndentsMap(string: string, ignoreSingleSpaces: boolean): void;
-declare function encodeIndentsKey(indentType: any, indentAmount: any): void;
-declare function decodeIndentsKey(indentsKey: any): void;
-declare function getMostUsedKey(indents: any): void;
-declare function makeIndentString(type: any, amount: any): void;
-export declare function detectIndent(string: string): void;
-
-export default detectIndent;

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,35 +0,0 @@
-export declare const Str: {
-  slash: (str: string) => void;
-  ensurePrefix: (prefix: string, str: string) => void;
-  ensureSuffix: (suffix: string, str: string) => void;
-  template: (str: string, ...args: any[]) => void;
-  * Truncate a string
-   */
-  truncate: () => unknown;
-  random: (length, dict?: string) => void;
-  capitalize: (str: string) => void;
-  slug: (str: string) => void;
-  detectIndent: (str: string) => void;
-  detectNewline: (str: string) => void;
-  camelCase: (str: string) => void;
-  capitalCase: (str: string) => void;
-  constantCase: (str: string) => void;
-  dotCase: (str: string) => void;
-  noCase: (str: string) => void;
-  paramCase: (str: string) => void;
-  pascalCase: (str: string) => void;
-  pathCase: (str: string) => void;
-  sentenceCase: (str: string) => void;
-  snakeCase: (str: string) => void;
-  titleCase: (str: string) => void;
-  kebabCase: (str: string) => void;
-  plural: (str: string) => void;
-  singular: (str: string) => void;
-  isPlural: (str: string) => void;
-  isSingular: (str: string) => void;
-  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

@@ -1,33 +0,0 @@
-export declare interface PluralizeOptions {
-  count?: number
-  inclusive?: boolean
-}
-declare type Rule = [RegExp, string]
-type StringOrRegExp = string | RegExp
-
-interface PluralizeFunction {
-  (word: string, options?: PluralizeOptions): string
-  plural: (word: string) => string
-  isPlural: (word: string) => boolean
-  singular: (word: string) => string
-  isSingular: (word: string) => boolean
-  addPluralRule: (rule: StringOrRegExp, replacement: string) => void
-  addSingularRule: (rule: StringOrRegExp, replacement: string) => void
-  addUncountableRule: (word: string | RegExp) => void
-  addIrregularRule: (single: string, plural: string) => void
-}
-
-const pluralRules: Rule[] = []
-const singularRules: Rule[] = []
-const uncountables: Record<string, boolean> = {}
-const irregularPlurals: Record<string, string> = {}
-const irregularSingles: Record<string, string> = {}
-declare function sanitizeRule(rule: string | RegExp): RegExp;
-declare function restoreCase(word: string, token: string): string;
-declare function interpolate(str: string, ...args: any[]): string;
-declare function replace(word: string, rule: Rule): string;
-declare function sanitizeWord(token: string, word: string, rules: Rule[]): string;
-declare function replaceWord(replaceMap: Record<string, string>, keepMap: Record<string, string>, rules: Rule[]): (word: string) => string;
-declare function checkWord(replaceMap: Record<string, string>, keepMap: Record<string, string>, rules: Rule[]): (word: string) => boolean;
-
-export default pluralize;