@goast/typescript 0.4.1 → 0.4.2

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

@@ -1,85 +0,0 @@
-import "../../../_dnt.test_polyfills.js";
-import { EOL } from 'node:os';
-
-import { expect } from '../../../deps/jsr.io/@std/expect/1.0.6/expect.js';
-import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.3/bdd.js';
-
-import { TypeScriptFileBuilder } from '../../file-builder.js';
-import { tsDoc } from './doc.js';
-import { tsEnumValue } from './enum-value.js';
-import { tsEnum } from './enum.js';
-
-let builder: TypeScriptFileBuilder;
-
-beforeEach(() => {
-  builder = new TypeScriptFileBuilder();
-});
-
-describe('tsEnum', () => {
-  it('should write the name of the enum', () => {
-    builder.append(tsEnum('X'));
-    expect(builder.toString(false)).toBe(`enum X {}${EOL}`);
-  });
-
-  it('should write the members if they exist', () => {
-    builder.append(tsEnum('X', { members: [tsEnumValue('A'), tsEnumValue('B')] }));
-    expect(builder.toString(false)).toBe(`enum X {${EOL}  A,${EOL}  B${EOL}}${EOL}`);
-  });
-
-  it('should write export keyword if configured', () => {
-    builder.append(tsEnum('X', { export: true }));
-    expect(builder.toString(false)).toBe(`export enum X {}${EOL}`);
-  });
-
-  it('should write const keyword if configured', () => {
-    builder.append(tsEnum('X', { const: true }));
-    expect(builder.toString(false)).toBe(`const enum X {}${EOL}`);
-  });
-
-  it('should write documenation if it exists', () => {
-    builder.append(tsEnum('X', { doc: tsDoc({ description: 'description' }) }));
-    expect(builder.toString(false)).toBe(`/**${EOL} * description${EOL} */${EOL}enum X {}${EOL}`);
-  });
-
-  it('should write all the parts of the enum', () => {
-    builder.append(
-      tsEnum('X', {
-        doc: tsDoc({ description: 'description' }),
-        members: [tsEnumValue('A'), tsEnumValue('B')],
-        export: true,
-        const: true,
-      }),
-    );
-    expect(builder.toString(false)).toBe(
-      `/**${EOL} * description${EOL} */${EOL}export const enum X {${EOL}  A,${EOL}  B${EOL}}${EOL}`,
-    );
-  });
-
-  it('should render injections', () => {
-    builder.append(
-      tsEnum('X', {
-        doc: tsDoc({ description: 'description' }),
-        members: [tsEnumValue('A'), tsEnumValue('B')],
-        export: true,
-        const: true,
-        inject: {
-          before: '║b║',
-          after: '║a║',
-          beforeDoc: '║bd║',
-          afterDoc: '║ad║',
-          beforeModifiers: '║bm║',
-          afterModifiers: '║am║',
-          beforeName: '║bn║',
-          afterName: '║an║',
-          beforeBody: '║bb║',
-          afterBody: '║ab║',
-          beforeMembers: '║bm║',
-          afterMembers: '║am║',
-        },
-      }),
-    );
-    expect(builder.toString(false)).toBe(
-      `║b║║bd║${EOL}/**${EOL} * description${EOL} */${EOL}║ad║║bm║export const ║am║enum ║bn║X║an║ ║bb║{${EOL}  ║bm║A,${EOL}  B║am║${EOL}}║ab║${EOL}║a║`,
-    );
-  });
-});

package/src/src/ast/nodes/enum.ts

