@stacksjs/strings 0.70.88 → 0.70.91

package/dist/case.d.ts

@@ -0,0 +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;
+/**
+ * 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;
+/**
+ * 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/case.js

@@ -0,0 +1,133 @@
+export function capitalize(str) {
+  return str[0] ? str[0].toUpperCase() + str.slice(1).toLowerCase() : "";
+}
+export function lowercase(str) {
+  return str.toLowerCase();
+}
+const SPLIT_LOWER_UPPER_RE = /([\p{Ll}\d])(\p{Lu})/gu, SPLIT_UPPER_UPPER_RE = /(\p{Lu})(\p{Lu}\p{Ll})/gu, SPLIT_SEPARATE_NUMBER_RE = /(\d)\p{Ll}|(\p{L})\d/u, DEFAULT_STRIP_REGEXP = /[^\p{L}\d]+/giu, SPLIT_REPLACE_VALUE = "$1\x00$2", DEFAULT_PREFIX_SUFFIX_CHARACTERS = "";
+export function split(value) {
+  let result = value.trim();
+  result = result.replace(SPLIT_LOWER_UPPER_RE, SPLIT_REPLACE_VALUE).replace(SPLIT_UPPER_UPPER_RE, SPLIT_REPLACE_VALUE);
+  result = result.replace(DEFAULT_STRIP_REGEXP, "\x00");
+  let start = 0, end = result.length;
+  while (result.charAt(start) === "\x00")
+    start++;
+  if (start === end)
+    return [];
+  while (result.charAt(end - 1) === "\x00")
+    end--;
+  return result.slice(start, end).split(/\0/g);
+}
+export function splitSeparateNumbers(value) {
+  const words = split(value);
+  for (let i = 0;i < words.length; i++) {
+    const word = words[i];
+    if (word === void 0)
+      continue;
+    const match = SPLIT_SEPARATE_NUMBER_RE.exec(word);
+    if (match) {
+      const offset = match.index + (match[1] ?? match[2] ?? "").length;
+      words.splice(i, 1, word.slice(0, offset), word.slice(offset));
+    }
+  }
+  return words;
+}
+export function noCase(input, options) {
+  const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+  return prefix + words.map(lowerFactory(options?.locale)).join(options?.delimiter ?? " ") + suffix;
+}
+export function camelCase(input, options) {
+  const [prefix, words, suffix] = splitPrefixSuffix(input, options), lower = lowerFactory(options?.locale), upper = upperFactory(options?.locale), transform = options?.mergeAmbiguousCharacters ? capitalCaseTransformFactory(lower, upper) : pascalCaseTransformFactory(lower, upper);
+  return prefix + words.map((word, index) => {
+    if (index === 0)
+      return lower(word);
+    return transform(word, index);
+  }).join(options?.delimiter ?? "") + suffix;
+}
+export function pascalCase(input, options) {
+  const [prefix, words, suffix] = splitPrefixSuffix(input, options), lower = lowerFactory(options?.locale), upper = upperFactory(options?.locale), transform = options?.mergeAmbiguousCharacters ? capitalCaseTransformFactory(lower, upper) : pascalCaseTransformFactory(lower, upper);
+  return prefix + words.map(transform).join(options?.delimiter ?? "") + suffix;
+}
+export function pascalSnakeCase(input, options) {
+  return capitalCase(input, { delimiter: "_", ...options });
+}
+export function capitalCase(input, options) {
+  const [prefix, words, suffix] = splitPrefixSuffix(input, options), lower = lowerFactory(options?.locale), upper = upperFactory(options?.locale);
+  return prefix + words.map(capitalCaseTransformFactory(lower, upper)).join(options?.delimiter ?? " ") + suffix;
+}
+export function constantCase(input, options) {
+  const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+  return prefix + words.map(upperFactory(options?.locale)).join(options?.delimiter ?? "_") + suffix;
+}
+export function dotCase(input, options) {
+  return noCase(input, { delimiter: ".", ...options });
+}
+export function kebabCase(input, options) {
+  return noCase(input, { delimiter: "-", ...options });
+}
+export function pathCase(input, options) {
+  return noCase(input, { delimiter: "/", ...options });
+}
+export function sentenceCase(input, options) {
+  const [prefix, words, suffix] = splitPrefixSuffix(input, options), lower = lowerFactory(options?.locale), upper = upperFactory(options?.locale), transform = capitalCaseTransformFactory(lower, upper);
+  return prefix + words.map((word, index) => {
+    if (index === 0)
+      return transform(word);
+    return lower(word);
+  }).join(options?.delimiter ?? " ") + suffix;
+}
+export function snakeCase(input, options) {
+  return noCase(input, { delimiter: "_", ...options });
+}
+export function trainCase(input, options) {
+  return capitalCase(input, { delimiter: "-", ...options });
+}
+export function paramCase(input, options) {
+  return kebabCase(input, options);
+}
+function lowerFactory(locale) {
+  return locale === !1 ? (input) => input.toLowerCase() : (input) => input.toLocaleLowerCase(locale);
+}
+function upperFactory(locale) {
+  return locale === !1 ? (input) => input.toUpperCase() : (input) => input.toLocaleUpperCase(locale);
+}
+function capitalCaseTransformFactory(lower, upper) {
+  return (word) => {
+    if (!word)
+      return word;
+    return `${upper(word[0] ?? "")}${lower(word.slice(1))}`;
+  };
+}
+function pascalCaseTransformFactory(lower, upper) {
+  return (word, index) => {
+    if (!word)
+      return word;
+    const char0 = word[0] ?? "";
+    return (index > 0 && char0 >= "0" && char0 <= "9" ? `_${char0}` : upper(char0)) + lower(word.slice(1));
+  };
+}
+function splitPrefixSuffix(input, options = {}) {
+  const splitFn = options.split ?? split, prefixCharacters = options.prefixCharacters ?? DEFAULT_PREFIX_SUFFIX_CHARACTERS, suffixCharacters = options.suffixCharacters ?? DEFAULT_PREFIX_SUFFIX_CHARACTERS;
+  let prefixIndex = 0, suffixIndex = input.length;
+  while (prefixIndex < input.length) {
+    const char = input.charAt(prefixIndex);
+    if (!prefixCharacters.includes(char))
+      break;
+    prefixIndex++;
+  }
+  while (suffixIndex > prefixIndex) {
+    const index = suffixIndex - 1, char = input.charAt(index);
+    if (!suffixCharacters.includes(char))
+      break;
+    suffixIndex = index;
+  }
+  return [
+    input.slice(0, prefixIndex),
+    splitFn(input.slice(prefixIndex, suffixIndex)),
+    input.slice(suffixIndex)
+  ];
+}
+
+export * from "./sponge-case";
+export * from "./swap-case";
+export * from "./title-case";

package/dist/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-indent.js

@@ -0,0 +1,72 @@
+const INDENT_REGEX = /^(?:( )+|\t+)/, INDENT_TYPE_SPACE = "space", INDENT_TYPE_TAB = "tab";
+function makeIndentsMap(string, ignoreSingleSpaces = !0) {
+  const indents = new Map;
+  let previousSize = 0, previousIndentType, key = "";
+  for (const line of string.split(/\n/g)) {
+    if (!line)
+      continue;
+    let indent, indentType, use, weight, entry;
+    const matches = line.match(INDENT_REGEX);
+    if (matches === null) {
+      previousSize = 0;
+      previousIndentType = "";
+    } else {
+      indent = matches[0].length;
+      indentType = matches[1] ? INDENT_TYPE_SPACE : INDENT_TYPE_TAB;
+      if (ignoreSingleSpaces && indentType === INDENT_TYPE_SPACE && indent === 1)
+        continue;
+      if (indentType !== previousIndentType)
+        previousSize = 0;
+      previousIndentType = indentType;
+      use = 1;
+      weight = 0;
+      const indentDifference = indent - previousSize;
+      previousSize = indent;
+      if (indentDifference === 0) {
+        use = 0;
+        weight = 1;
+      } else {
+        const absoluteIndentDifference = indentDifference > 0 ? indentDifference : -indentDifference;
+        key = encodeIndentsKey(indentType, absoluteIndentDifference);
+      }
+      entry = indents.get(key);
+      entry = entry === void 0 ? [1, 0] : [entry[0] + use, entry[1] + weight];
+      indents.set(key, entry);
+    }
+  }
+  return indents;
+}
+function encodeIndentsKey(indentType, indentAmount) {
+  return (indentType === INDENT_TYPE_SPACE ? "s" : "t") + String(indentAmount);
+}
+function decodeIndentsKey(indentsKey) {
+  const type = indentsKey[0] === "s" ? INDENT_TYPE_SPACE : INDENT_TYPE_TAB, amount = Number(indentsKey.slice(1));
+  return { type, amount };
+}
+function getMostUsedKey(indents) {
+  let result, maxUsed = 0, maxWeight = 0;
+  for (const [key, [usedCount, weight]] of indents)
+    if (usedCount > maxUsed || usedCount === maxUsed && weight > maxWeight) {
+      maxUsed = usedCount;
+      maxWeight = weight;
+      result = key;
+    }
+  return result;
+}
+function makeIndentString(type, amount) {
+  return (type === INDENT_TYPE_SPACE ? " " : "\t").repeat(amount);
+}
+export function detectIndent(string) {
+  if (typeof string !== "string")
+    throw TypeError("Expected a string");
+  let indents = makeIndentsMap(string, !0);
+  if (indents.size === 0)
+    indents = makeIndentsMap(string, !1);
+  const keyOfMostUsedIndent = getMostUsedKey(indents), decoded = keyOfMostUsedIndent !== void 0 ? decodeIndentsKey(keyOfMostUsedIndent) : void 0, type = decoded?.type, amount = decoded?.amount ?? 0, indent = decoded ? makeIndentString(type, amount) : "";
+  return {
+    amount,
+    type,
+    indent
+  };
+}
+export default detectIndent;

package/dist/detect-newline.d.ts

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

package/dist/detect-newline.js

@@ -0,0 +1,16 @@
+export function detectNewline(string) {
+  if (typeof string !== "string")
+    throw TypeError("Expected a string");
+  const newlines = string.match(/\r?\n/g) || [];
+  if (newlines.length === 0)
+    return;
+  const crlf = newlines.filter((newline) => newline === `\r
+`).length, lf = newlines.length - crlf;
+  return crlf > lf ? `\r
+` : `
+`;
+}
+export function detectNewlineGraceful(string) {
+  return typeof string === "string" && detectNewline(string) || `
+`;
+}

package/dist/helpers.d.ts

@@ -0,0 +1,23 @@
+export declare function toString(v: any): string;
+/**
+ * Mask a portion of a string with a repeated character, Laravel-style
+ * (stacksjs/stacks#314).
+ *
+ * Useful for redacting PII in logs (credit card middle, phone digits,
+ * email local part) without losing the format. The mask character is
+ * repeated for `length` characters starting at `index`; `length` defaults
+ * to "all remaining characters from index to end of string."
+ *
+ * `index` is the character offset, not a byte offset. Negative `index`
+ * counts from the end of the string (`-4` = "start four characters from
+ * the end"). An out-of-range `index` returns the original string.
+ *
+ * @example
+ * ```ts
+ * mask('1234567890123456', '*', 4, 8)   // → '1234********3456'
+ * mask('1234567890123456', '*', 4)      // → '1234************'
+ * mask('1234567890123456', '*', -4, 4)  // → '123456789012****'
+ * mask('hello@example.com', '*', 1, 4)  // → 'h****@example.com'
+ * ```
+ */
+export declare function mask(value: string, character: string, index: number, length?: number): string;

