@goast/core 0.4.0-beta3 → 0.4.0

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

@@ -0,0 +1,369 @@
+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

@@ -0,0 +1,179 @@
+/**
+ * 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

@@ -0,0 +1,93 @@
+// 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

@@ -0,0 +1,50 @@
+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);
+        },
+      );
+    }
+  });
+}