@goast/typescript 0.5.3 → 0.6.0-beta.1

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.ts

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

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

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

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

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

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

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

package/src/src/ast/references/typescript.ts

@@ -1,35 +0,0 @@
-import { type TsGenericReferenceFactory, tsReference, type TsReferenceFactory } from '../nodes/reference.js';
-
-export const any: TsReferenceFactory = tsReference.factory('any');
-export const unknown: TsReferenceFactory = tsReference.factory('unknown');
-export const void_: TsReferenceFactory = tsReference.factory('void');
-export const never: TsReferenceFactory = tsReference.factory('never');
-export const number: TsReferenceFactory = tsReference.factory('number');
-export const string: TsReferenceFactory = tsReference.factory('string');
-export const boolean: TsReferenceFactory = tsReference.factory('boolean');
-export const bigint: TsReferenceFactory = tsReference.factory('bigint');
-export const symbol: TsReferenceFactory = tsReference.factory('symbol');
-export const object: TsReferenceFactory = tsReference.factory('object');
-export const undefined_: TsReferenceFactory = tsReference.factory('undefined');
-export const null_: TsReferenceFactory = tsReference.factory('null');
-
-export const array: TsGenericReferenceFactory<1> = tsReference.genericFactory<1>('Array');
-export const record: TsGenericReferenceFactory<2> = tsReference.genericFactory<2>('Record');
-export const map: TsGenericReferenceFactory<2> = tsReference.genericFactory<2>('Map');
-export const set: TsGenericReferenceFactory<1> = tsReference.genericFactory<1>('Set');
-export const promise: TsGenericReferenceFactory<1> = tsReference.genericFactory<1>('Promise');
-
-export const readonlyArray: TsGenericReferenceFactory<1> = tsReference.genericFactory<1>('ReadonlyArray');
-export const readonly: TsGenericReferenceFactory<1> = tsReference.genericFactory<1>('Readonly');
-export const partial: TsGenericReferenceFactory<1> = tsReference.genericFactory<1>('Partial');
-export const required: TsGenericReferenceFactory<1> = tsReference.genericFactory<1>('Required');
-export const pick: TsGenericReferenceFactory<2> = tsReference.genericFactory<2>('Pick');
-export const omit: TsGenericReferenceFactory<2> = tsReference.genericFactory<2>('Omit');
-export const exclude: TsGenericReferenceFactory<2> = tsReference.genericFactory<2>('Exclude');
-export const extract: TsGenericReferenceFactory<2> = tsReference.genericFactory<2>('Extract');
-export const nonNullable: TsGenericReferenceFactory<1> = tsReference.genericFactory<1>('NonNullable');
-export const parameters: TsGenericReferenceFactory<1> = tsReference.genericFactory<1>('Parameters');
-export const returnType: TsGenericReferenceFactory<1> = tsReference.genericFactory<1>('ReturnType');
-export const instanceType: TsGenericReferenceFactory<1> = tsReference.genericFactory<1>('InstanceType');
-
-export const blob: TsReferenceFactory = tsReference.factory('Blob');

package/src/src/ast/utils/get-type-script-builder-options.ts

@@ -1,19 +0,0 @@
-import { defaultOpenApiGeneratorConfig, type SourceBuilder, type StringBuilder } from '@goast/core';
-
-import { defaultTypeScriptGeneratorConfig, type TypeScriptGeneratorConfig } from '../../config.js';
-import { TypeScriptFileBuilder } from '../../file-builder.js';
-
-const tsConfigSymbol = Symbol();
-type _BuilderWithConfig = SourceBuilder & { [tsConfigSymbol]?: TypeScriptGeneratorConfig };
-
-export function getTypeScriptBuilderOptions(builder: StringBuilder): TypeScriptGeneratorConfig {
-  if (builder instanceof TypeScriptFileBuilder) {
-    return builder.options;
-  }
-  if (tsConfigSymbol in builder.options) {
-    return builder.options[tsConfigSymbol] as TypeScriptGeneratorConfig;
-  }
-  const options = { ...defaultOpenApiGeneratorConfig, ...defaultTypeScriptGeneratorConfig, ...builder.options };
-  (builder as _BuilderWithConfig)[tsConfigSymbol] = options;
-  return options;
-}

