@goast/typescript 0.4.4 → 0.5.1-k6.1

package/src/src/ast/nodes/reference.test.ts

@@ -1,42 +0,0 @@
-import "../../../_dnt.test_polyfills.js";
-import { EOL } from 'node:os';
-
-import { expect } from '../../../deps/jsr.io/@std/expect/1.0.12/expect.js';
-import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.9/bdd.js';
-
-import type { TypeScriptImport } from '../../common-results.js';
-import { TypeScriptFileBuilder } from '../../file-builder.js';
-import { tsReference } from './reference.js';
-
-let builder: TypeScriptFileBuilder;
-
-beforeEach(() => {
-  builder = new TypeScriptFileBuilder();
-});
-
-describe('tsReference', () => {
-  it('should write the name of the reference', () => {
-    builder.append(tsReference('X'));
-    expect(builder.toString(false)).toBe('X');
-  });
-
-  it('should write the generics if they exist', () => {
-    builder.append(tsReference('X', null, { generics: ['T', 'U'] }));
-    expect(builder.toString(false)).toBe('X<T, U>');
-  });
-
-  it('should add the import if module name of file path is provided', () => {
-    builder.append(tsReference('X', 'module'));
-    expect(builder.imports.imports).toEqual(
-      <TypeScriptImport[]> [
-        { kind: 'module', modulePath: 'module', name: 'X', type: 'import' },
-      ],
-    );
-    expect(builder.toString(false)).toBe(`import { X } from 'module';${EOL}X`);
-  });
-
-  it('should write the injections', () => {
-    builder.append(tsReference('X', null, { generics: ['T', 'U'], inject: { before: '║b║', after: '║a║' } }));
-    expect(builder.toString(false)).toBe('║b║X<T, U>║a║');
-  });
-});

package/src/src/ast/nodes/reference.ts

