@goast/typescript 0.4.1-beta1 → 0.4.1

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

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

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

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

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

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

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

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

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