@@ -1,77 +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 { TsDoc } from './doc.js';
-import { type TsEnumValue, tsEnumValue } from './enum-value.js';
-
-type Injects = 'doc' | 'modifiers' | 'name' | 'body' | 'members';
-
-type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
-  typeof TsNode<TBuilder, TInjects | Injects>,
-  {
-    doc?: Nullable<TsDoc<TBuilder>>;
-    export?: Nullable<boolean>;
-    const?: Nullable<boolean>;
-    name: string;
-    members?: Nullable<Nullable<TsEnumValue<TBuilder>>[]>;
-  }
->;
-
-export class TsEnum<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<
-  TBuilder,
-  TInjects | Injects
-> {
-  public doc: TsDoc<TBuilder> | null;
-  public export: boolean;
-  public const: boolean;
-  public name: string;
-  public members: TsEnumValue<TBuilder>[];
-
-  constructor(options: Options<TBuilder, TInjects>) {
-    super(options);
-    this.doc = options.doc ?? null;
-    this.export = options.export ?? false;
-    this.const = options.const ?? false;
-    this.name = options.name;
-    this.members = options.members?.filter(notNullish) ?? [];
-  }
-
-  protected override onWrite(builder: TBuilder): void {
-    builder.append(this.inject.beforeDoc);
-    this.doc?.write(builder);
-    builder.append(this.inject.afterDoc);
-
-    builder.append(this.inject.beforeModifiers);
-    if (this.export) builder.append('export ');
-    if (this.const) builder.append('const ');
-    builder.append(this.inject.afterModifiers);
-
-    builder.append('enum ');
-    builder.append(this.inject.beforeName, this.name, this.inject.afterName);
-    builder.append(' ');
-
-    builder.append(this.inject.beforeBody);
-    builder.parenthesize(
-      '{}',
-      (b) => {
-        b.append(this.inject.beforeMembers);
-        tsEnumValue.write(b, this.members);
-        b.append(this.inject.afterMembers);
-      },
-      { multiline: this.members.length > 0 },
-    );
-    builder.append(this.inject.afterBody);
-
-    builder.appendLine();
-  }
-}
-
-const createEnum = <TBuilder extends SourceBuilder>(
-  name: Options<TBuilder>['name'],
-  options?: Prettify<Omit<Options<TBuilder>, 'name'>>,
-): TsEnum<TBuilder> => new TsEnum<TBuilder>({ ...options, name });
-
-export const tsEnum: typeof createEnum & { write: typeof writeTsNodes } = Object.assign(createEnum, {
-  write: writeTsNodes,
-});

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

@@ -1,29 +0,0 @@
-import "../../../_dnt.test_polyfills.js";
-import { EOL } from 'node:os';
-
-import { expect } from '../../../deps/jsr.io/@std/expect/1.0.6/expect.js';
-import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.3/bdd.js';
-
-import { SourceBuilder } from '@goast/core';
-
-import { TypeScriptFileBuilder } from '../../file-builder.js';
-import { tsExport } from './export.js';
-
-let builder: TypeScriptFileBuilder;
-
-beforeEach(() => {
-  builder = new TypeScriptFileBuilder();
-});
-
-describe('tsExport', () => {
-  it('should add the export to the builder', () => {
-    builder.append(tsExport('myFunction', './my-function'));
-    expect(builder.imports['_exports']).toEqual(new Map([['./my-function', new Set(['myFunction'])]]));
-  });
-
-  it('should write export if not TypeScriptFileBuilder', () => {
-    const builder = new SourceBuilder();
-    tsExport('myFunction', './my-function').write(builder);
-    expect(builder.toString()).toBe(`export { myFunction } from './my-function';${EOL}`);
-  });
-});

package/src/src/ast/nodes/export.ts

@@ -1,54 +0,0 @@
-import type { AstNodeOptions, Nullable, Prettify, SourceBuilder } from '@goast/core';
-
-import type { TypeScriptExportType } from '../../common-results.js';
-import { TypeScriptFileBuilder } from '../../file-builder.js';
-import { TsNode } from '../node.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>,
-  {
-    name: string;
-    filePath: string;
-    kind?: Nullable<TypeScriptExportType>;
-  }
->;
-
-export class TsExport<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<
-  TBuilder,
-  TInjects | Injects
-> {
-  public name: string;
-  public filePath: string;
-  public kind: TypeScriptExportType;
-
-  constructor(options: Options<TBuilder, TInjects>) {
-    super(options);
-    this.name = options.name;
-    this.filePath = options.filePath;
-    this.kind = options.kind ?? 'export';
-  }
-
-  protected override onWrite(builder: TBuilder): void {
-    if (builder instanceof TypeScriptFileBuilder) {
-      builder.addExport(this.name, this.filePath, { type: this.kind });
-    } else {
-      builder.appendLine(
-        this.kind === 'type-export' ? 'export type' : 'export',
-        ` { ${this.name} } from '${this.filePath}';`,
-      );
-    }
-  }
-}
-
-export const createExport = <TBuilder extends SourceBuilder>(
-  name: Options<TBuilder>['name'],
-  filePath: Options<TBuilder>['filePath'],
-  options?: Prettify<Omit<Options<TBuilder>, 'name' | 'filePath'>>,
-): TsExport<TBuilder> => new TsExport<TBuilder>({ ...options, name, filePath });
-
-export const tsExport: typeof createExport & { write: typeof writeTsNodes } = Object.assign(createExport, {
-  write: writeTsNodes,
-});

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