@@ -1,194 +0,0 @@
-import {
-  type AstNodeOptions,
-  notNullish,
-  type Nullable,
-  type Prettify,
-  type SourceBuilder,
-  type TupleWithCount,
-} from '@goast/core';
-
-import type { TypeScriptImportType } from '../../common-results.js';
-import { TypeScriptFileBuilder } from '../../file-builder.js';
-import { TsNode } from '../node.js';
-import { writeTsGenericParameters } from '../utils/write-ts-generic-parameters.js';
-import { writeTsNodes } from '../utils/write-ts-nodes.js';
-import type { TsType } from './types.js';
-
-type Injects = never;
-
-type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
-  typeof TsNode<TBuilder, TInjects | Injects>,
-  {
-    name: string;
-    moduleNameOrfilePath?: Nullable<string>;
-    generics?: Nullable<Nullable<TsType<TBuilder>>[]>;
-    importType?: Nullable<TypeScriptImportType>;
-  }
->;
-type FactoryOptions<TBuilder extends SourceBuilder> = {
-  importType?: Nullable<TypeScriptImportType>;
-};
-
-type _AddImportHandler<T> = {
-  // deno-lint-ignore no-explicit-any
-  builderClass: abstract new (...args: any[]) => T;
-  // deno-lint-ignore no-explicit-any
-  handler: (builder: T, reference: TsReference<any>) => void;
-};
-
-export class TsReference<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<
-  TBuilder,
-  TInjects | Injects
-> {
-  // deno-lint-ignore no-explicit-any
-  private static readonly addImportHandlers: _AddImportHandler<any>[] = [
-    {
-      builderClass: TypeScriptFileBuilder,
-      handler: (builder: TypeScriptFileBuilder, reference) => {
-        if (reference.moduleNameOrfilePath) {
-          builder.addImport(reference.name, reference.moduleNameOrfilePath, { type: reference.importType });
-        }
-      },
-    },
-  ];
-
-  public name: string;
-  public moduleNameOrfilePath: string | null;
-  public generics: TsType<TBuilder>[];
-  public importType: TypeScriptImportType;
-
-  constructor(options: Options<TBuilder, TInjects>) {
-    super(options);
-    this.name = options.name;
-    this.moduleNameOrfilePath = options.moduleNameOrfilePath ?? null;
-    this.generics = options.generics?.filter(notNullish) ?? [];
-    this.importType = options.importType ?? 'import';
-  }
-
-  protected override onWrite(builder: TBuilder): void {
-    builder.append(this.name);
-    writeTsGenericParameters(builder, this.generics);
-    if (this.moduleNameOrfilePath) {
-      const handler = TsReference.addImportHandlers.find((h) => builder instanceof h.builderClass);
-      if (handler) {
-        handler.handler(builder, this);
-      }
-    }
-  }
-
-  public static registerAddImportHandler<TBuilder extends SourceBuilder>(
-    builderClass: _AddImportHandler<TBuilder>['builderClass'],
-    handler: _AddImportHandler<TBuilder>['handler'],
-  ): void {
-    TsReference.addImportHandlers.push({ builderClass, handler });
-  }
-}
-
-const createReference = <TBuilder extends SourceBuilder>(
-  name: Options<TBuilder>['name'],
-  moduleNameOrfilePath?: Options<TBuilder>['moduleNameOrfilePath'],
-  options?: Prettify<Omit<Options<TBuilder>, 'name' | 'moduleNameOrfilePath'>>,
-): TsReference<TBuilder> => new TsReference<TBuilder>({ ...options, name, moduleNameOrfilePath });
-
-export type TsReferenceFactory =
-  & (<TBuilder extends SourceBuilder>(options?: FactoryOptions<TBuilder>) => TsReference<TBuilder>)
-  & {
-    refName: string;
-    moduleNameOrfilePath: Nullable<string>;
-  };
-export type TsModuleReferenceFactory = TsReferenceFactory & {
-  moduleNameOrfilePath: string;
-};
-
-export type TsGenericReferenceFactory<TGenericCount extends number | number[]> =
-  & (<TBuilder extends SourceBuilder>(
-    generics: TupleWithCount<TsType<TBuilder>, TGenericCount>,
-    options?: FactoryOptions<TBuilder>,
-  ) => TsReference<TBuilder>)
-  & {
-    refName: string;
-    moduleNameOrfilePath: Nullable<string>;
-    infer: <TBuilder extends SourceBuilder>() => TsReference<TBuilder>;
-  };
-export type TsGenericModuleReferenceFactory<TGenericCount extends number | number[]> =
-  & TsGenericReferenceFactory<TGenericCount>
-  & {
-    moduleNameOrfilePath: string;
-  };
-
-function _createFactory(
-  name: string,
-  moduleNameOrfilePath?: Nullable<string>,
-  defaultOptions?: { importType?: Nullable<TypeScriptImportType> },
-): TsReferenceFactory {
-  return Object.assign(
-    <TBuilder extends SourceBuilder>(options?: FactoryOptions<TBuilder>) =>
-      createReference<TBuilder>(name, moduleNameOrfilePath, { ...defaultOptions, ...options }),
-    {
-      refName: name,
-      moduleNameOrfilePath,
-    },
-  );
-}
-function createFactory(
-  name: string,
-  moduleNameOrfilePath: string,
-  defaultOptions?: { importType?: Nullable<TypeScriptImportType> },
-): TsModuleReferenceFactory;
-function createFactory(
-  name: string,
-  moduleNameOrfilePath?: Nullable<string>,
-  defaultOptions?: { importType?: Nullable<TypeScriptImportType> },
-): TsReferenceFactory;
-function createFactory(
-  name: string,
-  moduleNameOrfilePath?: Nullable<string>,
-  defaultOptions?: { importType?: Nullable<TypeScriptImportType> },
-): TsReferenceFactory {
-  return _createFactory(name, moduleNameOrfilePath, defaultOptions);
-}
-
-function _createGenericFactory<TGenericCount extends number | number[]>(
-  name: string,
-  moduleNameOrfilePath?: Nullable<string>,
-  defaultOptions?: { importType?: Nullable<TypeScriptImportType> },
-): TsGenericReferenceFactory<TGenericCount> {
-  return Object.assign(
-    <TBuilder extends SourceBuilder>(
-      generics: TupleWithCount<TsType<TBuilder>, TGenericCount>,
-      options?: FactoryOptions<TBuilder>,
-    ) => createReference<TBuilder>(name, moduleNameOrfilePath, { ...defaultOptions, ...options, generics }),
-    {
-      refName: name,
-      moduleNameOrfilePath,
-      infer: <TBuilder extends SourceBuilder>() => createReference<TBuilder>(name, moduleNameOrfilePath),
-    },
-  );
-}
-function createGenericFactory<TGenericCount extends number | number[]>(
-  name: string,
-  moduleNameOrfilePath: string,
-  defaultOptions?: { importType?: Nullable<TypeScriptImportType> },
-): TsGenericModuleReferenceFactory<TGenericCount>;
-function createGenericFactory<TGenericCount extends number | number[]>(
-  name: string,
-  moduleNameOrfilePath?: Nullable<string>,
-  defaultOptions?: { importType?: Nullable<TypeScriptImportType> },
-): TsGenericReferenceFactory<TGenericCount>;
-function createGenericFactory<TGenericCount extends number | number[]>(
-  name: string,
-  moduleNameOrfilePath?: Nullable<string>,
-  defaultOptions?: { importType?: Nullable<TypeScriptImportType> },
-): TsGenericReferenceFactory<TGenericCount> {
-  return _createGenericFactory<TGenericCount>(name, moduleNameOrfilePath, defaultOptions);
-}
-
-export const tsReference: typeof createReference & {
-  factory: typeof createFactory;
-  genericFactory: typeof createGenericFactory;
-  write: typeof writeTsNodes;
-} = Object.assign(createReference, {
-  factory: createFactory,
-  genericFactory: createGenericFactory,
-  write: writeTsNodes,
-});

