@goast/core 0.4.0 → 0.4.1-springwebclient1

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);
-}

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

@@ -1,179 +0,0 @@
-/**
- * Represents a casing for a 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 type WordCasing =
-  | 'unchanged'
-  | 'all-lower'
-  | 'all-upper'
-  | 'first-upper'
-  | 'first-lower'
-  | 'first-upper-then-lower'
-  | 'first-lower-then-upper'
-  | 'first-upper-alternating'
-  | 'first-lower-alternating';
-
-/**
- * Represents a casing for a string.
- * @example
- * toCase('fooBar', 'unchanged') // => 'fooBar'
- * toCase('fooBar', 'all-lower') // => 'foobar'
- * toCase('fooBar', 'all-upper') // => 'FOOBAR'
- * toCase('fooBar', 'first-upper') // => 'FooBar'
- * toCase('FooBar', 'first-lower') // => 'fooBar'
- * toCase('fooBar', 'first-upper-then-lower') // => 'Foobar'
- * toCase('FooBar', 'first-lower-then-upper') // => 'fOOBAR'
- * toCase('fooBar', 'first-upper-alternating') // => 'FoObAr'
- * toCase('FooBar', 'first-lower-alternating') // => 'fOoBaR'
- * toCase('fooBar', 'camel') // => 'fooBar'
- * toCase('fooBar', 'pascal') // => 'FooBar'
- * toCase('fooBar', 'kebab') // => 'foo-bar'
- * toCase('fooBar', 'snake') // => 'foo_bar'
- */
-export type StringCasing = WordCasing | 'camel' | 'pascal' | 'kebab' | 'snake' | 'custom';
-
-export type StringCasingWithOptions<T extends StringCasing = StringCasing> = {
-  casing: T;
-} & CaseOptions<T>;
-
-export type ExtendedStringCasing = StringCasing | StringCasingWithOptions;
-
-export type CaseOptions<T extends StringCasing> = T extends 'camel' ? Partial<CamelCaseOptions>
-  : T extends 'pascal' ? Partial<PascalCaseOptions>
-  : T extends 'kebab' ? Partial<KebabCaseOptions>
-  : T extends 'snake' ? Partial<SnakeCaseOptions>
-  : T extends 'custom' ? CustomCaseOptions
-  : never;
-
-export type BaseCaseOptions = {
-  /**
-   * Specifies a prefix to add to the string.
-   * @default undefined
-   * @example
-   * toCase('foo', { prefix: 'bar' }) // => 'barfoo'
-   */
-  prefix?: string;
-  /**
-   * Specifies a suffix to add to the string.
-   * @default undefined
-   * @example
-   * toCase('foo', { suffix: 'bar' }) // => 'foobar'
-   */
-  suffix?: string;
-};
-
-export type CamelCaseOptions = BaseCaseOptions & {
-  /**
-   * Controls the casing of all characters except the first one for each word.
-   *
-   * If true, all characters except the first one will remain unchanged; otherwise, all characters except the first one will be converted to lowercase.
-   *
-   * @default false
-   * @example
-   * toCamelCase('fooBAR') // => 'fooBar'
-   * toCamelCase('fooBAR', { keepOriginalCase: false }) // => 'fooBar'
-   * toCamelCase('fooBAR', { keepOriginalCase: true }) // => 'fooBAR'
-   */
-  keepOriginalCase: boolean;
-};
-
-export type PascalCaseOptions = BaseCaseOptions & {
-  /**
-   * Controls the casing of all characters except the first one for each word.
-   *
-   * If true, all characters except the first one will remain unchanged; otherwise, all characters except the first one will be converted to lowercase.
-   *
-   * @default false
-   * @example
-   * toCamelCase('FooBAR') // => 'FooBar'
-   * toCamelCase('FooBAR', { keepOriginalCase: false }) // => 'FooBar'
-   * toCamelCase('FooBAR', { keepOriginalCase: true }) // => 'FooBAR'
-   */
-  keepOriginalCase: boolean;
-};
-
-export type KebabCaseOptions = BaseCaseOptions & {
-  /**
-   * Specifies the casing of words.
-   * @default 'all-lower'
-   * @example
-   * toKebabCase('Foo bAR') // => 'foo-bar'
-   * toKebabCase('Foo bAR', { wordCasing: 'all-upper' }) // => 'FOO-BAR'
-   */
-  wordCasing: WordCasing;
-  /**
-   * Specifies the casing of the first word. If undefined uses the casing option.
-   * @default undefined
-   * @example
-   * toKebabCase('Foo bAR') // => 'foo-bar'
-   * toKebabCase('Foo bAR', { firstWordCasing: 'all-upper' }) // => 'FOO-bar'
-   * toKebabCase('Foo bAR', { wordCasing: 'all-upper', firstWordCasing: 'all-lower' }) // => 'foo-BAR'
-   */
-  firstWordCasing?: WordCasing;
-};
-
-export type SnakeCaseOptions = BaseCaseOptions & {
-  /**
-   * Specifies the casing of words.
-   * @default 'all-upper'
-   * @example
-   * toSnakeCase('Foo bAR') // => 'FOO_BAR'
-   * toSnakeCase('Foo bAR', { wordCasing: 'all-lower' }) // => 'foo_bar'
-   */
-  wordCasing: WordCasing;
-  /**
-   * Specifies the casing of the first word. If undefined uses the casing option.
-   * @default undefined
-   * @example
-   * toSnakeCase('Foo bAR') // => 'FOO_BAR'
-   * toSnakeCase('Foo bAR', { firstWordCasing: 'all-lower' }) // => 'foo_BAR'
-   * toSnakeCase('Foo bAR', { wordCasing: 'all-lower', firstWordCasing: 'all-upper' }) // => 'FOO_bar'
-   */
-  firstWordCasing?: WordCasing;
-};
-
-export type CustomCaseOptions =
-  & BaseCaseOptions
-  & {
-    /**
-     * Specifies the separator between words.
-     * @default undefined
-     * @example
-     * toCustomCase('Foo bAR', { wordCasing: 'first-upper-then-lower', wordSeparator: '~' }) // => 'Foo~Bar'
-     */
-    wordSeparator?: string;
-  }
-  & (
-    | {
-      /**
-       * Specifies the casing of words.
-       * @example
-       * toCustomCase('Foo bAR', { wordCasing: 'first-upper-then-lower' }) // => 'FooBar'
-       */
-      wordCasing: WordCasing;
-      /**
-       * Specifies the casing of the first word. If undefined uses the casing option.
-       * @default undefined
-       * @example
-       * toCustomCase('Foo bAR', { wordCasing: 'first-upper-then-lower', firstWordCasing: 'all-upper' }) // => 'FOOBar'
-       */
-      firstWordCasing?: WordCasing;
-    }
-    | {
-      /**
-       * Specifies the casing of words.
-       * @example
-       * toCustomCase('Foo bAR baz', { wordCasing: (wordIndex) => (wordIndex % 2 === 0 ? 'all-upper' : 'all-lower') }) // => 'FOObarBAZ'
-       */
-      wordCasing: (wordIndex: number) => WordCasing;
-    }
-  );