@@ -1,61 +0,0 @@
-import "../../../_dnt.test_polyfills.js";
-import { expect } from '../../../deps/jsr.io/@std/expect/1.0.6/expect.js';
-import { beforeEach, it } from '../../../deps/jsr.io/@std/testing/1.0.3/bdd.js';
-
-import { TypeScriptFileBuilder } from '../../file-builder.js';
-import { tsFunctionType } from './function-type.js';
-import { tsGenericParameter } from './generic-parameter.js';
-import { tsParameter } from './parameter.js';
-
-let builder: TypeScriptFileBuilder;
-
-beforeEach(() => {
-  builder = new TypeScriptFileBuilder();
-});
-
-it('should write the parameters and the return type', () => {
-  builder.append(tsFunctionType({ parameters: [tsParameter('x'), tsParameter('y')], returnType: 'number' }));
-  expect(builder.toString(false)).toBe('(x, y) => number');
-});
-
-it('should write the generics if they exist', () => {
-  builder.append(
-    tsFunctionType({
-      generics: [tsGenericParameter('T'), tsGenericParameter('U')],
-      returnType: 'number',
-    }),
-  );
-  expect(builder.toString(false)).toBe('<T, U>() => number');
-});
-
-it('should write all the parts of the function type', () => {
-  builder.append(
-    tsFunctionType({
-      generics: [tsGenericParameter('T'), tsGenericParameter('U')],
-      parameters: [tsParameter('x'), tsParameter('y')],
-      returnType: 'number',
-    }),
-  );
-  expect(builder.toString(false)).toBe('<T, U>(x, y) => number');
-});
-
-it('should render injections', () => {
-  builder.append(
-    tsFunctionType({
-      generics: [tsGenericParameter('T'), tsGenericParameter('U')],
-      parameters: [tsParameter('x'), tsParameter('y')],
-      returnType: 'number',
-      inject: {
-        before: '║b║',
-        after: '║a║',
-        beforeGenerics: '║bg║',
-        afterGenerics: '║ag║',
-        beforeParams: '║bp║',
-        afterParams: '║ap║',
-        beforeReturnType: '║brt║',
-        afterReturnType: '║art║',
-      },
-    }),
-  );
-  expect(builder.toString(false)).toBe('║b║║bg║<T, U>║ag║║bp║(x, y)║ap║ => ║brt║number║art║║a║');
-});

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

@@ -1,60 +0,0 @@
-import { type AstNodeOptions, type BasicAppendValue, notNullish, type Nullable, type SourceBuilder } from '@goast/core';
-
-import { TsNode } from '../node.js';
-import { writeTsNode, writeTsNodes } from '../utils/write-ts-nodes.js';
-import { type TsGenericParameter, tsGenericParameter } from './generic-parameter.js';
-import { type TsParameter, tsParameter } from './parameter.js';
-import type { TsType } from './types.js';
-
-type Injects = 'generics' | 'params' | 'returnType';
-
-type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
-  typeof TsNode<TBuilder, TInjects | Injects>,
-  {
-    generics?: Nullable<Nullable<TsGenericParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
-    parameters?: Nullable<Nullable<TsParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
-    returnType?: Nullable<TsType<TBuilder>>;
-  }
->;
-
-export class TsFunctionType<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<
-  TBuilder,
-  TInjects | Injects
-> {
-  public generics: (TsGenericParameter<TBuilder> | BasicAppendValue<TBuilder>)[];
-  public parameters: (TsParameter<TBuilder> | BasicAppendValue<TBuilder>)[];
-  public returnType: TsType<TBuilder> | null;
-
-  constructor(options: Options<TBuilder, TInjects>) {
-    super(options);
-    this.generics = options.generics?.filter(notNullish) ?? [];
-    this.parameters = options.parameters?.filter(notNullish) ?? [];
-    this.returnType = options.returnType ?? null;
-  }
-
-  protected override onWrite(builder: TBuilder): void {
-    builder.append(this.inject.beforeGenerics);
-    tsGenericParameter.write(builder, this.generics);
-    builder.append(this.inject.afterGenerics);
-
-    builder.append(this.inject.beforeParams);
-    tsParameter.write(builder, this.parameters);
-    builder.append(this.inject.afterParams);
-
-    builder.append(' => ');
-
-    builder.append(this.inject.beforeReturnType);
-    writeTsNode(builder, this.returnType ?? 'void');
-    builder.append(this.inject.afterReturnType);
-  }
-}
-
-const createFunctionType = <TBuilder extends SourceBuilder>(options?: Options<TBuilder>): TsFunctionType<TBuilder> =>
-  new TsFunctionType<TBuilder>(options ?? {});
-
-export const tsFunctionType: typeof createFunctionType & { write: typeof writeTsNodes } = Object.assign(
-  createFunctionType,
-  {
-    write: writeTsNodes,
-  },
-);

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

