@goast/core 0.5.2 → 0.6.0-beta.1

package/src/src/utils/string-builder/string-builder.ts

@@ -1,165 +0,0 @@
-import { isNullish } from '../common.utils.js';
-import type { Nullable, SingleOrMultiple } from '../type.utils.js';
-import { defaultStringBuilderOptions, type StringBuilderOptions } from './options.js';
-
-export type BuilderFn<TBuilder extends StringBuilder> = (builder: TBuilder) => void;
-export type Primitive = string | number | boolean;
-
-export type AppendParam<TBuilder extends StringBuilder, TAdditionalAppends> = SingleOrMultiple<
-  | Primitive
-  | null
-  | undefined
-  | BuilderFn<TBuilder>
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  | TAdditionalAppends
-  | {
-    __type: 'append-value-group';
-    values: AppendParam<TBuilder, TAdditionalAppends>[];
-    separator: string | null;
-  }
->;
-
-export const AdditionalAppendsSymbol = Symbol('AdditionalAppends');
-
-/**
- * Represents a mutable string of characters.
- */
-export class StringBuilder<TAdditionalAppends = never> {
-  private readonly _options: StringBuilderOptions;
-  protected str: string = '';
-
-  [AdditionalAppendsSymbol](_: TAdditionalAppends): void {
-    throw new Error('This method should never be called.');
-  }
-
-  public get options(): StringBuilderOptions {
-    return this._options;
-  }
-
-  /**
-   * Initializes a new instance of the StringBuilder class.
-   * @param options The options.
-   */
-  constructor(options?: Partial<StringBuilderOptions>) {
-    this._options = { ...defaultStringBuilderOptions, ...options };
-  }
-
-  /**
-   * Creates a new StringBuilder instance and appends the specified string to it.
-   * @param str The string to append.
-   * @param options The options.
-   * @returns A new StringBuilder instance.
-   */
-  public static fromString(str: string, options?: Partial<StringBuilderOptions>): StringBuilder {
-    const builder = new StringBuilder(options);
-    builder.append(str);
-    return builder;
-  }
-
-  /**
-   * Builds a string using a StringBuilder build action.
-   * @param buildAction The build action to perform on the StringBuilder instance.
-   * @param options The options for the StringBuilder instance.
-   * @returns The built string.
-   */
-  public static build(buildAction: AppendParam<StringBuilder, never>, options?: Partial<StringBuilderOptions>): string {
-    const builder = new StringBuilder(options);
-    builder.append(buildAction);
-    return builder.toString();
-  }
-
-  protected appendSingle(value: AppendParam<this, TAdditionalAppends>) {
-    if (isNullish(value)) return;
-    if (Array.isArray(value)) {
-      for (const part of value) {
-        this.appendSingle(part);
-      }
-    } else if (typeof value === 'string') {
-      this.str += value;
-    } else if (typeof value === 'number' || typeof value === 'boolean') {
-      this.str += value.toString();
-    } else if (typeof value === 'function') {
-      (value as (builder: this) => void)(this);
-    } else if (
-      typeof value === 'object' &&
-      value !== null &&
-      '__type' in value &&
-      value.__type === 'append-value-group'
-    ) {
-      let isFirst = true;
-      for (const part of value.values) {
-        if (!isFirst && value.separator) {
-          this.append(value.separator);
-        }
-        this.appendSingle(part);
-        isFirst = false;
-      }
-    }
-  }
-
-  /**
-   * Appends one or more strings to the end of the current StringBuilder.
-   * @param value The string(s) to append.
-   * @returns The current StringBuilder.
-   */
-  public append(...value: AppendParam<this, TAdditionalAppends>[]): this {
-    for (const part of value) {
-      this.appendSingle(part);
-    }
-    return this;
-  }
-
-  /**
-   * Appends one or more strings to the end of the current StringBuilder, followed by a line terminator.
-   * @param value
-   * @returns
-   */
-  public appendLine(...value: Nullable<AppendParam<this, TAdditionalAppends>>[]): this {
-    return this.append(...value, '\n');
-  }
-
-  /**
-   * Prepends one or more strings to the beginning of the current StringBuilder.
-   * @param value The string(s) to prepend.
-   * @returns The current StringBuilder.
-   */
-  public prepend(...value: AppendParam<StringBuilder, never>[]): this {
-    for (const part of value.reverse()) {
-      if (isNullish(part)) continue;
-      if (typeof part === 'function') {
-        const builder = new StringBuilder(this.options);
-        part(builder);
-        this.str = builder.str + this.str;
-      } else if (typeof part === 'string') {
-        this.str = part + this.str;
-      } else {
-        this.str = part.toString() + this.str;
-      }
-    }
-    return this;
-  }
-
-  /**
-   * Prepends one or more strings to the beginning of the current StringBuilder, followed by a line terminator.
-   * @param value The string(s) to prepend.
-   * @returns The current StringBuilder.
-   */
-  public prependLine(...value: AppendParam<StringBuilder, never>[]): this {
-    return this.prepend(...value, '\n');
-  }
-
-  /**
-   * Converts the value of this instance to a string.
-   * @returns A string whose value is the same as this instance.
-   */
-  public toString(): string {
-    return this.str.replace(/\r?\n/g, this._options.newLine);
-  }
-
-  /**
-   * Removes all characters from the current StringBuilder.
-   */
-  public clear(): void {
-    this.str = '';
-  }
-}

