@goast/typescript 0.5.2 → 0.5.3-beta.1

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;
-};

package/src/src/config.ts

@@ -1,89 +0,0 @@
-import type { DefaultGenerationProviderConfig, ExtendedStringCasing, OpenApiGeneratorConfig } from '@goast/core';
-
-import type { ImportModuleTransformer } from './utils.js';
-
-export type TypeScriptGeneratorConfig = OpenApiGeneratorConfig & {
-  /**
-   * The transformer to use for transforming import module paths.
-   * @default 'omit-extension'
-   */
-  importModuleTransformer: ImportModuleTransformer;
-
-  /**
-   * The casing to use for file names.
-   * @default 'kebab'
-   */
-  fileNameCasing: ExtendedStringCasing;
-
-  /**
-   * The casing to use for type names.
-   * @default 'pascal'
-   */
-  typeNameCasing: ExtendedStringCasing;
-
-  /**
-   * The casing to use for function names.
-   * @default 'camel'
-   */
-  functionNameCasing: ExtendedStringCasing;
-
-  /**
-   * The casing to use for property names.
-   * @default 'camel'
-   */
-  propertyNameCasing: ExtendedStringCasing;
-
-  /**
-   * The casing to use for enum value names.
-   * @default 'pascal'
-   */
-  enumValueNameCasing: ExtendedStringCasing;
-
-  /**
-   * The casing to use for constant names.
-   * @default { casing: 'snake', wordCasing: 'all-upper' }
-   */
-  constantNameCasing: ExtendedStringCasing;
-
-  /**
-   * The casing to use for generic parameter names.
-   * @default { casing: 'pascal', prefix: 'T' }
-   */
-  genericParamNameCasing: ExtendedStringCasing;
-
-  /**
-   * The casing to use for parameter names.
-   * @default 'camel'
-   */
-  paramNameCasing: ExtendedStringCasing;
-
-  /**
-   * Whether to prefer `unknown` over `any`.
-   * @default true
-   */
-  preferUnknown: boolean;
-
-  /**
-   * Whether to use single quotes for strings.
-   * @default true
-   */
-  useSingleQuotes: boolean;
-};
-
-export const defaultTypeScriptGeneratorConfig: DefaultGenerationProviderConfig<TypeScriptGeneratorConfig> = {
-  indent: { type: 'spaces', count: 2 },
-
-  importModuleTransformer: 'omit-extension',
-
-  fileNameCasing: 'kebab',
-  typeNameCasing: 'pascal',
-  functionNameCasing: 'camel',
-  propertyNameCasing: 'camel',
-  enumValueNameCasing: 'pascal',
-  constantNameCasing: { casing: 'snake', wordCasing: 'all-upper' },
-  genericParamNameCasing: { casing: 'pascal', prefix: 'T' },
-  paramNameCasing: 'camel',
-
-  preferUnknown: true,
-  useSingleQuotes: true,
-};

package/src/src/file-builder.ts