package/src/src/ast/nodes/string.test.ts

@@ -1,35 +0,0 @@
-import "../../../_dnt.test_polyfills.js";
-import { expect } from '../../../deps/jsr.io/@std/expect/1.0.12/expect.js';
-import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.9/bdd.js';
-
-import { TypeScriptFileBuilder } from '../../file-builder.js';
-import { tsString } from './string.js';
-
-let builder: TypeScriptFileBuilder;
-
-beforeEach(() => {
-  builder = new TypeScriptFileBuilder();
-});
-
-describe('tsString', () => {
-  it('should write the string', () => {
-    builder.append(tsString('X'));
-    expect(builder.toString(false)).toBe(`'X'`);
-  });
-
-  it('should use double quotes if configured', () => {
-    builder.options.useSingleQuotes = false;
-    builder.append(tsString('X'));
-    expect(builder.toString(false)).toBe(`"X"`);
-  });
-
-  it('should write the string as template string if configured', () => {
-    builder.append(tsString('X', { template: true }));
-    expect(builder.toString(false)).toBe('`X`');
-  });
-
-  it('should write the injections', () => {
-    builder.append(tsString('X', { inject: { before: '║b║', after: '║a║' } }));
-    expect(builder.toString(false)).toBe(`║b║'X'║a║`);
-  });
-});

package/src/src/ast/nodes/string.ts

@@ -1,49 +0,0 @@
-import type { AstNodeOptions, Nullable, Prettify, SourceBuilder } from '@goast/core';
-
-import { TsNode } from '../node.js';
-import { getTypeScriptBuilderOptions } from '../utils/get-type-script-builder-options.js';
-import { writeTsNodes } from '../utils/write-ts-nodes.js';
-
-type Injects = never;
-
-type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
-  typeof TsNode<TBuilder, TInjects | Injects>,
-  {
-    value: string;
-    template?: Nullable<boolean>;
-  }
->;
-
-export class TsString<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<
-  TBuilder,
-  TInjects | Injects
-> {
-  public value: string;
-  public template: boolean;
-
-  constructor(options: Options<TBuilder, TInjects>) {
-    super(options);
-    this.value = options.value;
-    this.template = options.template ?? false;
-  }
-
-  protected override onWrite(builder: TBuilder): void {
-    const builderOptions = getTypeScriptBuilderOptions(builder);
-    let value = JSON.stringify(this.value);
-    if (this.template) {
-      value = `\`${value.slice(1, -1).replace(/`/g, '\\`')}\``;
-    } else if (builderOptions.useSingleQuotes) {
-      value = `'${value.slice(1, -1).replace(/'/g, "\\'")}'`;
-    }
-    builder.append(value);
-  }
-}
-
-const createString = <TBuilder extends SourceBuilder>(
-  value: Options<TBuilder>['value'],
-  options?: Prettify<Omit<Options<TBuilder>, 'value'>>,
-): TsString<TBuilder> => new TsString<TBuilder>({ ...options, value });
-
-export const tsString: typeof createString & { write: typeof writeTsNodes } = Object.assign(createString, {
-  write: writeTsNodes,
-});

package/src/src/ast/nodes/tuple.test.ts