package/src/src/utils/string-builder/utils.ts

@@ -1,69 +0,0 @@
-import { concatSingleOrMultiple, notNullish } from '../common.utils.js';
-import type { Nullable } from '../type.utils.js';
-import type { AdditionalAppendsSymbol, AppendParam, BuilderFn, Primitive, StringBuilder } from './string-builder.js';
-
-export type BasicAppendValue<TBuilder extends StringBuilder = StringBuilder> =
-  | Primitive
-  | BuilderFn<TBuilder>
-  | BasicAppendValueGroup<TBuilder>;
-export type BasicAppendValueGroup<TBuilder extends StringBuilder = StringBuilder> = {
-  __type: 'append-value-group';
-  values: BasicAppendValue<TBuilder>[];
-  separator: string | null;
-};
-
-export type AppendValue<TBuilder extends StringBuilder = StringBuilder> = NonNullable<
-  AppendParam<TBuilder, Parameters<TBuilder[typeof AdditionalAppendsSymbol]>[0]>
->;
-export type AppendValueGroup<TBuilder extends StringBuilder = StringBuilder> = {
-  __type: 'append-value-group';
-  values: AppendValue<TBuilder>[];
-  separator: string | null;
-};
-
-/** @deprecated Use AppendValue<TBuilder> instead */
-export type TextOrBuilderFn<TBuilder> = string | ((builder: TBuilder) => void);
-
-export function basicAppendValueGroup<TBuilder extends StringBuilder = StringBuilder>(
-  values: Nullable<Nullable<BasicAppendValue<TBuilder>>[]>,
-  separator?: Nullable<string>,
-): BasicAppendValueGroup<TBuilder> {
-  return {
-    __type: 'append-value-group',
-    values: values?.filter(notNullish) ?? [],
-    separator: separator ?? null,
-  };
-}
-
-export function appendValueGroup<TBuilder extends StringBuilder = StringBuilder>(
-  values: Nullable<Nullable<AppendValue<TBuilder>>[]>,
-  separator?: Nullable<string>,
-): AppendValueGroup<TBuilder> {
-  return {
-    __type: 'append-value-group',
-    values: values?.filter(notNullish) ?? [],
-    separator: separator ?? null,
-  };
-}
-
-export function isAppendValue(value: unknown): value is AppendValue<never> {
-  return (
-    typeof value === 'string' ||
-    typeof value === 'number' ||
-    typeof value === 'boolean' ||
-    typeof value === 'function' ||
-    isAppendValueGroup(value)
-  );
-}
-
-export function isAppendValueGroup<TBuilder extends StringBuilder = StringBuilder>(
-  value: unknown,
-): value is AppendValueGroup<TBuilder> {
-  return typeof value === 'object' && value !== null && '__type' in value && value.__type === 'append-value-group';
-}
-
-export function concatAppendValues<TBuilder extends StringBuilder = StringBuilder>(
-  ...values: AppendValue<TBuilder>[]
-): AppendValue<TBuilder> {
-  return concatSingleOrMultiple(...values) as AppendValue<TBuilder>;
-}

