@goast/typescript 0.3.6 → 0.3.7-beta1

package/esm/lib/generators/services/easy-network-stub/easy-network-stub-generator.js

@@ -94,15 +94,15 @@ export class DefaultTypeScriptEasyNetworkStubGenerator extends TypeScriptFileGen
             ],
             returnType: 'this',
             body: appendValueGroup([
-                s `this.stubWrapper.stub2<${requestType}>()(${s.indent `
-              ${ts.string(endpoint.method.toUpperCase())},
-              ${this.getStubClassName(ctx)}.${this.getEndpointPathPropertyName(ctx, endpoint)},
-              async (request) => {${s.indent `
-                if (this.stubWrapper.options.rememberRequests) {${s.indent `
-                  this.${this.getEndpointRequestsFieldName(ctx, endpoint)}.push(request);`}
-                }
-                throw await response(${this.getResponderVariableName(ctx, endpoint)}, request);`}
-              }`}
+                s `this.stubWrapper.stub2<${requestType}>()(${s.indent `
+              ${ts.string(endpoint.method.toUpperCase())},
+              ${this.getStubClassName(ctx)}.${this.getEndpointPathPropertyName(ctx, endpoint)},
+              async (request) => {${s.indent `
+                if (this.stubWrapper.options.rememberRequests) {${s.indent `
+                  this.${this.getEndpointRequestsFieldName(ctx, endpoint)}.push(request);`}
+                }
+                throw await response(${this.getResponderVariableName(ctx, endpoint)}, request);`}
+              }`}
             );`,
                 'return this;',
             ], '\n'),

package/esm/lib/generators/services/easy-network-stub/easy-network-stubs-generator.js

@@ -79,13 +79,15 @@ export class TypeScriptEasyNetworkStubsGenerator extends OpenApiServicesGenerati
                 ...Object.entries(ctx.output.typescript.stubs).map(([id, x]) => ts.property(toCasing(serviceNames[id], fieldCasing), {
                     accessModifier: 'private',
                     optional: true,
-                    type: ctx.refs.easyNetworkStubGroup([ts.reference(x.component, x.filePath), 'this']),
+                    type: ctx.refs.easyNetworkStubGroup([ts.reference(x.component, x.filePath), 'this'], {
+                        importType: 'type-import',
+                    }),
                 })),
                 ts.constructor({
                     parameters: [
                         ts.constructorParameter('stub', { type: ts.refs.easyNetworkStub.easyNetworkStub() }),
                         ts.constructorParameter('options', {
-                            type: ts.refs.partial([ctx.refs.easyNetworkStubWrapperOptions()]),
+                            type: ts.refs.partial([ctx.refs.easyNetworkStubWrapperOptions()], { importType: 'type-import' }),
                             optional: true,
                         }),
                     ],
@@ -93,14 +95,16 @@ export class TypeScriptEasyNetworkStubsGenerator extends OpenApiServicesGenerati
                 }),
                 ts.property('requests', {
                     accessModifier: 'public',
-                    type: ts.arrayType(ctx.refs.stubRequestItem(), { readonly: true }),
+                    type: ts.arrayType(ctx.refs.stubRequestItem({ importType: 'type-import' }), { readonly: true }),
                     get: ts.property.getter({
                         body: appendValueGroup(['return this._stubWrapper.requests;'], '\n'),
                     }),
                 }),
                 ...Object.entries(ctx.output.typescript.stubs).map(([id, x]) => ts.property(toCasing(serviceNames[id], ctx.config.propertyNameCasing), {
                     accessModifier: 'public',
-                    type: ctx.refs.easyNetworkStubGroup([ts.reference(x.component, x.filePath), 'this']),
+                    type: ctx.refs.easyNetworkStubGroup([ts.reference(x.component, x.filePath), 'this'], {
+                        importType: 'type-import',
+                    }),
                     get: ts.property.getter({
                         body: appendValueGroup([
                             s `return this.${toCasing(serviceNames[id], fieldCasing)} ??= ${ctx.refs.createEasyNetworkStubGroup.infer()}(this, this._stubWrapper, ${ts.reference(x.component, x.filePath)});`,

package/esm/lib/generators/services/easy-network-stub/refs.js

@@ -6,14 +6,20 @@ export function getReferenceFactories(options) {
     const easyNetworkStubUtilsPath = join(utilsDirPath, 'easy-network-stub.utils.ts');
     return {
         // easy-network-stub.utils.ts
-        easyNetworkStubWrapperOptions: ts.reference.factory('EasyNetworkStubWrapperOptions', easyNetworkStubUtilsPath),
-        stubRequestItem: ts.reference.factory('StubRequestItem', easyNetworkStubUtilsPath),
-        stubRequestInfo: ts.reference.genericFactory('StubRequestInfo', easyNetworkStubUtilsPath),
-        strictRouteResponseCallback: ts.reference.genericFactory('StrictRouteResponseCallback', easyNetworkStubUtilsPath),
+        easyNetworkStubWrapperOptions: ts.reference.factory('EasyNetworkStubWrapperOptions', easyNetworkStubUtilsPath, {
+            importType: 'type-import',
+        }),
+        stubRequestItem: ts.reference.factory('StubRequestItem', easyNetworkStubUtilsPath, { importType: 'type-import' }),
+        stubRequestInfo: ts.reference.genericFactory('StubRequestInfo', easyNetworkStubUtilsPath, {
+            importType: 'type-import',
+        }),
+        strictRouteResponseCallback: ts.reference.genericFactory('StrictRouteResponseCallback', easyNetworkStubUtilsPath, { importType: 'type-import' }),
         getStubResponder: ts.reference.genericFactory('getStubResponder', easyNetworkStubUtilsPath),
         easyNetworkStubWrapper: ts.reference.factory('EasyNetworkStubWrapper', easyNetworkStubUtilsPath),
         easyNetworkStubBase: ts.reference.factory('EasyNetworkStubBase', easyNetworkStubUtilsPath),
-        easyNetworkStubGroup: ts.reference.genericFactory('EasyNetworkStubGroup', easyNetworkStubUtilsPath),
+        easyNetworkStubGroup: ts.reference.genericFactory('EasyNetworkStubGroup', easyNetworkStubUtilsPath, {
+            importType: 'type-import',
+        }),
         createEasyNetworkStubGroup: ts.reference.genericFactory('createEasyNetworkStubGroup', easyNetworkStubUtilsPath),
     };
 }

package/esm/lib/generators/services/fetch-clients/fetch-client-generator.js

@@ -133,7 +133,7 @@ export class DefaultTypeScriptFetchClientGenerator extends TypeScriptFileGenerat
         const method = this.getInterfaceEndpointMethod(ctx, endpoint);
         method.accessModifier = 'public';
         method.body = appendValueGroup([
-            s `const url = new ${ctx.refs.urlBuilder()}(this.options.baseUrl)${s.indent `
+            s `const url = new ${ctx.refs.urlBuilder()}(this.options.baseUrl)${s.indent `
           .withPath(${ts.string(endpoint.path)})${(b) => b.forEach(endpoint.parameters, (b, p) => {
                 switch (p.target) {
                     case 'path':
@@ -143,7 +143,7 @@ export class DefaultTypeScriptFetchClientGenerator extends TypeScriptFileGenerat
                         b.append(s `\n.withQueryParam(${ts.string(p.name)}, params.${toCasing(p.name, ctx.config.paramNameCasing)})`);
                         break;
                 }
-            })}
+            })}
           .build();`}`,
             s `const response = (this.options.fetch ?? fetch)(url, ${ts.object({
                 members: [

package/esm/lib/generators/services/fetch-clients/refs.js

@@ -6,8 +6,8 @@ export function getReferenceFactories(options) {
     const fetchClientUtilsPath = resolve(utilsDirPath, 'fetch-client.utils.ts');
     return {
         // fetch-client.utils.ts
-        typedResponse: ts.reference.genericFactory('TypedResponse', fetchClientUtilsPath),
-        fetchClientOptions: ts.reference.factory('FetchClientOptions', fetchClientUtilsPath),
+        typedResponse: ts.reference.genericFactory('TypedResponse', fetchClientUtilsPath, { importType: 'type-import' }),
+        fetchClientOptions: ts.reference.factory('FetchClientOptions', fetchClientUtilsPath, { importType: 'type-import' }),
         urlBuilder: ts.reference.factory('UrlBuilder', fetchClientUtilsPath),
     };
 }

package/esm/lib/generators/services/k6-clients/k6-client-generator.js

@@ -186,7 +186,7 @@ export class DefaultTypeScriptK6ClientGenerator extends TypeScriptFileGenerator
                         ],
                     }),
                     parameters: [ts.constructorParameter('rootUrl'), ts.constructorParameter('defaultK6ParamsFactory')],
-                    body: s `this.rootUrl = rootUrl;
+                    body: s `this.rootUrl = rootUrl;
                   this._defaultK6ParamsFactory = defaultK6ParamsFactory;`,
                 }),
                 ...ctx.service.endpoints.map((e) => this.getEndpointMethod(ctx, e)),
@@ -245,11 +245,11 @@ export class DefaultTypeScriptK6ClientGenerator extends TypeScriptFileGenerator
                     }
                     : null,
                 '',
-                s `return /** @type {${returnType}} */ (${s.indent `
-              ${ctx.config.async ? 'await rb.buildAsync' : 'rb.build'}({${s.indent `
-                accept: ${ts.string(accept)},
-                params: this.getK6Params(k6Params),`}
-              })`}
+                s `return /** @type {${returnType}} */ (${s.indent `
+              ${ctx.config.async ? 'await rb.buildAsync' : 'rb.build'}({${s.indent `
+                accept: ${ts.string(accept)},
+                params: this.getK6Params(k6Params),`}
+              })`}
             );`,
             ], '\n'),
         });

package/esm/lib/import-collection.js

@@ -12,13 +12,14 @@ export class ImportExportCollection {
         this._typeImports = new Map();
         this._jsDocImports = new Map();
         this._exports = new Map();
+        this._typeExports = new Map();
         this._options = { ...defaultImportExportCollectionOptions, ...options };
     }
     get hasImports() {
         return this._imports.size > 0 || this._typeImports.size > 0 || this._jsDocImports.size > 0;
     }
     get hasExports() {
-        return this._exports.size > 0;
+        return this._exports.size > 0 || this._typeExports.size > 0;
     }
     get imports() {
         return [
@@ -48,28 +49,23 @@ export class ImportExportCollection {
             map.set(fromModule, new Set([importName]));
         }
     }
-    getImportMap(type) {
-        switch (type) {
-            case 'import':
-                return this._imports;
-            case 'type-import':
-                return this._typeImports;
-            case 'js-doc':
-                return this._jsDocImports;
-        }
-    }
-    addExport(exportName, fromModule) {
-        const existingExport = this._exports.get(fromModule);
+    addExport(exportName, fromModule, options) {
+        var _a;
+        const map = this.getExportMap((_a = options === null || options === void 0 ? void 0 : options.type) !== null && _a !== void 0 ? _a : 'export');
+        const existingExport = map.get(fromModule);
         if (existingExport) {
             existingExport.add(exportName);
         }
         else {
-            this._exports.set(fromModule, new Set([exportName]));
+            map.set(fromModule, new Set([exportName]));
         }
     }
     clear() {
         this._imports.clear();
+        this._typeImports.clear();
+        this._jsDocImports.clear();
         this._exports.clear();
+        this._typeExports.clear();
     }
     toString(options) {
         const builder = new StringBuilder(options);
@@ -108,6 +104,15 @@ export class ImportExportCollection {
             }
             const sortedExports = this.sortAndResolve(this._exports, filePath, importModuleTransformer);
             this.writeImportsExports(builder, 'export', sortedExports, { useSingleQuotes });
+            hasPrevious = true;
+        }
+        if (this._typeExports.size > 0) {
+            if (hasPrevious) {
+                builder.appendLine();
+            }
+            const sortedExports = this.sortAndResolve(this._typeExports, filePath, importModuleTransformer);
+            this.writeImportsExports(builder, 'export type', sortedExports, { useSingleQuotes });
+            hasPrevious = true;
         }
     }
     writeImportsExports(builder, keyword, data, options) {
@@ -150,4 +155,22 @@ export class ImportExportCollection {
             kind,
         ];
     }
+    getImportMap(type) {
+        switch (type) {
+            case 'import':
+                return this._imports;
+            case 'type-import':
+                return this._typeImports;
+            case 'js-doc':
+                return this._jsDocImports;
+        }
+    }
+    getExportMap(type) {
+        switch (type) {
+            case 'export':
+                return this._exports;
+            case 'type-export':
+                return this._typeExports;
+        }
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goast/typescript",
-  "version": "0.3.6",
+  "version": "0.3.7-beta1",
   "repository": "https://github.com/MaSch0212/goast.git",
   "description": "Provides gOAst generators for generating TypeScript code from OpenAPI specifications.",
   "keywords": [
@@ -30,7 +30,6 @@
     "@goast/core": "0.3.5",
     "tslib": "2.6.3"
   },
-  "packageManager": "pnpm@9.5.0",
   "module": "./esm/index.js",
   "main": "./cjs/index.js",
   "types": "./types/index.d.ts",
@@ -42,4 +41,4 @@
     },
     "./package.json": "./package.json"
   }
-}
+}