@@ -1,45 +0,0 @@
-import "../../../_dnt.test_polyfills.js";
-import { normalizeEOL } from '@goast/test-utils';
-
-import { expect } from '../../../deps/jsr.io/@std/expect/1.0.12/expect.js';
-import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.9/bdd.js';
-
-import { TypeScriptFileBuilder } from '../../file-builder.js';
-import { tsTuple } from './tuple.js';
-
-let builder: TypeScriptFileBuilder;
-
-beforeEach(() => {
-  builder = new TypeScriptFileBuilder();
-});
-
-describe('tsTuple', () => {
-  it('should write empty tuple if no elements are provided', () => {
-    builder.append(tsTuple([]));
-    expect(builder.toString(false)).toBe('[]');
-  });
-
-  it('should write the elements', () => {
-    builder.append(tsTuple(['string', 'number']));
-    expect(builder.toString(false)).toBe('[string, number]');
-  });
-
-  it('should write multiline if there are more than 3 elements', () => {
-    builder.append(tsTuple(['string', 'number', 'boolean', 'unknown']));
-    expect(builder.toString(false)).toBe(
-      normalizeEOL(8)(
-        `[
-          string,
-          number,
-          boolean,
-          unknown
-        ]`,
-      ),
-    );
-  });
-
-  it('should write as const', () => {
-    builder.append(tsTuple(['string', 'number'], { asConst: true }));
-    expect(builder.toString(false)).toBe('[string, number] as const');
-  });
-});

package/src/src/ast/nodes/tuple.ts

@@ -1,53 +0,0 @@
-import { type AstNodeOptions, notNullish, type Nullable, type Prettify, type SourceBuilder } from '@goast/core';
-
-import { TsNode } from '../node.js';
-import { writeTsNodes } from '../utils/write-ts-nodes.js';
-import type { TsType, TsValue } from './types.js';
-
-type Injects = never;
-
-type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
-  typeof TsNode<TBuilder, TInjects | Injects>,
-  {
-    elements: Nullable<TsType<TBuilder> | TsValue<TBuilder>>[];
-    asConst?: Nullable<boolean>;
-  }
->;
-
-export class TsTuple<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<
-  TBuilder,
-  TInjects | Injects
-> {
-  public elements: (TsType<TBuilder> | TsValue<TBuilder>)[];
-  public asConst: boolean;
-
-  constructor(options: Options<TBuilder, TInjects>) {
-    super(options);
-    this.elements = options.elements.filter(notNullish);
-    this.asConst = options.asConst ?? false;
-  }
-
-  protected override onWrite(builder: TBuilder): void {
-    if (this.elements.length === 0) {
-      builder.append('[]');
-    } else {
-      const multiline = this.elements.length > 3;
-      builder.parenthesize('[]', (b) => writeTsNodes(b, this.elements, { separator: multiline ? ',\n' : ', ' }), {
-        multiline,
-      });
-    }
-
-    if (this.asConst) {
-      builder.append(' as const');
-    }
-  }
-}
-
-const createTuple = <TBuilder extends SourceBuilder>(
-  elements: Options<TBuilder>['elements'],
-  options?: Prettify<Omit<Options<TBuilder>, 'elements'>>,
-): TsTuple<TBuilder> => new TsTuple<TBuilder>({ ...options, elements });
-
-export const tsTuple: typeof createTuple & { write: typeof writeTsNodes } = Object.assign(createTuple, {
-  write: writeTsNodes,
-});

package/src/src/ast/nodes/type-alias.test.ts

@@ -1,35 +0,0 @@
-import "../../../_dnt.test_polyfills.js";
-import { EOL } from 'node:os';
-
-import { expect } from '../../../deps/jsr.io/@std/expect/1.0.12/expect.js';
-import { beforeEach, it } from '../../../deps/jsr.io/@std/testing/1.0.9/bdd.js';
-
-import { TypeScriptFileBuilder } from '../../file-builder.js';
-import { tsGenericParameter } from './generic-parameter.js';
-import { tsTypeAlias } from './type-alias.js';
-
-let builder: TypeScriptFileBuilder;
-
-beforeEach(() => {
-  builder = new TypeScriptFileBuilder();
-});
-
-it('should write the name of the type alias', () => {
-  builder.append(tsTypeAlias('X', 'number'));
-  expect(builder.toString(false)).toBe('type X = number;' + EOL);
-});
-
-it('should write the generics if they exist', () => {
-  builder.append(tsTypeAlias('X', 'number', { generics: [tsGenericParameter('T'), tsGenericParameter('U')] }));
-  expect(builder.toString(false)).toBe('type X<T, U> = number;' + EOL);
-});
-
-it('should write export keyword if configured', () => {
-  builder.append(tsTypeAlias('X', 'number', { export: true }));
-  expect(builder.toString(false)).toBe('export type X = number;' + EOL);
-});
-
-it('should render injections', () => {
-  builder.append(tsTypeAlias('X', 'number', { inject: { before: ['before'], after: ['after'] } }));
-  expect(builder.toString(false)).toBe(`beforetype X = number;${EOL}after`);
-});

