@stacksjs/strings 0.65.0 → 0.68.0

package/dist/is.d.ts

@@ -1,4 +1,5 @@
-import type { HashAlgorithm } from "@stacksjs/types";
+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;
@@ -40,4 +41,4 @@ 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;
+export declare function isISO31661Alpha3(iso31661Alpha3: string): boolean;

package/dist/macro.d.ts

@@ -1,37 +1,35 @@
 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;
+  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: number, 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;
+export declare const str: typeof Str;

package/dist/pluralize.d.ts

@@ -1,23 +1,32 @@
-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 interface PluralizeOptions {
+  count?: number
+  inclusive?: boolean
 }
-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 {};
+declare type Rule = [RegExp, string]
+type StringOrRegExp = string | RegExp
+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 const pluralRules: Rule[];
+declare const irregularPlurals: 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 { return (word: string) => { const token = word.toLowerCase() if (keepMap[token]) return restoreCase(word, token) if (replaceMap[token]) return restoreCase(word, replaceMap[token]) return sanitizeWord(token, word, rules) } };
+declare function checkWord(replaceMap: Record<string, string>, keepMap: Record<string, string>, rules: Rule[]): (word: string) => boolean { return (word: string) => { const token = word.toLowerCase() if (keepMap[token]) return true if (replaceMap[token]) return false return sanitizeWord(token, token, rules) === token } };
+export declare const pluralize: PluralizeFunction;
+export declare const singular: PluralizeFunction;
+export declare const plural: PluralizeFunction;
+declare const lowerPlural: unknown;
+
+export default pluralize;

package/dist/slug.d.ts

@@ -0,0 +1,13 @@
+export declare interface SlugifyOptions {
+  replacement?: string
+  remove?: RegExp
+  lower?: boolean
+  strict?: boolean
+  locale?: string
+  trim?: boolean
+}
+declare type CharMap = Record<string, string>
+type LocaleMap = Record<string, CharMap>
+declare const locales: LocaleMap;
+export declare function slugify(string: string, options: SlugifyOptions = {}): string;
+export declare function extendCharMap(customMap: CharMap): void;

package/dist/sponge-case.d.ts

@@ -0,0 +1 @@
+export declare function spongeCase(input: string, locale?: string[] | string): string;

package/dist/string.d.ts

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

package/dist/swap-case.d.ts

@@ -0,0 +1 @@
+export declare function swapCase(input: string, locale?: string[] | string): string;

package/dist/title-case.d.ts

@@ -0,0 +1,14 @@
+export declare const WORD_SEPARATORS: Set<string>;
+export declare const SENTENCE_TERMINATORS: Set<string>;
+export declare const TITLE_TERMINATORS: Set<string>;
+export declare const SMALL_WORDS: Set<string>;
+export declare interface TitleCaseOptions {
+  locale?: string | string[]
+  sentenceCase?: boolean
+  sentenceTerminators?: Set<string>
+  smallWords?: Set<string>
+  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/utils.d.ts

@@ -1,70 +1,18 @@
-interface SlugOptions {
-	replacement?: string;
-	remove?: RegExp;
-	lower?: boolean;
-	strict?: boolean;
-	locale?: string;
-	trim?: boolean;
+declare 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 const urlAlphabet: (...args: any[]) => unknown;
 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 truncate(str: string, length: number, end = '...'): string;
+export declare function random(size = 16, dict: string = urlAlphabet): string;
 export declare function slug(str: string, options?: SlugOptions): string;
-export { default as detectIndent } from "detect-indent";
-export { detectNewline } from "detect-newline";
+export * from './detect-indent'
+export * from './detect-newline'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/strings",
   "type": "module",
-  "version": "0.65.0",
+  "version": "0.68.0",
   "description": "The Stacks string utilities.",
   "author": "Chris Breuer",
   "contributors": ["Chris Breuer <chris@stacksjs.org>"],
@@ -36,17 +36,15 @@
   ],
   "exports": {
     ".": {
-      "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", "src"],
+  "files": ["README.md", "dist"],
   "scripts": {
     "build": "bun build.ts",
     "typecheck": "bun tsc --noEmit",
@@ -54,21 +52,13 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@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",
     "macroable": "^7.0.2",
-    "pluralize": "^8.0.0",
-    "slugify": "^1.6.6",
-    "string-ts": "^2.2.0",
-    "title-case": "^4.3.2",
     "validator": "^13.12.0"
   },
   "devDependencies": {
-    "@stacksjs/development": "0.64.6",
-    "@types/pluralize": "^0.0.33",
+    "@stacksjs/alias": "0.67.0",
+    "@stacksjs/development": "0.67.0",
+    "@stacksjs/types": "0.67.0",
     "@types/validator": "^13.12.2"
   }
 }