@@ -1,135 +0,0 @@
-import "../../../_dnt.test_polyfills.js";
-import { EOL } from 'node:os';
-
-import { expect } from '../../../deps/jsr.io/@std/expect/1.0.6/expect.js';
-import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.3/bdd.js';
-
-import { normalizeEOL } from '@goast/test-utils';
-
-import { TypeScriptFileBuilder } from '../../file-builder.js';
-import { tsDecorator } from './decorator.js';
-import { tsDoc } from './doc.js';
-import { tsFunction } from './function.js';
-import { tsGenericParameter } from './generic-parameter.js';
-import { tsParameter } from './parameter.js';
-
-let builder: TypeScriptFileBuilder;
-
-beforeEach(() => {
-  builder = new TypeScriptFileBuilder();
-});
-
-describe('tsFunction', () => {
-  it('should write the name of the function', () => {
-    builder.append(tsFunction('X'));
-    expect(builder.toString(false)).toBe('function X() {}' + EOL);
-  });
-
-  it('should write the generics if they exist', () => {
-    builder.append(tsFunction('X', { generics: [tsGenericParameter('T'), tsGenericParameter('U')] }));
-    expect(builder.toString(false)).toBe('function X<T, U>() {}' + EOL);
-  });
-
-  it('should write the parameters if they exist', () => {
-    builder.append(tsFunction('X', { parameters: [tsParameter('y'), tsParameter('z')] }));
-    expect(builder.toString(false)).toBe('function X(y, z) {}' + EOL);
-  });
-
-  it('should write the return type if it exists', () => {
-    builder.append(tsFunction('X', { returnType: 'number' }));
-    expect(builder.toString(false)).toBe('function X(): number {}' + EOL);
-  });
-
-  it('should write the body if it exists', () => {
-    builder.append(tsFunction('X', { body: 'return 42;' }));
-    expect(builder.toString(false)).toBe(`function X() {${EOL}  return 42;${EOL}}${EOL}`);
-  });
-
-  it('should write export keyword if configured', () => {
-    builder.append(tsFunction('X', { export: true }));
-    expect(builder.toString(false)).toBe('export function X() {}' + EOL);
-  });
-
-  it('should write documenation if it exists', () => {
-    builder.append(tsFunction('X', { doc: tsDoc({ description: 'description' }) }));
-    expect(builder.toString(false)).toBe(`/**${EOL} * description${EOL} */${EOL}function X() {}${EOL}`);
-  });
-
-  it('should write decorators if they exist', () => {
-    builder.append(tsFunction('X', { decorators: [tsDecorator('decorator')] }));
-    expect(builder.toString(false)).toBe(`@decorator${EOL}function X() {}${EOL}`);
-  });
-
-  it('should write all the parts of the function', () => {
-    builder.append(
-      tsFunction('X', {
-        doc: tsDoc({ description: 'description' }),
-        decorators: [tsDecorator('decorator')],
-        generics: [tsGenericParameter('T'), tsGenericParameter('U')],
-        parameters: [tsParameter('y'), tsParameter('z')],
-        returnType: 'number',
-        body: 'return 42;',
-        export: true,
-      }),
-    );
-    expect(builder.toString(false)).toBe(
-      normalizeEOL(8)(
-        `/**
-         * description
-         */
-        @decorator
-        export function X<T, U>(y, z): number {
-          return 42;
-        }
-        `,
-      ),
-    );
-  });
-
-  it('should render injections', () => {
-    builder.append(
-      tsFunction('X', {
-        doc: tsDoc({ description: 'description' }),
-        decorators: [tsDecorator('decorator')],
-        generics: [tsGenericParameter('T'), tsGenericParameter('U')],
-        parameters: [tsParameter('y'), tsParameter('z')],
-        returnType: 'number',
-        body: 'return 42;',
-        export: true,
-        inject: {
-          before: '║b║',
-          after: '║a║',
-          beforeDoc: '║bd║',
-          afterDoc: '║ad║',
-          beforeDecorators: '║bds║',
-          afterDecorators: '║ads║',
-          beforeModifiers: '║bm║',
-          afterModifiers: '║am║',
-          beforeName: '║bn║',
-          afterName: '║an║',
-          beforeGenerics: '║bg║',
-          afterGenerics: '║ag║',
-          beforeParams: '║bp║',
-          afterParams: '║ap║',
-          beforeReturnType: '║brt║',
-          afterReturnType: '║art║',
-          beforeBody: '║bb║',
-          afterBody: '║ab║',
-        },
-      }),
-    );
-    expect(builder.toString(false)).toBe(
-      normalizeEOL(8)(
-        `║b║║bd║
-        /**
-         * description
-         */
-        ║ad║║bds║@decorator
-        ║ads║║bm║export ║am║function ║bn║X║an║║bg║<T, U>║ag║║bp║(y, z)║ap║: ║brt║number║art║ ║bb║{
-          return 42;
-        }║ab║
-        ║a║`,
-      ),
-    );
-  });
-});