package/src/src/ast/nodes/type-alias.ts

@@ -1,75 +0,0 @@
-import {
-  type AstNodeOptions,
-  type BasicAppendValue,
-  notNullish,
-  type Nullable,
-  type Prettify,
-  type SourceBuilder,
-} from '@goast/core';
-
-import { TsNode } from '../node.js';
-import { writeTsNode, writeTsNodes } from '../utils/write-ts-nodes.js';
-import type { TsDoc } from './doc.js';
-import { type TsGenericParameter, tsGenericParameter } from './generic-parameter.js';
-import type { TsType } from './types.js';
-
-type Injects = never;
-
-type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
-  typeof TsNode<TBuilder, TInjects | Injects>,
-  {
-    name: string;
-    doc?: Nullable<TsDoc<TBuilder>>;
-    generics?: Nullable<Nullable<TsGenericParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
-    type: TsType<TBuilder>;
-    export?: Nullable<boolean>;
-  }
->;
-
-export class TsTypeAlias<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<
-  TBuilder,
-  TInjects | Injects
-> {
-  public name: string;
-  public doc: TsDoc<TBuilder> | null;
-  public generics: (TsGenericParameter<TBuilder> | BasicAppendValue<TBuilder>)[];
-  public type: TsType<TBuilder>;
-  public export: boolean;
-
-  constructor(options: Options<TBuilder, TInjects>) {
-    super(options);
-    this.name = options.name;
-    this.doc = options.doc ?? null;
-    this.generics = options.generics?.filter(notNullish) ?? [];
-    this.type = options.type;
-    this.export = options.export ?? false;
-  }
-
-  protected override onWrite(builder: TBuilder): void {
-    if (this.doc) writeTsNode(builder, this.doc);
-    if (this.export) builder.append('export ');
-
-    builder.append('type ');
-    builder.append(this.name);
-    tsGenericParameter.write(builder, this.generics);
-
-    builder.append(' = ');
-    builder.indent((b) => {
-      writeTsNode(b, this.type);
-    });
-
-    builder.append(';');
-
-    builder.appendLine();
-  }
-}
-
-const createTypeAlias = <TBuilder extends SourceBuilder>(
-  name: Options<TBuilder>['name'],
-  type: Options<TBuilder>['type'],
-  options?: Prettify<Omit<Options<TBuilder>, 'name' | 'type'>>,
-): TsTypeAlias<TBuilder> => new TsTypeAlias<TBuilder>({ ...options, name, type });
-
-export const tsTypeAlias: typeof createTypeAlias & { write: typeof writeTsNodes } = Object.assign(createTypeAlias, {
-  write: writeTsNodes,
-});

package/src/src/ast/nodes/typeof.ts

@@ -1,42 +0,0 @@
-import type { AstNodeOptions, SourceBuilder } from '@goast/core';
-
-import { TsNode } from '../node.js';
-import { writeTsNode, writeTsNodes } from '../utils/write-ts-nodes.js';
-import type { TsValue } from './types.js';
-
-type Injects = 'value';
-
-type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
-  typeof TsNode<TBuilder, TInjects | Injects>,
-  {
-    value: TsValue<TBuilder>;
-  }
->;
-
-export class TsTypeof<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<
-  TBuilder,
-  TInjects | Injects
-> {
-  public value: TsValue<TBuilder>;
-
-  constructor(options: Options<TBuilder, TInjects>) {
-    super(options);
-    this.value = options.value;
-  }
-
-  protected override onWrite(builder: TBuilder): void {
-    builder.append('typeof ');
-    builder.append(this.inject.beforeValue);
-    writeTsNode(builder, this.value);
-    builder.append(this.inject.afterValue);
-  }
-}
-
-export const createTypeof = <TBuilder extends SourceBuilder>(
-  value: Options<TBuilder>['value'],
-  options?: Omit<Options<TBuilder>, 'value'>,
-): TsTypeof<TBuilder> => new TsTypeof<TBuilder>({ ...options, value });
-
-export const tsTypeof: typeof createTypeof & { write: typeof writeTsNodes } = Object.assign(createTypeof, {
-  write: writeTsNodes,
-});