package/src/src/utils/string.utils.ts

@@ -1,369 +0,0 @@
-import { isNullish } from './common.utils.js';
-import type {
-  BaseCaseOptions,
-  CamelCaseOptions,
-  CaseOptions,
-  CustomCaseOptions,
-  KebabCaseOptions,
-  PascalCaseOptions,
-  SnakeCaseOptions,
-  StringCasing,
-  StringCasingWithOptions,
-  WordCasing,
-} from './string.utils.types.js';
-import type { Nullable } from './type.utils.js';
-
-export function adjustCasing(a: StringCasing, b: StringCasing): StringCasing;
-export function adjustCasing(
-  a: StringCasing | StringCasingWithOptions,
-  b: StringCasing | Partial<StringCasingWithOptions>,
-): StringCasingWithOptions;
-export function adjustCasing(
-  a: StringCasing | StringCasingWithOptions,
-  b: StringCasing | Partial<StringCasingWithOptions>,
-): StringCasing | StringCasingWithOptions {
-  if (typeof a === 'string') {
-    if (typeof b === 'string') {
-      return b;
-    } else {
-      return { casing: a, ...b };
-    }
-  } else if (typeof b === 'string') {
-    return { ...a, casing: b };
-  } else {
-    return { ...a, ...b };
-  }
-}
-
-export function lowercase<T extends string>(str: T): Lowercase<T> {
-  return str.toLowerCase() as Lowercase<T>;
-}
-
-export function uppercase<T extends string>(str: T): Uppercase<T> {
-  return str.toUpperCase() as Uppercase<T>;
-}
-
-export function capitalize<T extends string>(str: T): Capitalize<T> {
-  return (str.charAt(0).toUpperCase() + str.slice(1)) as Capitalize<T>;
-}
-
-export function uncapitalize<T extends string>(str: T): Uncapitalize<T> {
-  return (str.charAt(0).toLowerCase() + str.slice(1)) as Uncapitalize<T>;
-}
-
-/**
- * Gets the words from a string. Words are separated by capital letters. Leading numbers are removed. Non-alphanumerical characters are removed and interpreted as word seperators. Multiple uppercase letters are interpreted as one word.
- * @param str The string to get the words from.
- * @returns The words.
- * @example
- * getWords('fooBar') // => ['foo', 'Bar']
- * getWords('fooBarBaz') // => ['foo', 'Bar', 'Baz']
- * getWords('fooBarBaz123') // => ['foo', 'Bar', 'Baz', '123']
- * getWords('123Foo###Bar###') // => ['Foo', 'Bar']
- * getWords('fooBARBaz') // => ['foo', 'BAR', 'Baz']
- */
-export function getWords(str: Nullable<string>): string[] {
-  if (isNullish(str)) return [];
-
-  // Remove non-alphanumerical characters
-  str = str.replace(/[^a-zA-Z0-9]+/g, '-');
-  str = str.replace(/^[0-9-]+/, '');
-
-  // Split into words
-  return str.match(/[A-Z]{2,}(?=[A-Z0-9-]|$)|[a-zA-Z][a-z]*|[0-9]+/g) ?? [];
-}
-
-/**
- * Converts a word to a given casing.
- * @param str The word to convert.
- * @param casing The casing to convert to.
- * @returns The converted word.
- * @example
- * toCasing('fooBar', 'unchanged') // => 'fooBar'
- * toCasing('fooBar', 'all-lower') // => 'foobar'
- * toCasing('fooBar', 'all-upper') // => 'FOOBAR'
- * toCasing('fooBar', 'first-upper') // => 'FooBar'
- * toCasing('FooBar', 'first-lower') // => 'fooBar'
- * toCasing('fooBar', 'first-upper-then-lower') // => 'Foobar'
- * toCasing('FooBar', 'first-lower-then-upper') // => 'fOOBAR'
- * toCasing('fooBar', 'first-upper-alternating') // => 'FoObAr'
- * toCasing('FooBar', 'first-lower-alternating') // => 'fOoBaR'
- */
-export function wordToCasing(str: Nullable<string>, casing: WordCasing): string {
-  str ??= '';
-  switch (casing) {
-    case 'unchanged':
-      return str;
-    case 'all-lower':
-      return str.toLowerCase();
-    case 'all-upper':
-      return str.toUpperCase();
-    case 'first-upper':
-      return str[0].toUpperCase() + str.slice(1);
-    case 'first-lower':
-      return str[0].toLowerCase() + str.slice(1);
-    case 'first-upper-then-lower':
-      return str[0].toUpperCase() + str.slice(1).toLowerCase();
-    case 'first-lower-then-upper':
-      return str[0].toLowerCase() + str.slice(1).toUpperCase();
-    case 'first-upper-alternating':
-      return str
-        .split('')
-        .map((c, i) => (i % 2 === 0 ? c.toUpperCase() : c.toLowerCase()))
-        .join('');
-    case 'first-lower-alternating':
-      return str
-        .split('')
-        .map((c, i) => (i % 2 === 0 ? c.toLowerCase() : c.toUpperCase()))
-        .join('');
-  }
-}
-
-export function toCasing<T extends StringCasing>(
-  str: Nullable<string>,
-  casing: T | StringCasingWithOptions<T>,
-): string {
-  let options: CaseOptions<T> | undefined;
-  let casingType: StringCasing;
-  if (typeof casing === 'string') {
-    casingType = casing;
-  } else {
-    options = casing;
-    casingType = casing.casing;
-  }
-
-  switch (casingType) {
-    case 'camel':
-      return toCamelCase(str, options as CaseOptions<'camel'>);
-    case 'pascal':
-      return toPascalCase(str, options as CaseOptions<'pascal'>);
-    case 'kebab':
-      return toKebabCase(str, options as CaseOptions<'kebab'>);
-    case 'snake':
-      return toSnakeCase(str, options as CaseOptions<'snake'>);
-    case 'custom':
-      return toCustomCase(str, options as CaseOptions<'custom'>);
-    default:
-      return wordToCasing(getWords(str).join(''), casingType);
-  }
-}
-
-function addPrefixAndSuffix(str: string, { prefix, suffix }: BaseCaseOptions): string {
-  if (prefix) {
-    str = prefix + str;
-  }
-  if (suffix) {
-    str = str + suffix;
-  }
-  return str;
-}
-
-/**
- * Converts a string to camel case.
- * @param str The string to convert.
- * @param options The options.
- * @returns The converted string.
- * @example
- * toCamelCase('Foo bAR') // => 'fooBar'
- * toCamelCase('Foo bAR', { keepOriginalCase: true }) // => 'fooBAR'
- * toCamelCase('Foo bAR', { keepOriginalCase: false }) // => 'fooBar'
- * toCamelCase('Foo bAR', { prefix: 'bar' }) // => 'barfooBar'
- * toCamelCase('Foo bAR', { suffix: 'bar' }) // => 'fooBarbar'
- */
-export function toCamelCase(str: Nullable<string>, options?: Partial<CamelCaseOptions>): string {
-  const opts: CamelCaseOptions = { keepOriginalCase: false, ...options };
-  const words = getWords(str);
-  const camelCase = words
-    .map((word, index) =>
-      index === 0
-        ? wordToCasing(word, opts.keepOriginalCase ? 'first-lower' : 'all-lower')
-        : wordToCasing(word, opts.keepOriginalCase ? 'first-upper' : 'first-upper-then-lower')
-    )
-    .join('');
-  return addPrefixAndSuffix(camelCase, opts);
-}
-
-/**
- * Converts a string to pascal case.
- * @param str The string to convert.
- * @param options The options.
- * @returns The converted string.
- * @example
- * toPascalCase('foo bAR') // => 'FooBar'
- * toPascalCase('foo bAR', { keepOriginalCase: true }) // => 'FooBAR'
- * toPascalCase('foo bAR', { keepOriginalCase: false }) // => 'FooBar'
- * toPascalCase('foo bAR', { prefix: 'bar' }) // => 'barFooBar'
- * toPascalCase('foo bAR', { suffix: 'bar' }) // => 'FooBarbar'
- */
-export function toPascalCase(str: Nullable<string>, options?: Partial<PascalCaseOptions>): string {
-  const opts: PascalCaseOptions = { keepOriginalCase: false, ...options };
-  const words = getWords(str);
-  const pascalCase = words
-    .map((word) => wordToCasing(word, opts.keepOriginalCase ? 'first-upper' : 'first-upper-then-lower'))
-    .join('');
-  return addPrefixAndSuffix(pascalCase, opts);
-}
-
-/**
- * Converts a string to kebab case.
- * @param str The string to convert.
- * @param options The options.
- * @returns The converted string.
- * @example
- * toKebabCase('Foo bAR') // => 'foo-bar'
- * toKebabCase('Foo bAR', { wordCasing: 'all-upper' }) // => 'FOO-BAR'
- * toKebabCase('Foo bAR', { firstWordCasing: 'all-upper' }) // => 'FOO-bar'
- * toKebabCase('Foo bAR', { casing: 'all-upper', firstWordCasing: 'all-lower' }) // => 'foo-BAR'
- * toKebabCase('Foo bAR', { prefix: 'bar' }) // => 'barfoo-bar'
- * toKebabCase('Foo bAR', { suffix: 'bar' }) // => 'foo-barbar'
- */
-export function toKebabCase(str: Nullable<string>, options?: Partial<KebabCaseOptions>): string {
-  const opts: KebabCaseOptions = { wordCasing: 'all-lower', ...options };
-  const words = getWords(str);
-  const kebabCase = words
-    .map((word, index) =>
-      index === 0 ? wordToCasing(word, opts.firstWordCasing ?? opts.wordCasing) : wordToCasing(word, opts.wordCasing)
-    )
-    .join('-');
-  return addPrefixAndSuffix(kebabCase, opts);
-}
-
-/**
- * Converts a string to snake case.
- * @param str The string to convert.
- * @param options The options.
- * @returns The converted string.
- * @example
- * toSnakeCase('Foo bAR') // => 'FOO_BAR'
- * toSnakeCase('Foo bAR', { wordCasing: 'all-lower' }) // => 'foo_bar'
- * toSnakeCase('Foo bAR', { firstWordCasing: 'all-lower' }) // => 'foo_BAR'
- * toSnakeCase('Foo bAR', { casing: 'all-lower', firstWordCasing: 'all-upper' }) // => 'FOO_bar'
- * toSnakeCase('Foo bAR', { prefix: 'bar' }) // => 'barFOO_BAR'
- * toSnakeCase('Foo bAR', { suffix: 'bar' }) // => 'FOO_BARbar'
- */
-export function toSnakeCase(str: Nullable<string>, options?: Partial<SnakeCaseOptions>): string {
-  const opts: SnakeCaseOptions = { wordCasing: 'all-upper', ...options };
-  const words = getWords(str);
-  const snakeCase = words
-    .map((word, index) =>
-      index === 0 ? wordToCasing(word, opts.firstWordCasing ?? opts.wordCasing) : wordToCasing(word, opts.wordCasing)
-    )
-    .join('_');
-  return addPrefixAndSuffix(snakeCase, opts);
-}
-
-/**
- * Converts a string to a custom case.
- * @param str The string to convert.
- * @param options The options.
- * @returns The converted string.
- * @example
- * toCustomCase('Foo bAR', { wordCasing: 'first-upper-then-lower' }) // => 'FooBar'
- * toCustomCase('Foo bAR', { wordCasing: 'first-upper-then-lower', wordSeparator: '~' }) // => 'Foo~Bar'
- * toCustomCase('Foo bAR', { wordCasing: 'first-upper-then-lower', wordSeparator: '~', prefix: 'bar' }) // => 'barFoo~Bar'
- * toCustomCase('Foo bAR', { wordCasing: 'first-upper-then-lower', wordSeparator: '~', suffix: 'bar' }) // => 'Foo~Barbar'
- * toCustomCase('Foo bAR', { wordCasing: 'all-upper', firstWordCasing: 'all-lower' }) // => 'fooBAR'
- * toCustomCase('Foo bAR baz', { wordCasing: (wordIndex) => (wordIndex % 2 === 0 ? 'all-upper' : 'all-lower') }) // => 'FOObarBAZ'
- */
-export function toCustomCase(str: Nullable<string>, options: CustomCaseOptions): string {
-  const words = getWords(str);
-  const wordMapFn: (word: string, index: number) => string = typeof options.wordCasing === 'function'
-    ? (word, index) => wordToCasing(word, options.wordCasing(index))
-    : (word, index) =>
-      index === 0
-        ? wordToCasing(word, options.firstWordCasing ?? options.wordCasing)
-        : wordToCasing(word, options.wordCasing);
-  const customCase = words.map(wordMapFn).join(options.wordSeparator ?? '');
-  return addPrefixAndSuffix(customCase, options);
-}
-
-/**
- * Escapes a string to be used in a regular expression.
- * @param str The string to escape.
- */
-export function escapeRegExp(str: string): string {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
-/**
- * Removes characters from a string and, if necessary, inserts new characters in their place, returning the spliced string.
- * @param str The string to splice.
- * @param start The index at which to start changing the string.
- * @param deleteCount The number of characters to remove.
- * @param insert The string to insert.
- * @returns The spliced string.
- */
-export function spliceString(str: string, start: number, deleteCount: number, insert: string): string {
-  return str.slice(0, start) + insert + str.slice(start + deleteCount);
-}
-
-/**
- * Removes leading indentation based on the last line. Also removes the first line if it is empty.
- * @param str The string to trim.
- */
-export function trimIndent(str: string): string {
-  const indent = str.match(/\n( *).*$/)?.[1] ?? '';
-  if (indent.length === 0) return str;
-  return str.replace(/^\r?\n/, '').replace(new RegExp(`^ {0,${indent.length}}`, 'gm'), '');
-}
-
-function isNonLineBreakWhitespaceChar(char: string): boolean {
-  return (
-    char === ' ' ||
-    char === '\t' ||
-    char === '\f' ||
-    char === '\v' ||
-    char === '\u00a0' ||
-    char === '\u1680' ||
-    char === '\u2000' ||
-    char === '\u2001' ||
-    char === '\u2002' ||
-    char === '\u2003' ||
-    char === '\u2004' ||
-    char === '\u2005' ||
-    char === '\u2006' ||
-    char === '\u2007' ||
-    char === '\u2008' ||
-    char === '\u2009' ||
-    char === '\u200a' ||
-    char === '\u2028' ||
-    char === '\u2029' ||
-    char === '\u202f' ||
-    char === '\u205f' ||
-    char === '\u3000' ||
-    char === '\ufeff'
-  );
-}
-export function trimEnd(str: string, includeNewLine: boolean = true): string {
-  if (includeNewLine) return str.trimEnd();
-  let i = str.length;
-  for (; isNonLineBreakWhitespaceChar(str[i - 1]); i--);
-  return str.substring(0, i);
-}
-export function trimStart(str: string, includeNewLine: boolean = true): string {
-  if (includeNewLine) return str.trimStart();
-  let i = 0;
-  for (; isNonLineBreakWhitespaceChar(str[i]); i++);
-  return str.substring(i);
-}
-export function trim(str: string, includeNewLine: boolean = true): string {
-  if (includeNewLine) return str.trim();
-  let s = 0;
-  for (; isNonLineBreakWhitespaceChar(str[s]); s++);
-  let e = str.length;
-  for (; isNonLineBreakWhitespaceChar(str[e - 1]); e--);
-  return str.substring(s, e);
-}
-
-export function removeStr(str: string, rem: string): string {
-  let i = str.indexOf(rem);
-  if (i === -1) return str;
-  let result = '';
-  let s = 0;
-  while (i !== -1) {
-    result += str.substring(s, i);
-    s = i + rem.length;
-    i = str.indexOf(rem, s);
-  }
-  return result + str.substring(s);
-}