package/src/src/ast/utils/to-ts-node.ts

@@ -1,27 +0,0 @@
-import type { BasicAppendValue, SourceBuilder } from '@goast/core';
-
-import { type TsObject, tsObject } from '../nodes/object.js';
-import { tsProperty } from '../nodes/property.js';
-import { type TsString, tsString } from '../nodes/string.js';
-import { type TsTuple, tsTuple } from '../nodes/tuple.js';
-
-export function toTsNode<TBuilder extends SourceBuilder>(object: Record<string, unknown>): TsObject<TBuilder>;
-export function toTsNode<TBuilder extends SourceBuilder>(tuple: unknown[]): TsTuple<TBuilder>;
-export function toTsNode<TBuilder extends SourceBuilder>(string: string): TsString<TBuilder>;
-export function toTsNode<TBuilder extends SourceBuilder>(value: unknown): BasicAppendValue<TBuilder>;
-export function toTsNode<TBuilder extends SourceBuilder>(value: unknown): unknown {
-  if (Array.isArray(value)) {
-    return tsTuple(value.map((x) => toTsNode<TBuilder>(x)));
-  }
-  if (typeof value === 'object' && value !== null) {
-    const result = tsObject<TBuilder>();
-    for (const [k, v] of Object.entries(value)) {
-      result.members.push(tsProperty(k, { value: toTsNode(v) }));
-    }
-    return result;
-  }
-  if (value === null || value === undefined || typeof value === 'boolean' || typeof value === 'number') {
-    return String(value);
-  }
-  return tsString(String(value));
-}

package/src/src/ast/utils/write-ts-generic-parameters.ts

@@ -1,25 +0,0 @@
-import {
-  type AppendValue,
-  notNullish,
-  type Nullable,
-  type SingleOrMultiple,
-  type SourceBuilder,
-  toArray,
-} from '@goast/core';
-
-import type { TsNode } from '../node.js';
-import { writeTsNodes } from './write-ts-nodes.js';
-
-export function writeTsGenericParameters<TBuilder extends SourceBuilder>(
-  builder: TBuilder,
-  nodes: SingleOrMultiple<Nullable<TsNode<TBuilder> | AppendValue<TBuilder>>>,
-): void {
-  const filteredNodes = toArray(nodes).filter(notNullish);
-  const multiline = filteredNodes.length > 2;
-  builder.parenthesizeIf(
-    filteredNodes.length > 0,
-    '<>',
-    (b) => writeTsNodes(b, filteredNodes, { separator: multiline ? ',\n' : ', ' }),
-    { multiline },
-  );
-}

package/src/src/ast/utils/write-ts-members.ts

@@ -1,28 +0,0 @@
-import { type AppendValue, isAppendValue, notNullish, type Nullable, type SourceBuilder } from '@goast/core';
-
-import type { TsNode } from '../node.js';
-import { tsDoc } from '../nodes/doc.js';
-import { TsMethod } from '../nodes/method.js';
-import { TsProperty } from '../nodes/property.js';
-import { writeTsNode } from './write-ts-nodes.js';
-
-export function writeTsMembers<TBuilder extends SourceBuilder>(
-  builder: TBuilder,
-  members: Nullable<AppendValue<TBuilder> | TsNode<TBuilder>>[],
-  options?: { alreadyHasMembers?: boolean },
-): void {
-  const filteredMembers = members.filter(notNullish);
-  builder.forEach(filteredMembers, (b, m, i) =>
-    b.if(
-      () =>
-        !(m instanceof TsProperty && tsDoc.isEmpty(m.doc) && m.decorators.length === 0) &&
-        !(m instanceof TsMethod && !m.body && tsDoc.isEmpty(m.doc) && m.decorators.length === 0) &&
-        !isAppendValue(m),
-      (b) =>
-        b
-          .if(i > 0 || !!options?.alreadyHasMembers, (b) => b.ensurePreviousLineEmpty())
-          .append((b) => writeTsNode(b, m))
-          .if(i < filteredMembers.length - 1, (b) => b.ensurePreviousLineEmpty()),
-      (b) => b.append((b) => writeTsNode(b, m)).ensureCurrentLineEmpty(),
-    ));
-}