@@ -1,136 +0,0 @@
-import { dirname } from 'node:path';
-
-
-import fs from 'fs-extra';
-
-import { type AppendParam, type AppendValue, isAppendValue, type Nullable, SourceBuilder } from '@goast/core';
-
-import { TsNode } from './ast/node.js';
-import { defaultTypeScriptGeneratorConfig, type TypeScriptGeneratorConfig } from './config.js';
-import type { TypeScriptModelGeneratorOutput } from './generators/index.js';
-import {
-  ImportExportCollection,
-  type TypeScriptExportOptions,
-  type TypeScriptImportOptions,
-} from './import-collection.js';
-
-export type TypeScriptAppends<TAdditionalAppends> = TsNode<TypeScriptFileBuilder> | TAdditionalAppends;
-export type TypeScriptAppendParam<TBuilder extends TypeScriptFileBuilder, TAdditionalAppends> = AppendParam<
-  TBuilder,
-  TypeScriptAppends<TAdditionalAppends>
->;
-
-export function isTypeScriptAppendValue<TBuilder extends TypeScriptFileBuilder = TypeScriptFileBuilder>(
-  value: unknown,
-): value is AppendValue<TBuilder> {
-  return isAppendValue(value) || value instanceof TsNode;
-}
-
-export class TypeScriptFileBuilder<TAdditionalAppends = never>
-  extends SourceBuilder<TypeScriptAppends<TAdditionalAppends>> {
-  public readonly filePath: string | undefined;
-  public readonly imports: ImportExportCollection;
-
-  public override get options(): TypeScriptGeneratorConfig {
-    return super.options as TypeScriptGeneratorConfig;
-  }
-
-  constructor(filePath?: string, options?: TypeScriptGeneratorConfig) {
-    super(options ?? defaultTypeScriptGeneratorConfig);
-    this.filePath = filePath;
-    this.imports = new ImportExportCollection({
-      filePath: filePath,
-      importModuleTransformer: this.options.importModuleTransformer,
-      useSingleQuotes: this.options.useSingleQuotes,
-    });
-  }
-
-  public addImport(name: string, moduleNameOrfilePath: string, options?: TypeScriptImportOptions): this {
-    this.imports.addImport(name, moduleNameOrfilePath, options);
-    return this;
-  }
-
-  public addExport(name: string, filePath: string, options?: TypeScriptExportOptions): this {
-    this.imports.addExport(name, filePath, options);
-    return this;
-  }
-
-  public override clear(): void {
-    super.clear();
-    this.imports.clear();
-  }
-
-  public override toString(addPadding: boolean = true): string {
-    const builder = new SourceBuilder(this.options);
-    if (this.filePath?.match(/\.[cm]?js$/)) {
-      builder.appendLine('// @ts-check');
-    }
-
-    builder.ensurePreviousLineEmpty();
-    this.imports.writeTo(builder);
-
-    const baseString = super.toString();
-    if (baseString && addPadding) {
-      builder.ensurePreviousLineEmpty();
-    }
-
-    builder.append(baseString);
-
-    if (addPadding) {
-      builder.ensureCurrentLineEmpty();
-    }
-
-    return builder.toString();
-  }
-
-  protected override appendSingle(value: TypeScriptAppendParam<this, TAdditionalAppends>) {
-    super.appendSingle(value);
-    if (value instanceof TsNode) {
-      value.write(this);
-    }
-  }
-
-  public appendModelUsage(type: TypeScriptModelGeneratorOutput, options?: TypeScriptImportOptions): this {
-    this.append(options?.type === 'js-doc' ? type.component.replace(/\/\*\*.*\*\/\s*/gs, '') : type.component);
-    for (const i of type.imports) {
-      this.addImport(i.name, i.modulePath, { ...i, ...options });
-    }
-    return this;
-  }
-
-  public writeToFile(filePath?: string): void {
-    if (!filePath) filePath = this.filePath;
-    if (!filePath) throw new Error('File path is required');
-    fs.ensureDirSync(dirname(filePath));
-    fs.writeFileSync(filePath, this.toString());
-  }
-
-  public static generate(options: {
-    filePath: string;
-    logName?: Nullable<string>;
-    options?: TypeScriptGeneratorConfig;
-    generator: (builder: TypeScriptFileBuilder) => void;
-  }): void {
-    TypeScriptFileBuilder.tryGenerate(options);
-  }
-
-  public static tryGenerate({
-    filePath,
-    generator,
-    options,
-    logName,
-  }: {
-    filePath: Nullable<string>;
-    logName?: Nullable<string>;
-    options?: TypeScriptGeneratorConfig;
-    generator: (builder: TypeScriptFileBuilder) => void;
-  }) {
-    if (!filePath) return;
-    if (logName) {
-      console.log(`Generating ${logName} to ${filePath}...`);
-    }
-    const builder = new TypeScriptFileBuilder(filePath, options);
-    generator(builder);
-    builder.writeToFile();
-  }
-}

package/src/src/generators/file-generator.ts

@@ -1,15 +0,0 @@
-import type { MaybePromise, OpenApiGenerationProviderContext, OpenApiGeneratorInput, SourceBuilder } from '@goast/core';
-
-import { ts } from '../ast/index.js';
-import type { TypeScriptGeneratorConfig } from '../config.js';
-
-export abstract class TypeScriptFileGenerator<
-  TContext extends OpenApiGenerationProviderContext<OpenApiGeneratorInput, TypeScriptGeneratorConfig>,
-  TOutput,
-> {
-  public abstract generate(context: TContext): MaybePromise<TOutput>;
-
-  protected getAnyType(context: TContext): ts.Reference<SourceBuilder> {
-    return context.config.preferUnknown ? ts.refs.unknown() : ts.refs.any();
-  }
-}

package/src/src/generators/index.ts

@@ -1,6 +0,0 @@
-export * from './file-generator.js';
-export * from './models/index.js';
-export * from './services/angular-services/index.js';
-export * from './services/easy-network-stub/index.js';
-export * from './services/fetch-clients/index.js';
-export * from './services/k6-clients/index.js';

package/src/src/generators/models/index.ts

@@ -1,3 +0,0 @@
-export * from './model-generator.js';
-export * from './models-generator.js';
-export * from './models.js';