package/src/src/utils/type.utils.ts

@@ -1,93 +0,0 @@
-// deno-lint-ignore-file no-explicit-any ban-types
-export type Merge<U extends unknown[]> = U extends [infer A, ...infer R] ? A & Merge<R> : {};
-
-export type OptionalProperties<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
-export type RequiredProperties<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
-
-export type ArrayItem<T> = T extends (infer U)[] ? U : never;
-export type SingleOrMultiple<T> = T | T[];
-export type Single<T> = T extends (infer U)[] ? U : T;
-export type Multiple<T> = T extends (infer U)[] ? U[] : T[];
-
-export type Nullable<T> = T | null | undefined;
-
-export interface Constructor<T, TArgs extends any[] = any[]> extends Function {
-  new (...args: TArgs): T;
-}
-
-export type EmptyConstructor<T> = Constructor<T, []>;
-
-export type FunctionNames<T> = {
-  [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
-}[keyof T];
-
-export type Prettify<T> =
-  & {
-    [K in keyof T]: T[K];
-  }
-  & {};
-
-export type ValueOf<T> = T[keyof T];
-
-export type NonEmptyArray<T> = [T, ...T[]];
-
-type MustInclude<T, U extends T[]> = [T] extends [ValueOf<U>] ? U : never;
-export function stringUnionToArray<T>(): <U extends NonEmptyArray<T>>(
-  ...elements: MustInclude<T, U>
-) => MustInclude<T, U> {
-  return (...elements) => elements;
-}
-
-export type StringSuggestions<T extends string> = T | Omit<string, T>;
-export function suggestionsAsString<T>(
-  value: T,
-): T extends StringSuggestions<infer U> ? Exclude<T, StringSuggestions<U>> | string : T {
-  return value as any;
-}
-
-export type ParametersWithOverloads<T extends (...args: any[]) => any> = T extends {
-  (...args: infer A1): any;
-  (...args: infer A2): any;
-  (...args: infer A3): any;
-  (...args: infer A4): any;
-  (...args: infer A5): any;
-  (...args: infer A6): any;
-} ? A1 | A2 | A3 | A4 | A5 | A6
-  : T extends {
-    (...args: infer A1): any;
-    (...args: infer A2): any;
-    (...args: infer A3): any;
-    (...args: infer A4): any;
-    (...args: infer A5): any;
-  } ? A1 | A2 | A3 | A4 | A5
-  : T extends {
-    (...args: infer A1): any;
-    (...args: infer A2): any;
-    (...args: infer A3): any;
-    (...args: infer A4): any;
-  } ? A1 | A2 | A3 | A4
-  : T extends {
-    (...args: infer A1): any;
-    (...args: infer A2): any;
-    (...args: infer A3): any;
-  } ? A1 | A2 | A3
-  : T extends {
-    (...args: infer A1): any;
-    (...args: infer A2): any;
-  } ? A1 | A2
-  : T extends {
-    (...args: infer A1): any;
-  } ? A1
-  : never;
-
-type _TupleOf<T, N extends number, R extends unknown[]> = R['length'] extends N ? R : _TupleOf<T, N, [T, ...R]>;
-export type TupleWithCount<T, N extends number | number[]> = N extends number ? number extends N ? T[]
-  : _TupleOf<T, N, []>
-  : N extends [infer A, ...infer R]
-    ? A extends number ? R extends number[] ? TupleWithCount<T, A> | TupleWithCount<T, R>
-      : never
-    : never
-  : N extends [] ? never
-  : T[];
-
-export type MaybePromise<T> = T | Promise<T>;

package/src/tests/openapi.test.ts

@@ -1,50 +0,0 @@
-import "../_dnt.test_polyfills.js";
-import { join } from 'node:path';
-
-import {
-  declutterApiData,
-  openApiV2FilesDir,
-  openApiV3_1FilesDir,
-  openApiV3FilesDir,
-  type OpenApiVersion,
-  verify,
-} from '@goast/test-utils';
-
-import { describe, it } from '../deps/jsr.io/@std/testing/1.0.3/bdd.js';
-import { OpenApiParser, toCustomCase } from '../mod.js';
-
-const filePaths: { [P in OpenApiVersion]: string } = {
-  '2.0': openApiV2FilesDir,
-  '3.0': openApiV3FilesDir,
-  '3.1': openApiV3_1FilesDir,
-};
-
-const testFilesAllVersions: string[] = ['simple-schemas.yml', 'detailed-schemas.yml', 'object-schemas.yml'];
-const testFilesV3x: string[] = ['oneof-schemas.yml', 'discriminated-schemas.yml'];
-
-for (const [version, path] of Object.entries(filePaths)) {
-  describe(`OpenAPI V${version}`, () => {
-    const testFiles = version.startsWith('3') ? testFilesAllVersions.concat(testFilesV3x) : testFilesAllVersions;
-    for (const file of testFiles) {
-      const fileWithoutExt = file.replace(/\.[^/.]+$/, '');
-      it(
-        toCustomCase(fileWithoutExt, {
-          wordCasing: 'all-lower',
-          wordSeparator: ' ',
-        }),
-        async (t) => {
-          const filePath = join(path, file);
-          const data = await new OpenApiParser().parseApisAndTransform(filePath);
-
-          // Remove properties that do not need to be verified
-          for (const schema of Object.values(data.schemas)) {
-            delete (schema.$src as Record<string, unknown>).document;
-          }
-
-          declutterApiData(data);
-          await verify(t, data);
-        },
-      );
-    }
-  });
-}