package/src/src/ast/utils/write-ts-nodes.ts

@@ -1,35 +0,0 @@
-import {
-  type AppendValue,
-  notNullish,
-  type Nullable,
-  type Separator,
-  type SingleOrMultiple,
-  type SourceBuilder,
-  toArray,
-} from '@goast/core';
-
-import { TsNode } from '../node.js';
-
-export function writeTsNode<TBuilder extends SourceBuilder>(
-  builder: TBuilder,
-  node: Nullable<AppendValue<TBuilder> | TsNode<TBuilder>>,
-): void {
-  if (node instanceof TsNode) {
-    node.write(builder);
-  } else {
-    builder.append(node);
-  }
-}
-
-export function writeTsNodes<TBuilder extends SourceBuilder>(
-  builder: TBuilder,
-  nodes: SingleOrMultiple<Nullable<AppendValue<TBuilder> | TsNode<TBuilder>>>,
-  options?: { separator?: Separator<TBuilder, AppendValue<TBuilder> | TsNode<TBuilder>> },
-): void {
-  const filteredNodes = toArray(nodes).filter(notNullish);
-  if (filteredNodes.length === 1) {
-    writeTsNode(builder, filteredNodes[0]);
-  } else if (filteredNodes.length > 1) {
-    builder.forEach(filteredNodes, writeTsNode, { separator: options?.separator });
-  }
-}

package/src/src/ast/utils/write-ts-parameters.ts

@@ -1,25 +0,0 @@
-import {
-  type AppendValue,
-  notNullish,
-  type Nullable,
-  type SingleOrMultiple,
-  type SourceBuilder,
-  toArray,
-} from '@goast/core';
-
-import type { TsNode } from '../node.js';
-import { writeTsNodes } from './write-ts-nodes.js';
-
-export function writeTsParameters<TBuilder extends SourceBuilder>(
-  builder: TBuilder,
-  nodes: SingleOrMultiple<Nullable<TsNode<TBuilder> | AppendValue<TBuilder>>>,
-) {
-  const filteredNodes = toArray(nodes).filter(notNullish);
-  const multiline = filteredNodes.length > 2 ||
-    filteredNodes.some((p) =>
-      typeof p === 'object' && 'decorators' in p && Array.isArray(p.decorators) && p.decorators.length > 0
-    );
-  builder.parenthesize('()', (b) => writeTsNodes(b, filteredNodes, { separator: multiline ? ',\n' : ', ' }), {
-    multiline,
-  });
-}

package/src/src/common-results.ts

@@ -1,26 +0,0 @@
-import type { TypeScriptExportOptions } from './import-collection.js';
-
-export type TypeScriptComponentOutputKind = 'interface' | 'type' | 'enum' | 'class' | 'function' | 'variable';
-export type TypeScriptComponentOutput = {
-  component: string;
-  filePath?: string;
-  imports: TypeScriptImport[];
-  additionalExports?: string[] | ({ name: string } & TypeScriptExportOptions)[];
-  kind?: TypeScriptComponentOutputKind;
-};
-
-export type TypeScriptExportOutput = {
-  component: string;
-  filePath: string;
-} & TypeScriptExportOptions;
-
-export type TypeScriptImportKind = 'module' | 'file';
-export type TypeScriptImportType = 'import' | 'type-import' | 'js-doc';
-export type TypeScriptExportType = 'export' | 'type-export';
-
-export type TypeScriptImport = {
-  kind: TypeScriptImportKind;
-  type: TypeScriptImportType;
-  modulePath: string;
-  name: string;
-};