@goast/typescript 0.8.0-beta.2 → 0.8.0

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

@@ -0,0 +1,194 @@
+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.ts

@@ -0,0 +1,49 @@
+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.ts

@@ -0,0 +1,53 @@
+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.ts

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

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

@@ -0,0 +1,40 @@
+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.ts

@@ -0,0 +1,62 @@
+import { 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 { TsType } from './types.js';
+
+type Injects = never;
+
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
+  typeof TsNode<TBuilder, TInjects | Injects>,
+  {
+    types: Nullable<TsType<TBuilder>>[];
+  }
+>;
+
+export class TsUnionType<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<
+  TBuilder,
+  TInjects | Injects
+> {
+  public types: TsType<TBuilder>[];
+
+  constructor(options: Options<TBuilder, TInjects>) {
+    super(options);
+    this.types = options.types.filter(notNullish);
+  }
+
+  protected override onWrite(builder: TBuilder): void {
+    const types = this.types.length === 0 ? ['never'] : resolveNestedUnionTypes(this);
+    if (types.length === 1) {
+      writeTsNode(builder, types[0]);
+    } else {
+      const multiline = types.length > 3;
+      if (multiline) {
+        builder.appendLine().append('| ');
+      }
+      builder.forEach(types, (b, t) => b.parenthesize('()', (b) => writeTsNode(b, t)), {
+        separator: multiline ? '\n| ' : ' | ',
+      });
+    }
+  }
+}
+
+const createUnionType = <TBuilder extends SourceBuilder>(
+  types: Options<TBuilder>['types'],
+  options?: Prettify<Omit<Options<TBuilder>, 'types'>>,
+): TsUnionType<TBuilder> => new TsUnionType<TBuilder>({ ...options, types });
+
+export const tsUnionType: typeof createUnionType & { write: typeof writeTsNodes } = Object.assign(createUnionType, {
+  write: writeTsNodes,
+});
+
+function resolveNestedUnionTypes<TBuilder extends SourceBuilder>(node: TsUnionType<TBuilder>): TsType<TBuilder>[] {
+  const types: TsType<TBuilder>[] = [];
+  for (const type of node.types) {
+    if (type instanceof TsUnionType) {
+      types.push(...resolveNestedUnionTypes(type));
+    } else {
+      types.push(type);
+    }
+  }
+  return types;
+}

package/src/src/ast/nodes/variable.ts

@@ -0,0 +1,73 @@
+import type { AstNodeOptions, Nullable, Prettify, 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 { TsType, TsValue } 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>>;
+    type?: Nullable<TsType<TBuilder>>;
+    value?: Nullable<TsValue<TBuilder>>;
+    export?: Nullable<boolean>;
+    readonly?: Nullable<boolean>;
+  }
+>;
+
+export class TsVariable<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<
+  TBuilder,
+  TInjects | Injects
+> {
+  public name: string;
+  public doc: TsDoc<TBuilder> | null;
+  public type: TsType<TBuilder> | null;
+  public value: TsValue<TBuilder> | null;
+  public export: boolean;
+  public readonly: boolean;
+
+  constructor(options: Options<TBuilder, TInjects>) {
+    super(options);
+    this.name = options.name;
+    this.doc = options.doc ?? null;
+    this.type = options.type ?? null;
+    this.value = options.value ?? null;
+    this.export = options.export ?? false;
+    this.readonly = options.readonly ?? false;
+  }
+
+  protected override onWrite(builder: TBuilder): void {
+    if (this.doc) writeTsNode(builder, this.doc);
+    if (this.export) builder.append('export ');
+
+    builder.append(this.readonly ? 'const ' : 'let ');
+    builder.append(this.name);
+
+    if (this.type) {
+      builder.append(': ');
+      writeTsNode(builder, this.type);
+    }
+
+    if (this.value) {
+      builder.append(' = ');
+      writeTsNode(builder, this.value);
+    }
+
+    builder.append(';');
+
+    builder.appendLine();
+  }
+}
+
+const createVariable = <TBuilder extends SourceBuilder>(
+  name: Options<TBuilder>['name'],
+  options?: Prettify<Omit<Options<TBuilder>, 'name'>>,
+): TsVariable<TBuilder> => new TsVariable<TBuilder>({ ...options, name });
+
+export const tsVariable: typeof createVariable & { write: typeof writeTsNodes } = Object.assign(createVariable, {
+  write: writeTsNodes,
+});

package/src/src/ast/references/angular.ts

@@ -0,0 +1,24 @@
+import {
+  type TsGenericModuleReferenceFactory,
+  type TsModuleReferenceFactory,
+  tsReference,
+} from '../nodes/reference.js';
+
+// @angular/core
+export const inject: TsModuleReferenceFactory = tsReference.factory('inject', '@angular/core');
+export const injectable: TsModuleReferenceFactory = tsReference.factory('Injectable', '@angular/core');
+export const provider: TsModuleReferenceFactory = tsReference.factory('Provider', '@angular/core', {
+  importType: 'type-import',
+});
+
+// @angular/common/http
+export const httpClient: TsModuleReferenceFactory = tsReference.factory('HttpClient', '@angular/common/http');
+export const httpContext: TsModuleReferenceFactory = tsReference.factory('HttpContext', '@angular/common/http');
+export const httpResponse: TsGenericModuleReferenceFactory<1> = tsReference.genericFactory<1>(
+  'HttpResponse',
+  '@angular/common/http',
+);
+export const httpErrorResponse: TsModuleReferenceFactory = tsReference.factory(
+  'HttpErrorResponse',
+  '@angular/common/http',
+);

package/src/src/ast/references/easy-network-stub.ts

@@ -0,0 +1,21 @@
+import {
+  type TsGenericModuleReferenceFactory,
+  type TsModuleReferenceFactory,
+  tsReference,
+} from '../nodes/reference.js';
+
+export const easyNetworkStub: TsModuleReferenceFactory = tsReference.factory('EasyNetworkStub', 'easy-network-stub');
+export const httpMethod: TsModuleReferenceFactory = tsReference.factory('HttpMethod', 'easy-network-stub', {
+  importType: 'type-import',
+});
+export const routeResponseCallback: TsGenericModuleReferenceFactory<2> = tsReference.genericFactory<2>(
+  'RouteResponseCallback',
+  'easy-network-stub',
+  {
+    importType: 'type-import',
+  },
+);
+export const errorResponse: TsGenericModuleReferenceFactory<1> = tsReference.genericFactory<1>(
+  'ErrorResponse',
+  'easy-network-stub',
+);

package/src/src/ast/references/index.ts

@@ -0,0 +1,5 @@
+export * as angular from './angular.js';
+export * as easyNetworkStub from './easy-network-stub.js';
+export * as k6 from './k6.js';
+export * as rxjs from './rxjs.js';
+export * from './typescript.js';

package/src/src/ast/references/k6.ts

@@ -0,0 +1,8 @@
+import { type TsModuleReferenceFactory, tsReference } from '../nodes/reference.js';
+
+// k6
+export const jsonValue: TsModuleReferenceFactory = tsReference.factory('JSONValue', 'k6');
+
+// h6/http
+export const response: TsModuleReferenceFactory = tsReference.factory('Response', 'k6/http');
+export const params: TsModuleReferenceFactory = tsReference.factory('Params', 'k6/http');

package/src/src/ast/references/rxjs.ts

@@ -0,0 +1,7 @@
+import { type TsModuleReferenceFactory, tsReference } from '../nodes/reference.js';
+
+export const observable: TsModuleReferenceFactory = tsReference.factory('Observable', 'rxjs');
+export const firstValueFrom: TsModuleReferenceFactory = tsReference.factory('firstValueFrom', 'rxjs');
+export const filter: TsModuleReferenceFactory = tsReference.factory('filter', 'rxjs');
+export const map: TsModuleReferenceFactory = tsReference.factory('map', 'rxjs');
+export const take: TsModuleReferenceFactory = tsReference.factory('take', 'rxjs');