package/dist/helpers.js

@@ -0,0 +1,15 @@
+export function toString(v) {
+  return Object.prototype.toString.call(v);
+}
+export function mask(value, character, index, length) {
+  if (character === "")
+    return value;
+  const len = value.length, start = index < 0 ? Math.max(0, len + index) : index;
+  if (start >= len)
+    return value;
+  const maskLen = length === void 0 ? len - start : Math.max(0, length);
+  if (maskLen === 0)
+    return value;
+  const end = Math.min(len, start + maskLen), fill = character.charAt(0).repeat(end - start);
+  return value.slice(0, start) + fill + value.slice(end);
+}

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/is.d.ts

@@ -0,0 +1,5 @@
+/**
+ * String validation utilities
+ * Re-exports from native validators
+ */
+export * from './validators';

package/dist/is.js

@@ -0,0 +1 @@
+export * from "./validators";

package/dist/macro.d.ts

@@ -0,0 +1,40 @@
+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) => {
+    amount: number
+    indent: string
+    type?: string | undefined
+  };
+  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/macro.js

@@ -0,0 +1,95 @@
+import * as c from "./case";
+import p from "./pluralize";
+import * as u from "./utils";
+export const Str = {
+  slash(str) {
+    return u.slash(str);
+  },
+  ensurePrefix(prefix, str) {
+    return u.ensurePrefix(prefix, str);
+  },
+  ensureSuffix(suffix, str) {
+    return u.ensureSuffix(suffix, str);
+  },
+  template(str, ...args) {
+    return u.template(str, ...args);
+  },
+  truncate(str, length, end = "...") {
+    return u.truncate(str, length, end);
+  },
+  random(length = 16, dict) {
+    return u.random(length, dict);
+  },
+  capitalize(str) {
+    return c.capitalize(str);
+  },
+  slug(str) {
+    return u.slug(str);
+  },
+  detectIndent(str) {
+    return u.detectIndent(str);
+  },
+  detectNewline(str) {
+    return u.detectNewline(str);
+  },
+  camelCase(str) {
+    return c.camelCase(str);
+  },
+  capitalCase(str) {
+    return c.capitalCase(str);
+  },
+  constantCase(str) {
+    return c.constantCase(str);
+  },
+  dotCase(str) {
+    return c.dotCase(str);
+  },
+  noCase(str) {
+    return c.noCase(str);
+  },
+  paramCase(str) {
+    return c.paramCase(str);
+  },
+  pascalCase(str) {
+    return c.pascalCase(str);
+  },
+  pathCase(str) {
+    return c.pathCase(str);
+  },
+  sentenceCase(str) {
+    return c.sentenceCase(str);
+  },
+  snakeCase(str) {
+    return c.snakeCase(str);
+  },
+  titleCase(str) {
+    return c.titleCase(str);
+  },
+  kebabCase(str) {
+    return c.kebabCase(str);
+  },
+  plural(str) {
+    return p.plural(str);
+  },
+  singular(str) {
+    return p.singular(str);
+  },
+  isPlural(str) {
+    return p.isPlural(str);
+  },
+  isSingular(str) {
+    return p.isSingular(str);
+  },
+  addPluralRule(rule, repl) {
+    p.addPluralRule(rule, repl);
+  },
+  addSingularRule(rule, repl) {
+    p.addSingularRule(rule, repl);
+  },
+  addIrregularRule(single, plural) {
+    p.addIrregularRule(single, plural);
+  },
+  addUncountableRule(word) {
+    p.addUncountableRule(word);
+  }
+}, str = Str;

package/dist/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;