package/src/src/ast/nodes/function.ts

@@ -1,107 +0,0 @@
-import {
-  type AppendValue,
-  type AstNodeOptions,
-  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 TsDecorator, tsDecorator } from './decorator.js';
-import { type TsDoc, tsDoc } from './doc.js';
-import { type TsGenericParameter, tsGenericParameter } from './generic-parameter.js';
-import { type TsParameter, tsParameter } from './parameter.js';
-import type { TsType } from './types.js';
-
-type Injects = 'doc' | 'decorators' | 'modifiers' | 'name' | 'generics' | 'params' | 'returnType' | 'body';
-
-type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
-  typeof TsNode<TBuilder, TInjects | Injects>,
-  {
-    doc?: Nullable<TsDoc<TBuilder>>;
-    decorators?: Nullable<Nullable<TsDecorator<TBuilder>>[]>;
-    export?: boolean;
-    name: string;
-    generics?: Nullable<Nullable<TsGenericParameter<TBuilder>>[]>;
-    parameters?: Nullable<Nullable<TsParameter<TBuilder>>[]>;
-    returnType?: Nullable<TsType<TBuilder>>;
-    body?: Nullable<AppendValue<TBuilder>>;
-  }
->;
-
-export class TsFunction<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<
-  TBuilder,
-  TInjects | Injects
-> {
-  public doc: TsDoc<TBuilder> | null;
-  public decorators: TsDecorator<TBuilder>[];
-  public export: boolean;
-  public name: string;
-  public generics: TsGenericParameter<TBuilder>[];
-  public parameters: TsParameter<TBuilder>[];
-  public returnType: TsType<TBuilder> | null;
-  public body: AppendValue<TBuilder> | null;
-
-  constructor(options: Options<TBuilder, TInjects>) {
-    super(options);
-    this.doc = options.doc ?? null;
-    this.decorators = options.decorators?.filter(notNullish) ?? [];
-    this.export = options.export ?? false;
-    this.name = options.name;
-    this.generics = options.generics?.filter(notNullish) ?? [];
-    this.parameters = options.parameters?.filter(notNullish) ?? [];
-    this.returnType = options.returnType ?? null;
-    this.body = options.body ?? null;
-  }
-
-  protected override onWrite(builder: TBuilder): void {
-    builder.append(this.inject.beforeDoc);
-    tsDoc.write(builder, tsDoc.get(this.doc, { generics: this.generics }));
-    builder.append(this.inject.afterDoc);
-
-    builder.append(this.inject.beforeDecorators);
-    tsDecorator.write(builder, this.decorators, { multiline: true });
-    builder.append(this.inject.afterDecorators);
-
-    builder.append(this.inject.beforeModifiers);
-    if (this.export) builder.append('export ');
-    builder.append(this.inject.afterModifiers);
-
-    builder.append('function ');
-    builder.append(this.inject.beforeName, this.name, this.inject.afterName);
-
-    builder.append(this.inject.beforeGenerics);
-    tsGenericParameter.write(builder, this.generics);
-    builder.append(this.inject.afterGenerics);
-
-    builder.append(this.inject.beforeParams);
-    tsParameter.write(builder, this.parameters);
-    builder.append(this.inject.afterParams);
-
-    if (this.returnType) {
-      builder.append(': ');
-      builder.append(this.inject.beforeReturnType);
-      writeTsNode(builder, this.returnType);
-      builder.append(this.inject.afterReturnType);
-    }
-
-    builder.append(' ');
-
-    builder.append(this.inject.beforeBody);
-    builder.parenthesize('{}', this.body, { multiline: !!this.body });
-    builder.append(this.inject.afterBody);
-
-    builder.appendLine();
-  }
-}
-
-const createFunction = <TBuilder extends SourceBuilder>(
-  name: Options<TBuilder>['name'],
-  options?: Prettify<Omit<Options<TBuilder>, 'name'>>,
-): TsFunction<TBuilder> => new TsFunction<TBuilder>({ ...options, name });
-
-export const tsFunction: typeof createFunction & { write: typeof writeTsNodes } = Object.assign(createFunction, {
-  write: writeTsNodes,
-});