@stacksjs/strings 0.53.1 → 0.56.23

package/dist/index.d.ts

@@ -1,6 +1,10 @@
+import pluralize from 'pluralize';
+import * as detect_indent from 'detect-indent';
+export { default as detectIndent } from 'detect-indent';
+import { Macroable } from 'macroable';
+export { detectNewline } from 'detect-newline';
 export { camelCase, capitalCase, constantCase, dotCase, headerCase, paramCase as kebabCase, noCase, paramCase, pascalCase, pathCase, sentenceCase, snakeCase } from 'change-case';
 export { titleCase } from 'title-case';
-import pluralize from 'pluralize';
 
 interface SlugOptions {
     replacement?: string;
@@ -54,29 +58,31 @@ declare function ensureSuffix(suffix: string, str: string): string;
  * ```
  */
 declare function template(str: string, ...args: any[]): string;
+declare function truncate(str: string, length: number, end?: string): string;
 /**
  * Generate a random string
  * @category String
  */
 declare function randomStr(size?: number, dict?: string): string;
 /**
- * First letter uppercase, other lowercase
+ * Slugify a string
  * @category string
  * @example
  * ```
- * capitalize('hello world') => 'Hello world'
+ * slug('Hello World') => 'hello-world'
  * ```
  */
-declare function capitalize(str: string): string;
+declare function slug(str: string, options?: SlugOptions): string;
+
 /**
- * Slugify a string
+ * First letter uppercase, other lowercase
  * @category string
  * @example
  * ```
- * slug('Hello World') => 'hello-world'
+ * capitalize('hello world') => 'Hello world'
  * ```
  */
-declare function slug(str: string, options?: SlugOptions): string;
+declare function capitalize(str: string): string;
 
 declare const plural: typeof pluralize.plural;
 declare const singular: typeof pluralize.singular;
@@ -87,4 +93,44 @@ declare const addSingularRule: typeof pluralize.addSingularRule;
 declare const addIrregularRule: typeof pluralize.addIrregularRule;
 declare const addUncountableRule: typeof pluralize.addUncountableRule;
 
-export { addIrregularRule, addPluralRule, addSingularRule, addUncountableRule, capitalize, ensurePrefix, ensureSuffix, isPlural, isSingular, plural, randomStr, singular, slash, slug, template };
+declare class Str extends Macroable {
+    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): 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;
+    headerCase(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;
+    static macros: {};
+    static getters: {};
+}
+declare const str: Str;
+
+export { Str, addIrregularRule, addPluralRule, addSingularRule, addUncountableRule, capitalize, ensurePrefix, ensureSuffix, isPlural, isSingular, plural, randomStr, singular, slash, slug, str, template, truncate };

package/dist/index.mjs

@@ -1,7 +1,14 @@
+import slugify from 'slugify';
+import detectIndent from 'detect-indent';
+export { default as detectIndent } from 'detect-indent';
+import { detectNewline } from 'detect-newline';
+export { detectNewline } from 'detect-newline';
+import { camelCase, capitalCase, constantCase, dotCase, headerCase, noCase, paramCase, pascalCase, pathCase, sentenceCase, snakeCase } from 'change-case';
 export { camelCase, capitalCase, constantCase, dotCase, headerCase, paramCase as kebabCase, noCase, paramCase, pascalCase, pathCase, sentenceCase, snakeCase } from 'change-case';
+import { titleCase } from 'title-case';
 export { titleCase } from 'title-case';
-import slugify from 'slugify';
 import pluralize from 'pluralize';
+import { Macroable } from 'macroable';
 
 const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
 function slash(str) {
@@ -25,6 +32,11 @@ function template(str, ...args) {
     return args[index];
   });
 }
+function truncate(str, length, end = "...") {
+  if (str.length <= length)
+    return str;
+  return str.slice(0, length - end.length) + end;
+}
 function randomStr(size = 16, dict = urlAlphabet) {
   let id = "";
   let i = size;
@@ -33,9 +45,6 @@ function randomStr(size = 16, dict = urlAlphabet) {
     id += dict[Math.random() * len | 0];
   return id;
 }
-function capitalize(str) {
-  return str[0].toUpperCase() + str.slice(1).toLowerCase();
-}
 function slug(str, options) {
   if (options)
     return slugify(str, options);
@@ -45,6 +54,112 @@ function slug(str, options) {
   });
 }
 
+function capitalize(str) {
+  return str[0].toUpperCase() + str.slice(1).toLowerCase();
+}
+
 const { plural, singular, isPlural, isSingular, addPluralRule, addSingularRule, addIrregularRule, addUncountableRule } = pluralize;
 
-export { addIrregularRule, addPluralRule, addSingularRule, addUncountableRule, capitalize, ensurePrefix, ensureSuffix, isPlural, isSingular, plural, randomStr, singular, slash, slug, template };
+class Str extends Macroable {
+  slash(str2) {
+    return slash(str2);
+  }
+  ensurePrefix(prefix, str2) {
+    return ensurePrefix(prefix, str2);
+  }
+  ensureSuffix(suffix, str2) {
+    return ensureSuffix(suffix, str2);
+  }
+  template(str2, ...args) {
+    return template(str2, ...args);
+  }
+  /**
+   * Truncate a string
+   */
+  truncate(str2, length, end = "...") {
+    return truncate(str2, length, end);
+  }
+  random(length = 16) {
+    return randomStr(length);
+  }
+  capitalize(str2) {
+    return capitalize(str2);
+  }
+  slug(str2) {
+    return slug(str2);
+  }
+  detectIndent(str2) {
+    return detectIndent(str2);
+  }
+  detectNewline(str2) {
+    return detectNewline(str2);
+  }
+  camelCase(str2) {
+    return camelCase(str2);
+  }
+  capitalCase(str2) {
+    return capitalCase(str2);
+  }
+  constantCase(str2) {
+    return constantCase(str2);
+  }
+  dotCase(str2) {
+    return dotCase(str2);
+  }
+  headerCase(str2) {
+    return headerCase(str2);
+  }
+  noCase(str2) {
+    return noCase(str2);
+  }
+  paramCase(str2) {
+    return paramCase(str2);
+  }
+  pascalCase(str2) {
+    return pascalCase(str2);
+  }
+  pathCase(str2) {
+    return pathCase(str2);
+  }
+  sentenceCase(str2) {
+    return sentenceCase(str2);
+  }
+  snakeCase(str2) {
+    return snakeCase(str2);
+  }
+  titleCase(str2) {
+    return titleCase(str2);
+  }
+  kebabCase(str2) {
+    return paramCase(str2);
+  }
+  plural(str2) {
+    return plural(str2);
+  }
+  singular(str2) {
+    return singular(str2);
+  }
+  isPlural(str2) {
+    return isPlural(str2);
+  }
+  isSingular(str2) {
+    return isSingular(str2);
+  }
+  addPluralRule(rule, repl) {
+    return addPluralRule(rule, repl);
+  }
+  addSingularRule(rule, repl) {
+    return addSingularRule(rule, repl);
+  }
+  addIrregularRule(single, plural) {
+    return addIrregularRule(single, plural);
+  }
+  addUncountableRule(word) {
+    return addUncountableRule(word);
+  }
+}
+Str.macros = {};
+Str.getters = {};
+const str = new Str();
+
+export { Str, addIrregularRule, addPluralRule, addSingularRule, addUncountableRule, capitalize, ensurePrefix, ensureSuffix, isPlural, isSingular, plural, randomStr, singular, slash, slug, str, template, truncate };

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@stacksjs/strings",
   "type": "module",
-  "version": "0.53.1",
-  "packageManager": "pnpm@8.5.1",
+  "version": "0.56.23",
+  "packageManager": "pnpm@8.6.5",
   "description": "The Stacks string utilities.",
   "author": "Chris Breuer",
   "license": "MIT",
@@ -40,6 +40,7 @@
       "import": "./dist/index.mjs"
     }
   },
+  "main": "dist/index.mjs",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
   "contributors": [
@@ -53,15 +54,21 @@
     "@types/pluralize": "^0.0.29",
     "@types/validator": "^13.7.17",
     "change-case": "^4.1.2",
+    "detect-indent": "^7.0.1",
+    "detect-newline": "^4.0.0",
+    "macroable": "^7.0.2",
     "pluralize": "^8.0.0",
     "slugify": "^1.6.6",
     "title-case": "^3.0.3",
     "validator": "^13.9.0",
-    "@stacksjs/alias": "0.53.1",
-    "@stacksjs/types": "0.53.1"
+    "@stacksjs/alias": "0.56.23",
+    "@stacksjs/types": "0.56.23"
+  },
+  "dependencies": {
+    "macroable": "^7.0.2"
   },
   "devDependencies": {
-    "@stacksjs/development": "0.53.1"
+    "@stacksjs/development": "0.56.23"
   },
   "scripts": {
     "build": "unbuild",