package/types/lib/ast/nodes/export.d.ts

@@ -1,14 +1,17 @@
-import { AstNodeOptions, Prettify, SourceBuilder } from '@goast/core';
+import { AstNodeOptions, Nullable, Prettify, SourceBuilder } from '@goast/core';
+import { TypeScriptExportType } from '../../common-results';
 import { TsNode } from '../node';
 import { writeTsNodes } from '../utils/write-ts-nodes';
 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 declare class TsExport<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
     name: string;
     filePath: string;
+    kind: TypeScriptExportType;
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }

package/types/lib/ast/nodes/reference.d.ts

@@ -27,23 +27,35 @@ export declare class TsReference<TBuilder extends SourceBuilder, TInjects extend
     protected onWrite(builder: TBuilder): void;
     static registerAddImportHandler<TBuilder extends SourceBuilder>(builderClass: _AddImportHandler<TBuilder>['builderClass'], handler: _AddImportHandler<TBuilder>['handler']): void;
 }
-declare function _createFactory(name: string, moduleNameOrfilePath?: Nullable<string>): (<TBuilder extends SourceBuilder>(options?: FactoryOptions<TBuilder>) => TsReference<TBuilder, never>) & {
+declare function _createFactory(name: string, moduleNameOrfilePath?: Nullable<string>, defaultOptions?: {
+    importType?: Nullable<TypeScriptImportType>;
+}): (<TBuilder extends SourceBuilder>(options?: FactoryOptions<TBuilder>) => TsReference<TBuilder, never>) & {
     refName: string;
     moduleNameOrfilePath: Nullable<string>;
 };
-declare function createFactory(name: string, moduleNameOrfilePath: string): ReturnType<typeof _createFactory> & {
+declare function createFactory(name: string, moduleNameOrfilePath: string, defaultOptions?: {
+    importType?: Nullable<TypeScriptImportType>;
+}): ReturnType<typeof _createFactory> & {
     moduleNameOrfilePath: string;
 };
-declare function createFactory(name: string, moduleNameOrfilePath?: Nullable<string>): ReturnType<typeof _createFactory>;
-declare function _createGenericFactory<TGenericCount extends number | number[]>(name: string, moduleNameOrfilePath?: Nullable<string>): (<TBuilder extends SourceBuilder>(generics: TupleWithCount<TsType<TBuilder>, TGenericCount>, options?: FactoryOptions<TBuilder>) => TsReference<TBuilder, never>) & {
+declare function createFactory(name: string, moduleNameOrfilePath?: Nullable<string>, defaultOptions?: {
+    importType?: Nullable<TypeScriptImportType>;
+}): ReturnType<typeof _createFactory>;
+declare function _createGenericFactory<TGenericCount extends number | number[]>(name: string, moduleNameOrfilePath?: Nullable<string>, defaultOptions?: {
+    importType?: Nullable<TypeScriptImportType>;
+}): (<TBuilder extends SourceBuilder>(generics: TupleWithCount<TsType<TBuilder>, TGenericCount>, options?: FactoryOptions<TBuilder>) => TsReference<TBuilder, never>) & {
     refName: string;
     moduleNameOrfilePath: Nullable<string>;
     infer: <TBuilder extends SourceBuilder>() => TsReference<TBuilder, never>;
 };
-declare function createGenericFactory<TGenericCount extends number | number[]>(name: string, moduleNameOrfilePath: string): ReturnType<typeof _createGenericFactory<TGenericCount>> & {
+declare function createGenericFactory<TGenericCount extends number | number[]>(name: string, moduleNameOrfilePath: string, defaultOptions?: {
+    importType?: Nullable<TypeScriptImportType>;
+}): ReturnType<typeof _createGenericFactory<TGenericCount>> & {
     moduleNameOrfilePath: string;
 };
-declare function createGenericFactory<TGenericCount extends number | number[]>(name: string, moduleNameOrfilePath?: Nullable<string>): ReturnType<typeof _createGenericFactory<TGenericCount>>;
+declare function createGenericFactory<TGenericCount extends number | number[]>(name: string, moduleNameOrfilePath?: Nullable<string>, defaultOptions?: {
+    importType?: Nullable<TypeScriptImportType>;
+}): ReturnType<typeof _createGenericFactory<TGenericCount>>;
 export declare const tsReference: (<TBuilder extends SourceBuilder>(name: Options<TBuilder>["name"], moduleNameOrfilePath?: Options<TBuilder>["moduleNameOrfilePath"], options?: Prettify<Omit<Options<TBuilder>, "name" | "moduleNameOrfilePath">>) => TsReference<TBuilder, never>) & {
     factory: typeof createFactory;
     genericFactory: typeof createGenericFactory;

package/types/lib/common-results.d.ts

@@ -1,15 +1,20 @@
+import { TypeScriptExportOptions } from './import-collection';
 export type TypeScriptComponentOutput = {
     component: string;
     filePath?: string;
     imports: TypeScriptImport[];
-    additionalExports?: string[];
+    additionalExports?: string[] | ({
+        name: string;
+    } & TypeScriptExportOptions)[];
+    kind: 'unknown' | 'interface' | 'type' | 'enum' | 'class' | 'function' | 'variable';
 };
 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;

package/types/lib/file-builder.d.ts

@@ -2,7 +2,7 @@ import { AppendParam, AppendValue, Nullable, SourceBuilder } from '@goast/core';
 import { TsNode } from './ast/node';
 import { TypeScriptGeneratorConfig } from './config';
 import { TypeScriptModelGeneratorOutput } from './generators';
-import { ImportExportCollection, TypeScriptImportOptions } from './import-collection';
+import { ImportExportCollection, TypeScriptExportOptions, TypeScriptImportOptions } from './import-collection';
 export type TypeScriptAppends<TAdditionalAppends> = TsNode<TypeScriptFileBuilder> | TAdditionalAppends;
 export type TypeScriptAppendParam<TBuilder extends TypeScriptFileBuilder, TAdditionalAppends> = AppendParam<TBuilder, TypeScriptAppends<TAdditionalAppends>>;
 export declare function isTypeScriptAppendValue<TBuilder extends TypeScriptFileBuilder = TypeScriptFileBuilder>(value: unknown): value is AppendValue<TBuilder>;
@@ -12,7 +12,7 @@ export declare class TypeScriptFileBuilder<TAdditionalAppends = never> extends S
     get options(): TypeScriptGeneratorConfig;
     constructor(filePath?: string, options?: TypeScriptGeneratorConfig);
     addImport(name: string, moduleNameOrfilePath: string, options?: TypeScriptImportOptions): this;
-    addExport(name: string, filePath: string): this;
+    addExport(name: string, filePath: string, options?: TypeScriptExportOptions): this;
     clear(): void;
     toString(addPadding?: boolean): string;
     protected appendSingle(value: TypeScriptAppendParam<this, TAdditionalAppends>): void;

package/types/lib/import-collection.d.ts

@@ -1,5 +1,5 @@
 import { SourceBuilderOptions, StringBuilder } from '@goast/core';
-import { TypeScriptImport, TypeScriptImportKind, TypeScriptImportType } from './common-results';
+import { TypeScriptExportType, TypeScriptImport, TypeScriptImportKind, TypeScriptImportType } from './common-results';
 import { ImportModuleTransformer } from './utils';
 export type ImportExportCollectionOptions = {
     filePath?: string;
@@ -10,11 +10,15 @@ export declare const defaultImportExportCollectionOptions: ImportExportCollectio
 export type TypeScriptImportOptions = {
     type?: TypeScriptImportType;
 };
+export type TypeScriptExportOptions = {
+    type?: TypeScriptExportType;
+};
 export declare class ImportExportCollection {
     private readonly _imports;
     private readonly _typeImports;
     private readonly _jsDocImports;
     private readonly _exports;
+    private readonly _typeExports;
     private readonly _options;
     constructor(options?: Partial<ImportExportCollectionOptions>);
     get hasImports(): boolean;
@@ -22,15 +26,16 @@ export declare class ImportExportCollection {
     get imports(): TypeScriptImport[];
     private toImport;
     addImport(importName: string, fromModule: string, options?: TypeScriptImportOptions): void;
-    getImportMap(type: TypeScriptImportType): Map<string, Set<string>>;
-    addExport(exportName: string, fromModule: string): void;
+    addExport(exportName: string, fromModule: string, options?: TypeScriptExportOptions): void;
     clear(): void;
     toString(options: Partial<SourceBuilderOptions>): string;
     writeTo(builder: StringBuilder): void;
-    protected writeImportsExports(builder: StringBuilder, keyword: 'import' | 'export' | 'import type' | ' * @import', data: (readonly [string, TypeScriptImportKind, string[]])[], options: {
+    protected writeImportsExports(builder: StringBuilder, keyword: 'import' | 'export' | 'import type' | 'export type' | ' * @import', data: (readonly [string, TypeScriptImportKind, string[]])[], options: {
         useSingleQuotes: boolean;
     }): void;
     protected sortAndResolve(data: Map<string, Set<string>>, filePath: string | undefined, importModuleTransformer: ImportModuleTransformer): (readonly [string, TypeScriptImportKind, string[]])[];
     protected getImportKind(fromModule: string): TypeScriptImportKind;
     protected resolveModulePath(fromModule: string, filePath: string | undefined, importModuleTransformer: ImportModuleTransformer): [string, TypeScriptImportKind];
+    protected getImportMap(type: TypeScriptImportType): Map<string, Set<string>>;
+    protected getExportMap(type: TypeScriptExportType): Map<string, Set<string>>;
 }