package/src/src/ast/nodes/types.ts

@@ -1,40 +0,0 @@
-import type { BasicAppendValue, SourceBuilder } from '@goast/core';
-import type { TsArrayType } from './array-type.js';
-import type { TsArrowFunction } from './arrow-function.js';
-import type { TsCall } from './call.js';
-import type { TsClass } from './class.js';
-import type { TsFunctionType } from './function-type.js';
-import type { TsFunction } from './function.js';
-import type { TsIntersectionType } from './intersection-type.js';
-import type { TsLookupType } from './lookup-type.js';
-import type { TsObjectType } from './object-type.js';
-import type { TsObject } from './object.js';
-import type { TsReference } from './reference.js';
-import type { TsString } from './string.js';
-import type { TsTuple } from './tuple.js';
-import type { TsTypeof } from './typeof.js';
-import type { TsUnionType } from './union-type.js';
-
-export type TsType<TBuilder extends SourceBuilder> =
-  | BasicAppendValue<TBuilder>
-  | TsIntersectionType<TBuilder>
-  | TsUnionType<TBuilder>
-  | TsArrayType<TBuilder>
-  | TsTuple<TBuilder>
-  | TsFunctionType<TBuilder>
-  | TsObjectType<TBuilder>
-  | TsString<TBuilder>
-  | TsLookupType<TBuilder>
-  | TsTypeof<TBuilder>
-  | TsReference<TBuilder>;
-
-export type TsValue<TBuilder extends SourceBuilder> =
-  | BasicAppendValue<TBuilder>
-  | TsObject<TBuilder>
-  | TsTuple<TBuilder>
-  | TsString<TBuilder>
-  | TsArrowFunction<TBuilder>
-  | TsFunction<TBuilder>
-  | TsClass<TBuilder>
-  | TsCall<TBuilder>
-  | TsReference<TBuilder>;

package/src/src/ast/nodes/union-type.test.ts

@@ -1,50 +0,0 @@
-import "../../../_dnt.test_polyfills.js";
-import { EOL } from 'node:os';
-
-import { expect } from '../../../deps/jsr.io/@std/expect/1.0.12/expect.js';
-import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.9/bdd.js';
-
-import { TypeScriptFileBuilder } from '../../file-builder.js';
-import { tsUnionType } from './union-type.js';
-
-let builder: TypeScriptFileBuilder;
-
-beforeEach(() => {
-  builder = new TypeScriptFileBuilder();
-});
-
-describe('tsUnionType', () => {
-  it('should write type "never" if no types are provided', () => {
-    builder.append(tsUnionType([]));
-    expect(builder.toString(false)).toBe('never');
-  });
-
-  it('should write the type if only one type is provided', () => {
-    builder.append(tsUnionType(['string']));
-    expect(builder.toString(false)).toBe('string');
-  });
-
-  it('should write the types', () => {
-    builder.append(tsUnionType(['string', 'number']));
-    expect(builder.toString(false)).toBe('(string) | (number)');
-  });
-
-  it('should write the types on separate lines if there are more than 3', () => {
-    builder.append(tsUnionType(['string', 'number', 'boolean', 'unknown']));
-    expect(builder.toString(false)).toBe(`${EOL}| (string)${EOL}| (number)${EOL}| (boolean)${EOL}| (unknown)`);
-  });
-
-  it('should collapse nested union types', () => {
-    builder.append(tsUnionType([tsUnionType(['string', 'number']), tsUnionType(['boolean', 'unknown'])]));
-    expect(builder.toString(false)).toBe(`${EOL}| (string)${EOL}| (number)${EOL}| (boolean)${EOL}| (unknown)`);
-  });
-
-  it('should render injections', () => {
-    builder.append(
-      tsUnionType(['string', 'number'], {
-        inject: { before: '║b║', after: '║a║' },
-      }),
-    );
-    expect(builder.toString(false)).toBe('║b║(string) | (number)║a║');
-  });
-});