@stacksjs/strings 0.61.24 → 0.63.0

package/dist/index.js

@@ -12,181 +12,41 @@ var __export = (target, all) => {
 // src/string.ts
 var exports_string = {};
 __export(exports_string, {
-  truncate: () => {
-    {
-      return truncate;
-    }
-  },
-  toString: () => {
-    {
-      return toString;
-    }
-  },
-  titleCase: () => {
-    {
-      return titleCase;
-    }
-  },
-  template: () => {
-    {
-      return template;
-    }
-  },
-  str: () => {
-    {
-      return str;
-    }
-  },
-  split: () => {
-    {
-      return split;
-    }
-  },
-  snakeCase: () => {
-    {
-      return snakeCase;
-    }
-  },
-  slug: () => {
-    {
-      return slug;
-    }
-  },
-  slash: () => {
-    {
-      return slash;
-    }
-  },
-  singular: () => {
-    {
-      return singular2;
-    }
-  },
-  sentenceCase: () => {
-    {
-      return sentenceCase;
-    }
-  },
-  random: () => {
-    {
-      return random;
-    }
-  },
-  plural: () => {
-    {
-      return plural2;
-    }
-  },
-  pathCase: () => {
-    {
-      return pathCase;
-    }
-  },
-  pascalCase: () => {
-    {
-      return pascalCase;
-    }
-  },
-  paramCase: () => {
-    {
-      return kebabCase2;
-    }
-  },
-  noCase: () => {
-    {
-      return noCase;
-    }
-  },
-  lowercase: () => {
-    {
-      return lowercase;
-    }
-  },
-  kebabCase: () => {
-    {
-      return kebabCase;
-    }
-  },
-  isSingular: () => {
-    {
-      return isSingular2;
-    }
-  },
-  isPlural: () => {
-    {
-      return isPlural2;
-    }
-  },
-  ensureSuffix: () => {
-    {
-      return ensureSuffix;
-    }
-  },
-  ensurePrefix: () => {
-    {
-      return ensurePrefix;
-    }
-  },
-  dotCase: () => {
-    {
-      return dotCase;
-    }
-  },
-  detectNewline: () => {
-    {
-      return detectNewline;
-    }
-  },
-  detectIndent: () => {
-    {
-      return default2;
-    }
-  },
-  constantCase: () => {
-    {
-      return constantCase;
-    }
-  },
-  capitalize: () => {
-    {
-      return capitalize;
-    }
-  },
-  capitalCase: () => {
-    {
-      return capitalCase;
-    }
-  },
-  camelCase: () => {
-    {
-      return camelCase;
-    }
-  },
-  addUncountableRule: () => {
-    {
-      return addUncountableRule2;
-    }
-  },
-  addSingularRule: () => {
-    {
-      return addSingularRule2;
-    }
-  },
-  addPluralRule: () => {
-    {
-      return addPluralRule2;
-    }
-  },
-  addIrregularRule: () => {
-    {
-      return addIrregularRule2;
-    }
-  },
-  Str: () => {
-    {
-      return Str;
-    }
-  }
+  truncate: () => truncate,
+  toString: () => toString,
+  titleCase: () => titleCase,
+  template: () => template,
+  str: () => str,
+  split: () => split,
+  snakeCase: () => snakeCase,
+  slug: () => slug,
+  slash: () => slash,
+  singular: () => singular2,
+  sentenceCase: () => sentenceCase,
+  random: () => random,
+  plural: () => plural2,
+  pathCase: () => pathCase,
+  pascalCase: () => pascalCase,
+  paramCase: () => kebabCase2,
+  noCase: () => noCase,
+  lowercase: () => lowercase,
+  kebabCase: () => kebabCase,
+  isSingular: () => isSingular2,
+  isPlural: () => isPlural2,
+  ensureSuffix: () => ensureSuffix,
+  ensurePrefix: () => ensurePrefix,
+  dotCase: () => dotCase,
+  detectNewline: () => detectNewline,
+  detectIndent: () => default2,
+  constantCase: () => constantCase,
+  capitalize: () => capitalize,
+  capitalCase: () => capitalCase,
+  camelCase: () => camelCase,
+  addUncountableRule: () => addUncountableRule2,
+  addSingularRule: () => addSingularRule2,
+  addPluralRule: () => addPluralRule2,
+  addIrregularRule: () => addIrregularRule2,
+  Str: () => Str
 });
 
 // src/utils.ts
@@ -404,3 +264,6 @@ export {
   addIrregularRule2 as addIrregularRule,
   Str
 };
+
+//# debugId=272B1643AB5F268164756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,14 @@
+{
+  "version": 3,
+  "sources": ["../src/utils.ts", "../src/case.ts", "../src/pluralize.ts", "../src/macro.ts", "../src/helpers.ts"],
+  "sourcesContent": [
+    "import slugify from 'slugify'\n\ninterface SlugOptions {\n  replacement?: string\n  remove?: RegExp\n  lower?: boolean\n  strict?: boolean\n  locale?: string\n  trim?: boolean\n}\n\n// port from nanoid\n// https://github.com/ai/nanoid\nconst urlAlphabet = 'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'\n\n/**\n * Replace backslash to slash\n *\n * @category String\n * @example\n * ```\n * slash('C:\\\\Users\\\\Chris') => 'C:/Users/Chris'\n * ```\n */\nexport function slash(str: string) {\n  return str.replace(/\\\\/g, '/')\n}\n\n/**\n * Ensure prefix of a string\n *\n * @category String\n * @example\n * ```\n * ensurePrefix('https://', 'google.com') => 'https://google.com'\n * ensurePrefix('https://', 'http://google.com') => 'https://google.com'\n */\nexport function ensurePrefix(prefix: string, str: string) {\n  if (!str.startsWith(prefix)) return prefix + str\n  return str\n}\n\n/**\n * Ensure suffix of a string\n *\n * @category String\n * @example\n * ```\n * ensureSuffix('.js', 'index') => 'index.js'\n * ensureSuffix('.js', 'index.js') => 'index.js'\n * ```\n */\nexport function ensureSuffix(suffix: string, str: string) {\n  return str.endsWith(suffix) ? str : str + suffix\n}\n\n/**\n * Dead simple template engine, just like Python's `.format()`\n *\n * @category String\n * @example\n * ```\n * const result = template('Hello {0}! My name is {1}.',\n *   'Buddy',\n *   'Chris'\n * ) // Hello Buddy! My name is Chris.\n * ```\n */\nexport function template(str: string, ...args: any[]): string {\n  return str.replace(/{(\\d+)}/g, (match, key) => {\n    const index = Number(key)\n\n    return Number.isNaN(index) ? match : args[index]\n  })\n}\n\nexport function truncate(str: string, length: number, end = '...') {\n  if (str.length <= length) return str\n\n  return str.slice(0, length - end.length) + end\n}\n\n/**\n * Generate a random string\n * @category String\n */\nexport function random(size = 16, dict = urlAlphabet) {\n  let id = ''\n  let i = size\n  const len = dict.length\n  while (i--) id += dict[(Math.random() * len) | 0]\n  return id\n}\n\n/**\n * Slugify a string\n * @category string\n * @example\n * ```\n * slug('Hello World') => 'hello-world'\n * ```\n */\nexport function slug(str: string, options?: SlugOptions): string {\n  if (options) return slugify(str, options)\n\n  return slugify(str, {\n    lower: true,\n    strict: true,\n  })\n}\n\nexport { default as detectIndent } from 'detect-indent'\nexport { detectNewline } from 'detect-newline'\n",
+    "/**\n * First letter uppercase, other lowercase\n * @category string\n * @example\n * ```\n * capitalize('hello world') => 'Hello world'\n * ```\n */\nexport function capitalize(str: string): string {\n  return str[0] ? str[0].toUpperCase() + str.slice(1).toLowerCase() : ''\n}\n\nexport function lowercase(str: string): string {\n  return str.toLowerCase()\n}\n\nexport {\n  camelCase,\n  capitalCase,\n  constantCase,\n  dotCase,\n  noCase,\n  kebabCase,\n  kebabCase as paramCase,\n  pascalCase,\n  pathCase,\n  sentenceCase,\n  snakeCase,\n  split,\n} from 'change-case'\nexport { titleCase } from 'title-case'\n",
+    "import * as pluralize from 'pluralize'\n\ntype Rule = string | RegExp\ntype Replacement = string\ntype Word = string\nexport type PluralizeTest = (word: Word) => boolean\n\nexport interface Pluralize {\n  plural: (word: Word, count?: number, inclusive?: boolean) => Word\n  singular: (word: Word) => Word\n  isPlural: (word: Word) => boolean\n  isSingular: (word: Word) => boolean\n  addPluralRule: (rule: Rule, replacement: Replacement) => void\n  addSingularRule: (rule: Rule, replacement: Replacement) => void\n  addIrregularRule: (single: Word, plural: Word) => void\n  addUncountableRule: (word: Word | RegExp) => void\n}\n\nexport const plural: Pluralize['plural'] = (word, count, inclusive) => {\n  if (count !== undefined && inclusive) return `${count} ${pluralize.plural(word)}`\n\n  return pluralize.plural(word)\n}\n\nexport const singular: Pluralize['singular'] = (word) => pluralize.singular(word)\nexport const isPlural: Pluralize['isPlural'] = (word) => pluralize.isPlural(word)\nexport const isSingular: Pluralize['isSingular'] = (word) => pluralize.isSingular(word)\nexport const addPluralRule: Pluralize['addPluralRule'] = (rule, replacement) =>\n  pluralize.addPluralRule(rule, replacement)\nexport const addSingularRule: Pluralize['addSingularRule'] = (rule, replacement) =>\n  pluralize.addSingularRule(rule, replacement)\nexport const addIrregularRule: Pluralize['addIrregularRule'] = (single, plural) =>\n  pluralize.addIrregularRule(single, plural)\nexport const addUncountableRule: Pluralize['addUncountableRule'] = (word) => pluralize.addUncountableRule(word)\n",
+    "import * as c from './case'\nimport * as p from './pluralize'\nimport * as u from './utils'\n\nexport const Str = {\n  slash(str: string) {\n    return u.slash(str)\n  },\n\n  ensurePrefix(prefix: string, str: string) {\n    return u.ensurePrefix(prefix, str)\n  },\n\n  ensureSuffix(suffix: string, str: string) {\n    return u.ensureSuffix(suffix, str)\n  },\n\n  template(str: string, ...args: any[]): string {\n    return u.template(str, ...args)\n  },\n\n  /**\n   * Truncate a string\n   */\n  truncate(str: string, length: number, end = '...') {\n    return u.truncate(str, length, end)\n  },\n\n  random(length = 16) {\n    return u.random(length)\n  },\n\n  capitalize(str: string) {\n    return c.capitalize(str)\n  },\n\n  slug(str: string) {\n    return u.slug(str)\n  },\n\n  detectIndent(str: string) {\n    return u.detectIndent(str)\n  },\n\n  detectNewline(str: string) {\n    return u.detectNewline(str)\n  },\n\n  camelCase(str: string) {\n    return c.camelCase(str)\n  },\n\n  capitalCase(str: string) {\n    return c.capitalCase(str)\n  },\n\n  constantCase(str: string) {\n    return c.constantCase(str)\n  },\n\n  dotCase(str: string) {\n    return c.dotCase(str)\n  },\n\n  noCase(str: string) {\n    return c.noCase(str)\n  },\n\n  paramCase(str: string) {\n    return c.paramCase(str)\n  },\n\n  pascalCase(str: string) {\n    return c.pascalCase(str)\n  },\n\n  pathCase(str: string) {\n    return c.pathCase(str)\n  },\n\n  sentenceCase(str: string) {\n    return c.sentenceCase(str)\n  },\n\n  snakeCase(str: string) {\n    return c.snakeCase(str)\n  },\n\n  titleCase(str: string) {\n    return c.titleCase(str)\n  },\n\n  kebabCase(str: string) {\n    return c.kebabCase(str)\n  },\n\n  plural(str: string) {\n    // plural, singular, isPlural, isSingular, addPluralRule, addSingularRule, addIrregularRule, addUncountableRule\n    return p.plural(str)\n  },\n\n  singular(str: string) {\n    return p.singular(str)\n  },\n\n  isPlural(str: string) {\n    return p.isPlural(str)\n  },\n\n  isSingular(str: string) {\n    return p.isSingular(str)\n  },\n\n  addPluralRule(rule: string | RegExp, repl: string) {\n    return p.addPluralRule(rule, repl)\n  },\n\n  addSingularRule(rule: string | RegExp, repl: string) {\n    return p.addSingularRule(rule, repl)\n  },\n\n  addIrregularRule(single: string, plural: string) {\n    return p.addIrregularRule(single, plural)\n  },\n\n  addUncountableRule(word: string | RegExp) {\n    return p.addUncountableRule(word)\n  },\n}\n\nexport const str = Str\n",
+    "export function toString(v: any) {\n  return Object.prototype.toString.call(v)\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "272B1643AB5F268164756E2164756E21",
+  "names": []
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/strings",
   "type": "module",
-  "version": "0.61.24",
+  "version": "0.63.0",
   "description": "The Stacks string utilities.",
   "author": "Chris Breuer",
   "license": "MIT",
@@ -71,13 +71,13 @@
     "macroable": "^7.0.2",
     "pluralize": "^8.0.0",
     "slugify": "^1.6.6",
-    "string-ts": "^2.1.1",
+    "string-ts": "^2.2.0",
     "title-case": "^4.3.1",
     "validator": "^13.12.0"
   },
   "devDependencies": {
     "@stacksjs/development": "latest",
     "@types/pluralize": "^0.0.33",
-    "@types/validator": "^13.11.10"
+    "@types/validator": "^13.12.0"
   }
 }