@goast/typescript 0.0.5 → 0.2.0

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

@@ -1,6 +1,6 @@
-import { dirname, resolve } from 'path';
-import { ensureDirSync, writeFileSync } from 'fs-extra';
-import { getEndpointUrlPreview, notNullish, toCasing } from '@goast/core';
+import { resolve } from 'path';
+import { toCasing, appendValueGroup, builderTemplate as s, } from '@goast/core';
+import { ts } from '../../../ast';
 import { TypeScriptFileBuilder } from '../../../file-builder';
 import { TypeScriptFileGenerator } from '../../file-generator';
 export class DefaultTypeScriptFetchClientGenerator extends TypeScriptFileGenerator {
@@ -10,205 +10,145 @@ export class DefaultTypeScriptFetchClientGenerator extends TypeScriptFileGenerat
         if (this.shouldGenerateInterface(ctx)) {
             const filePath = this.getInterfaceFilePath(ctx);
             const name = this.getInterfaceName(ctx);
-            console.log(`Generating interface ${name} in ${filePath}...`);
-            ensureDirSync(dirname(filePath));
-            builder = new TypeScriptFileBuilder(filePath, ctx.config);
-            this.generateInterface(ctx, builder);
-            writeFileSync(filePath, builder.toString());
+            TypeScriptFileBuilder.generate({
+                logName: `interface ${name}`,
+                filePath,
+                options: ctx.config,
+                generator: (b) => b.append(this.getInterfaceFileContent(ctx)),
+            });
             result.interface = { filePath, component: name, imports: [{ kind: 'file', name, modulePath: filePath }] };
         }
         if (this.shouldGenerateClass(ctx)) {
             const filePath = this.getClassFilePath(ctx);
             const name = this.getClassName(ctx);
-            console.log(`Generating class ${name} in ${filePath}...`);
-            ensureDirSync(dirname(filePath));
-            if (!builder || builder.filePath !== filePath) {
-                builder = new TypeScriptFileBuilder(filePath, ctx.config);
-            }
-            this.generateDefaultOptions(ctx, builder);
-            this.generateClass(ctx, builder);
-            writeFileSync(filePath, builder.toString());
+            TypeScriptFileBuilder.generate({
+                logName: `class ${name}`,
+                filePath,
+                options: ctx.config,
+                generator: (b) => b.append(this.getClassFileContent(ctx)),
+            });
             result.class = { filePath, component: name, imports: [{ kind: 'file', name, modulePath: filePath }] };
         }
         return result;
     }
-    generateInterface(ctx, builder) {
-        builder
-            .ensurePreviousLineEmpty()
-            .append((builder) => this.generateInterfaceDocumentation(ctx, builder))
-            .ensureCurrentLineEmpty()
-            .append((builder) => this.generateInterfaceSignature(ctx, builder))
-            .append(' ')
-            .parenthesize('{}', (builder) => this.generateInterfaceContent(ctx, builder))
-            .appendLine();
-    }
-    generateInterfaceDocumentation(ctx, builder) {
-        if (ctx.service.description) {
-            builder.appendLine('/**').appendLineWithLinePrefix(' *', ctx.service.description).appendLine(' */');
-        }
+    // #region Interface
+    getInterfaceFileContent(ctx) {
+        return appendValueGroup([this.getInterface(ctx)], '\n');
     }
-    generateInterfaceSignature(ctx, builder) {
-        builder.append('export interface ').append(this.getInterfaceName(ctx));
+    getInterface(ctx) {
+        return ts.interface(this.getInterfaceName(ctx), {
+            doc: ts.doc({ description: ctx.service.description }),
+            export: true,
+            members: ctx.service.endpoints.map((endpoint) => this.getInterfaceEndpointMethod(ctx, endpoint)),
+        });
     }
-    generateInterfaceContent(ctx, builder) {
-        builder.forEach(ctx.service.endpoints, (builder, endpoint) => this.generateInterfaceServiceMethod(ctx, builder, endpoint));
+    getInterfaceEndpointMethod(ctx, endpoint) {
+        var _a, _b;
+        const params = endpoint.parameters.filter((x) => x.target === 'path' || x.target === 'query');
+        const bodySchema = (_b = (_a = endpoint.requestBody) === null || _a === void 0 ? void 0 : _a.content[0]) === null || _b === void 0 ? void 0 : _b.schema;
+        const responseSchema = this.getResponseSchema(ctx, endpoint);
+        return ts.method(toCasing(endpoint.name, ctx.config.methodCasing), {
+            doc: ts.doc({ description: endpoint.description }),
+            parameters: [
+                params.length > 0
+                    ? ts.parameter('params', {
+                        description: 'Parameters for the endpoint.',
+                        type: ts.objectType({
+                            members: params.map((x) => ts.property(toCasing(x.name, ctx.config.propertyNameCasing), {
+                                type: this.getSchemaType(ctx, x.schema),
+                                optional: !x.required,
+                            })),
+                        }),
+                    })
+                    : null,
+                bodySchema &&
+                    ts.parameter('body', {
+                        description: 'Body for the endpoint.',
+                        type: this.getSchemaType(ctx, bodySchema),
+                    }),
+            ],
+            returnType: ts.refs.promise([ctx.refs.typedResponse([this.getSchemaType(ctx, responseSchema, ts.refs.void_())])]),
+        });
     }
-    generateInterfaceServiceMethod(ctx, builder, endpoint) {
-        builder
-            .ensurePreviousLineEmpty()
-            .append((builder) => this.generateServiceMethodDocumentation(ctx, builder, endpoint))
-            .ensureCurrentLineEmpty()
-            .append((builder) => this.generateServiceMethodSignature(ctx, builder, endpoint))
-            .appendLine(';');
+    // #endregion
+    // #region Class
+    getClassFileContent(ctx) {
+        return appendValueGroup([this.getDefaultOptionsConstant(ctx), this.getClass(ctx)], '\n');
     }
-    generateDefaultOptions(ctx, builder) {
+    getDefaultOptionsConstant(ctx) {
         const baseUrl = ctx.service.endpoints
             .map((x) => { var _a, _b, _c; return (_c = (_b = (_a = x.$src) === null || _a === void 0 ? void 0 : _a.document.servers) === null || _b === void 0 ? void 0 : _b.find((x) => x.url)) === null || _c === void 0 ? void 0 : _c.url; })
             .find((x) => !!x);
-        builder
-            .ensurePreviousLineEmpty()
-            .addImport('FetchClientOptions', this.getUtilPath(ctx, 'types.ts'))
-            .append('export const ', this.getDefaultOptionsConstantName(ctx), ': FetchClientOptions = ')
-            .parenthesize('{}', (builder) => builder.appendLineIf(notNullish(baseUrl), 'baseUrl: ', this.toStringLiteral(ctx, baseUrl !== null && baseUrl !== void 0 ? baseUrl : ''), ','), { indent: true, multiline: true });
-    }
-    generateClass(ctx, builder) {
-        builder
-            .ensurePreviousLineEmpty()
-            .append((builder) => this.generateClassDocumentation(ctx, builder))
-            .ensureCurrentLineEmpty()
-            .append((builder) => this.generateClassSignature(ctx, builder))
-            .append(' ')
-            .parenthesize('{}', (builder) => this.generateClassContent(ctx, builder))
-            .appendLine();
-    }
-    generateClassDocumentation(ctx, builder) {
-        if (ctx.service.description) {
-            builder.appendLine('/**').appendLineWithLinePrefix(' *', ctx.service.description).appendLine(' */');
-        }
-    }
-    generateClassSignature(ctx, builder) {
-        builder
-            .append('export class ')
-            .append(this.getClassName(ctx))
-            .appendIf(this.shouldGenerateInterface(ctx), (builder) => builder
-            .addImport(this.getInterfaceName(ctx), this.getInterfaceFilePath(ctx))
-            .append(' implements ', this.getInterfaceName(ctx)));
-    }
-    generateClassContent(ctx, builder) {
-        builder
-            .append((builder) => this.generateClassFields(ctx, builder))
-            .append((builder) => this.generateClassConstructor(ctx, builder))
-            .forEach(ctx.service.endpoints, (builder, endpoint) => this.generateClassServiceMethod(ctx, builder, endpoint));
-    }
-    generateClassFields(ctx, builder) {
-        builder.ensureCurrentLineEmpty().appendLine('public options: FetchClientOptions;');
-    }
-    generateClassConstructor(ctx, builder) {
-        builder
-            .ensurePreviousLineEmpty()
-            .append('constructor(options?: Partial<FetchClientOptions>)')
-            .parenthesize('{}', (builder) => this.generateClassConstructorContent(ctx, builder), {
-            indent: true,
-            multiline: true,
+        return ts.variable(this.getDefaultOptionsConstantName(ctx), {
+            export: true,
+            readonly: true,
+            type: ctx.refs.fetchClientOptions(),
+            value: ts.object({
+                members: [baseUrl && ts.property('baseUrl', { value: ts.string(baseUrl) })],
+            }),
         });
     }
-    generateClassConstructorContent(ctx, builder) {
-        builder.appendLine('this.options = { ...', this.getDefaultOptionsConstantName(ctx), ', ...options };');
-    }
-    generateClassServiceMethod(ctx, builder, endpoint) {
-        builder
-            .ensurePreviousLineEmpty()
-            .append((builder) => this.generateServiceMethodDocumentation(ctx, builder, endpoint))
-            .ensureCurrentLineEmpty()
-            .append((builder) => this.generateServiceMethodSignature(ctx, builder, endpoint))
-            .append(' ')
-            .parenthesize('{}', (builder) => this.generateServiceMethodContent(ctx, builder, endpoint), {
-            indent: true,
-            multiline: true,
-        })
-            .appendLine();
-    }
-    generateServiceMethodDocumentation(ctx, builder, endpoint) {
-        var _a;
-        const hasParams = endpoint.parameters.some((p) => p.target === 'path' || p.target === 'query') ||
-            (!!endpoint.requestBody && ((_a = endpoint.requestBody) === null || _a === void 0 ? void 0 : _a.content.length) > 0);
-        builder.appendComment('/***/', (builder) => {
-            var _a;
-            return builder
-                .appendLine((_a = endpoint.description) !== null && _a !== void 0 ? _a : '[No description was provided by the API]')
-                .appendLine(`@see ${getEndpointUrlPreview(endpoint)}`)
-                .appendLineIf(hasParams, `@param params Parameters for the endpoint.`)
-                .append(`@returns The response of the call to the endpoint.`);
+    getClass(ctx) {
+        return ts.class(this.getClassName(ctx), {
+            doc: ts.doc({ description: ctx.service.description }),
+            export: true,
+            implements: this.shouldGenerateInterface(ctx)
+                ? [ts.reference(this.getInterfaceName(ctx), this.getInterfaceFilePath(ctx))]
+                : undefined,
+            members: [
+                ts.property('options', {
+                    doc: ts.doc({ description: 'Options for the fetch client.' }),
+                    accessModifier: 'public',
+                    type: ctx.refs.fetchClientOptions(),
+                }),
+                ts.constructor({
+                    parameters: [
+                        ts.constructorParameter('options', {
+                            type: ts.refs.partial([ctx.refs.fetchClientOptions()]),
+                            optional: true,
+                        }),
+                    ],
+                    body: appendValueGroup([s `this.options = { ...${this.getDefaultOptionsConstantName(ctx)}, ...options };`], '\n'),
+                }),
+                ...ctx.service.endpoints.map((endpoint) => this.getServiceMethod(ctx, endpoint)),
+            ],
         });
     }
-    generateServiceMethodSignature(ctx, builder, endpoint) {
-        builder
-            .append(toCasing(endpoint.name, ctx.config.methodCasing))
-            .parenthesize('()', (builder) => this.generateServiceMethodParameters(ctx, builder, endpoint))
-            .append(': ')
-            .append((builder) => this.generateServiceMethodReturnValue(ctx, builder, endpoint));
-    }
-    generateServiceMethodParameters(ctx, builder, endpoint) {
-        var _a, _b, _c;
-        const params = endpoint.parameters.filter((x) => x.target === 'path' || x.target === 'query');
-        const bodySchemaId = (_c = (_b = (_a = endpoint.requestBody) === null || _a === void 0 ? void 0 : _a.content[0]) === null || _b === void 0 ? void 0 : _b.schema) === null || _c === void 0 ? void 0 : _c.id;
-        builder
-            .appendLineIf(params.length > 0 && !!bodySchemaId)
-            .if(params.length > 0, (builder) => builder
-            .append('params: ')
-            .parenthesize('{}', (builder) => builder.forEach(params, (builder, parameter) => {
-            var _a;
-            return builder.appendLine(this.toPropertyName(ctx, parameter.name), parameter.required ? ': ' : '?: ', this.getTypeName(ctx, builder, (_a = parameter.schema) === null || _a === void 0 ? void 0 : _a.id), ';');
-        }), { indent: true, multiline: true }))
-            .appendLineIf(params.length > 0 && !!bodySchemaId, ',')
-            .appendIf(!!bodySchemaId, (builder) => builder.append(`body: ${this.getTypeName(ctx, builder, bodySchemaId)}`))
-            .appendLineIf(params.length > 0 && !!bodySchemaId);
-    }
-    generateServiceMethodReturnValue(ctx, builder, endpoint) {
-        builder
-            .append('Promise')
-            .parenthesize('<>', (builder) => this.generateTypedResponse(ctx, builder, this.getResponseSchema(ctx, endpoint)));
-    }
-    generateTypedResponse(ctx, builder, schema) {
-        builder
-            .addImport('TypedResponse', this.getUtilPath(ctx, 'types.ts'))
-            .append('TypedResponse')
-            .parenthesize('<>', (builder) => builder.append(this.getTypeName(ctx, builder, schema === null || schema === void 0 ? void 0 : schema.id, 'void')));
-    }
-    generateServiceMethodContent(ctx, builder, endpoint) {
-        builder
-            .addImport('UrlBuilder', this.getUtilPath(ctx, 'url-builder.ts'))
-            .appendLine('const url = new UrlBuilder(this.options.baseUrl)')
-            .indent((builder) => builder
-            .appendLine(`.withPath(${this.toStringLiteral(ctx, endpoint.path)})`)
-            .forEach(endpoint.parameters.filter((x) => x.target === 'path' || x.target === 'query'), (builder, parameter) => builder
-            .appendIf(parameter.target === 'path', `.withPathParam`)
-            .appendIf(parameter.target === 'query', `.withQueryParam`)
-            .parenthesize('()', `${this.toStringLiteral(ctx, parameter.name)}, params.${this.toPropertyName(ctx, parameter.name)}`)
-            .appendLine())
-            .appendLine('.build();'))
-            .append('const response = (this.options.fetch ?? fetch)')
-            .parenthesize('()', (builder) => builder.append('url, ').parenthesize('{}', (builder) => {
-            var _a, _b;
-            return builder
-                .appendLine('method: ', this.toStringLiteral(ctx, toCasing(endpoint.method, 'all-upper')), ',')
-                .appendLine('headers: this.options.headers,')
-                .appendLineIf(!!((_b = (_a = endpoint.requestBody) === null || _a === void 0 ? void 0 : _a.content[0]) === null || _b === void 0 ? void 0 : _b.schema), 'body: JSON.stringify(body),');
-        }, { indent: true, multiline: true }), { indent: false })
-            .appendLine(';')
-            .appendLine("Object.defineProperty(response, 'isVoidResponse', { value: ", this.getResponseSchema(ctx, endpoint) ? 'false' : 'true', ' });')
-            .appendLine('return response as unknown as ', (builder) => this.generateServiceMethodReturnValue(ctx, builder, endpoint), ';');
-    }
-    getTypeName(ctx, builder, schemaId, fallback) {
-        if (!schemaId) {
-            return fallback ? fallback : this.getAnyType(ctx);
-        }
-        const modelInfo = ctx.input.models[schemaId];
-        if (!modelInfo) {
-            return this.getAnyType(ctx);
-        }
-        modelInfo.imports.forEach((x) => builder.addImport(x.name, x.modulePath));
-        return modelInfo.component;
+    getServiceMethod(ctx, endpoint) {
+        var _a, _b;
+        const method = this.getInterfaceEndpointMethod(ctx, endpoint);
+        method.accessModifier = 'public';
+        method.body = appendValueGroup([
+            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':
+                        b.append(s `\n.withPathParam(${ts.string(p.name)}, params.${toCasing(p.name, ctx.config.paramNameCasing)})`);
+                        break;
+                    case 'query':
+                        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: [
+                    ts.property('method', { value: ts.string(toCasing(endpoint.method, 'all-upper')) }),
+                    ts.property('headers', { value: 'this.options.headers' }),
+                    ((_b = (_a = endpoint.requestBody) === null || _a === void 0 ? void 0 : _a.content[0]) === null || _b === void 0 ? void 0 : _b.schema) ? ts.property('body', { value: 'JSON.stringify(body)' }) : null,
+                ],
+            })});`,
+            s `Object.defineProperty(response, 'isVoidResponse', { value: ${this.getResponseSchema(ctx, endpoint) ? 'false' : 'true'} });`,
+            s `return response as unknown as ${method.returnType};`,
+        ], '\n');
+        return method;
+    }
+    // #endregion
+    getSchemaType(ctx, schema, fallback) {
+        const output = schema && ctx.input.models[schema.id];
+        if (!output)
+            return fallback !== null && fallback !== void 0 ? fallback : this.getAnyType(ctx);
+        return (b) => b.appendModelUsage(output);
     }
     shouldGenerateInterface(ctx) {
         return ctx.config.clientFileKind === 'interface' || ctx.config.clientFileKind === 'class-and-interface';
@@ -223,7 +163,7 @@ export class DefaultTypeScriptFetchClientGenerator extends TypeScriptFileGenerat
         return toCasing(ctx.service.name, ctx.config.classNameCasing);
     }
     getDefaultOptionsConstantName(ctx) {
-        return toCasing(this.getClassName(ctx) + '-default-options', ctx.config.constantCasing);
+        return toCasing(this.getClassName(ctx) + '-default-options', ctx.config.constantNameCasing);
     }
     getInterfaceFilePath(ctx) {
         var _a, _b;

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

@@ -3,6 +3,7 @@ import { ensureDirSync, writeFileSync, copyFileSync, readdirSync } from 'fs-extr
 import { OpenApiServicesGenerationProviderBase, Factory } from '@goast/core';
 import { DefaultTypeScriptFetchClientGenerator } from './fetch-client-generator';
 import { defaultTypeScriptFetchClientsGeneratorConfig, } from './models';
+import { getReferenceFactories } from './refs';
 import { TypeScriptFileBuilder } from '../../../file-builder';
 import { ImportExportCollection } from '../../../import-collection';
 export class TypeScriptClientsGenerator extends OpenApiServicesGenerationProviderBase {
@@ -19,7 +20,10 @@ export class TypeScriptClientsGenerator extends OpenApiServicesGenerationProvide
         };
     }
     buildContext(context, config) {
-        return this.getProviderContext(context, config, defaultTypeScriptFetchClientsGeneratorConfig);
+        const providerContext = this.getProviderContext(context, config, defaultTypeScriptFetchClientsGeneratorConfig);
+        return Object.assign(providerContext, {
+            refs: getReferenceFactories(providerContext.config),
+        });
     }
     onGenerate(ctx) {
         this.copyUtilsFiles(ctx);

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

@@ -0,0 +1,13 @@
+import { resolve } from 'path';
+import { ts } from '../../../ast';
+// See packages/typescript/assets/client/fetch for reference
+export function getReferenceFactories(options) {
+    const utilsDirPath = resolve(options.outputDir, options.utilsDirPath);
+    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),
+        urlBuilder: ts.reference.factory('UrlBuilder', fetchClientUtilsPath),
+    };
+}

package/esm/lib/import-collection.js

@@ -1,10 +1,16 @@
 import { extname } from 'path';
 import { StringBuilder } from '@goast/core';
+import { defaultTypeScriptGeneratorConfig } from './config';
 import { getModulePathRelativeToFile } from './utils';
+export const defaultImportExportCollectionOptions = {
+    importModuleTransformer: defaultTypeScriptGeneratorConfig.importModuleTransformer,
+    useSingleQuotes: defaultTypeScriptGeneratorConfig.useSingleQuotes,
+};
 export class ImportExportCollection {
-    constructor() {
+    constructor(options) {
         this._imports = new Map();
         this._exports = new Map();
+        this._options = Object.assign(Object.assign({}, defaultImportExportCollectionOptions), options);
     }
     get hasImports() {
         return this._imports.size > 0;
@@ -43,34 +49,26 @@ export class ImportExportCollection {
         this._imports.clear();
         this._exports.clear();
     }
-    toString(options, filePath, importModuleTransformer) {
+    toString(options) {
         const builder = new StringBuilder(options);
-        this.writeTo(builder, filePath, importModuleTransformer);
+        this.writeTo(builder);
         return builder.toString();
     }
-    writeTo(builder, filePath, importModuleTransformer) {
-        if (!filePath) {
-            filePath = builder.filePath;
-        }
-        if (!importModuleTransformer) {
-            importModuleTransformer = builder.options.importModuleTransformer;
-            if (!importModuleTransformer) {
-                throw new Error('importModuleTransformer is required');
-            }
-        }
+    writeTo(builder) {
+        const { filePath, importModuleTransformer, useSingleQuotes } = this._options;
         if (this._imports.size > 0) {
             const sortedImports = this.sortAndResolve(this._imports, filePath, importModuleTransformer);
-            this.writeImportsExports(builder, 'import', sortedImports);
+            this.writeImportsExports(builder, 'import', sortedImports, { useSingleQuotes });
         }
         if (this._imports.size > 0 && this._exports.size > 0) {
             builder.appendLine();
         }
         if (this._exports.size > 0) {
             const sortedExports = this.sortAndResolve(this._exports, filePath, importModuleTransformer);
-            this.writeImportsExports(builder, 'export', sortedExports);
+            this.writeImportsExports(builder, 'export', sortedExports, { useSingleQuotes });
         }
     }
-    writeImportsExports(builder, keyword, data) {
+    writeImportsExports(builder, keyword, data, options) {
         const moduleData = [];
         const fileData = [];
         for (const x of data) {
@@ -81,14 +79,15 @@ export class ImportExportCollection {
                 fileData.push(x);
             }
         }
+        const quote = options.useSingleQuotes ? "'" : '"';
         for (const [fromModule, _, names] of moduleData) {
-            builder.appendLine(`${keyword} { ${names.join(', ')} } from '${fromModule}';`);
+            builder.appendLine(`${keyword} { ${names.join(', ')} } from ${quote}${fromModule}${quote};`);
         }
         if (moduleData.length > 0 && fileData.length > 0) {
             builder.appendLine();
         }
         for (const [fromModule, _, names] of fileData) {
-            builder.appendLine(`${keyword} { ${names.join(', ')} } from '${fromModule}';`);
+            builder.appendLine(`${keyword} { ${names.join(', ')} } from ${quote}${fromModule}${quote};`);
         }
     }
     sortAndResolve(data, filePath, importModuleTransformer) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goast/typescript",
-  "version": "0.0.5",
+  "version": "0.2.0",
   "repository": "https://github.com/MaSch0212/goast.git",
   "author": {
     "name": "Marc Schmidt (MaSch0212)",
@@ -9,11 +9,11 @@
   "license": "MIT",
   "type": "module",
   "dependencies": {
-    "fs-extra": "^11.1.1",
-    "node-fetch": "^2.6.11",
-    "yaml": "^2.3.1",
-    "@goast/core": "0.1.1",
-    "tslib": "^2.3.0"
+    "fs-extra": "^11.2.0",
+    "node-fetch": "^2.7.0",
+    "yaml": "^2.4.1",
+    "@goast/core": "0.2.0",
+    "tslib": "2.6.2"
   },
   "module": "./esm/index.js",
   "main": "./cjs/index.js",

package/types/lib/ast/_index.d.ts

@@ -0,0 +1,38 @@
+export { TsAccessModifier as AccessModifier } from './common';
+export { TsNode as Node } from './node';
+export { TsArgument as Argument, tsArgument as argument } from './nodes/argument';
+export { TsArrayType as ArrayType, tsArrayType as arrayType } from './nodes/array-type';
+export { TsArrowFunction as ArrowFunction, tsArrowFunction as arrowFunction } from './nodes/arrow-function';
+export { TsCall as Call, tsCall as call } from './nodes/call';
+export { TsClass as Class, tsClass as class } from './nodes/class';
+export { TsConstructor as Constructor, tsConstructor as constructor } from './nodes/constructor';
+export { TsConstructorParameter as ConstructorParameter, tsConstructorParameter as constructorParameter, } from './nodes/constructor-parameter';
+export { TsDecorator as Decorator, tsDecorator as decorator } from './nodes/decorator';
+export { TsDoc as Doc, tsDoc as doc } from './nodes/doc';
+export { TsDocTag as DocTag, tsDocTag as docTag } from './nodes/doc-tag';
+export { TsEnum as Enum, tsEnum as enum } from './nodes/enum';
+export { TsEnumValue as EnumValue, tsEnumValue as enumValue } from './nodes/enum-value';
+export { TsExport as Export, tsExport as export } from './nodes/export';
+export { TsFunction as Function, tsFunction as function } from './nodes/function';
+export { TsFunctionType as FunctionType, tsFunctionType as functionType } from './nodes/function-type';
+export { TsGenericParameter as GenericParameter, tsGenericParameter as genericParameter, } from './nodes/generic-parameter';
+export { TsIndexer as Indexer, tsIndexer as indexer } from './nodes/indexer';
+export { TsInterface as Interface, tsInterface as interface } from './nodes/interface';
+export { TsIntersectionType as IntersectionType, tsIntersectionType as intersectionType, } from './nodes/intersection-type';
+export { TsLookupType as LookupType, tsLookupType as lookupType } from './nodes/lookup-type';
+export { TsMethod as Method, tsMethod as method } from './nodes/method';
+export { TsObject as Object, tsObject as object } from './nodes/object';
+export { TsObjectType as ObjectType, tsObjectType as objectType } from './nodes/object-type';
+export { TsParameter as Parameter, tsParameter as parameter } from './nodes/parameter';
+export { TsProperty as Property, tsProperty as property } from './nodes/property';
+export { TsReference as Reference, tsReference as reference } from './nodes/reference';
+export { TsString as String, tsString as string } from './nodes/string';
+export { TsTuple as Tuple, tsTuple as tuple } from './nodes/tuple';
+export { TsTypeAlias as TypeAlias, tsTypeAlias as typeAlias } from './nodes/type-alias';
+export { TsType as Type, TsValue as Value } from './nodes/types';
+export { TsUnionType as UnionType, tsUnionType as unionType } from './nodes/union-type';
+export { TsVariable as Variable, tsVariable as variable } from './nodes/variable';
+export { TsTypeof as Typeof, tsTypeof as typeof } from './nodes/typeof';
+export * as refs from './references';
+export { getTypeScriptBuilderOptions as getBuilderOptions } from './utils/get-type-script-builder-options';
+export { toTsNode as toNode } from './utils/to-ts-node';

package/types/lib/ast/common.d.ts

@@ -0,0 +1 @@
+export type TsAccessModifier = 'public' | 'protected' | 'private';

package/types/lib/ast/index.d.ts

@@ -0,0 +1 @@
+export * as ts from './_index';

package/types/lib/ast/node.d.ts

@@ -0,0 +1,4 @@
+import { AstNode, AstNodeOptions, SourceBuilder } from '@goast/core';
+export declare abstract class TsNode<TBuilder extends SourceBuilder, TInjects extends string = never> extends AstNode<TBuilder, TInjects> {
+    constructor(options: AstNodeOptions<typeof AstNode<TBuilder, TInjects>>);
+}

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

@@ -0,0 +1,17 @@
+import { AstNodeOptions, Prettify, SourceBuilder } from '@goast/core';
+import { TsValue } from './types';
+import { TsNode } from '../node';
+import { writeTsParameters } from '../utils/write-ts-parameters';
+type Injects = never;
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
+    value: TsValue<TBuilder>;
+}>;
+export declare class TsArgument<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    value: TsValue<TBuilder>;
+    constructor(options: Options<TBuilder, TInjects>);
+    protected onWrite(builder: TBuilder): void;
+}
+export declare const tsArgument: (<TBuilder extends SourceBuilder<never>>(value: Options<TBuilder>['value'], options?: Prettify<Omit<Options<TBuilder>, 'value'>>) => TsArgument<TBuilder, never>) & {
+    write: typeof writeTsParameters;
+};
+export {};

package/types/lib/ast/nodes/array-type.d.ts

@@ -0,0 +1,19 @@
+import { AstNodeOptions, Nullable, Prettify, SourceBuilder } from '@goast/core';
+import { TsType } from './types';
+import { TsNode } from '../node';
+import { writeTsNodes } from '../utils/write-ts-nodes';
+type Injects = 'type';
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
+    readonly?: Nullable<boolean>;
+    type: TsType<TBuilder>;
+}>;
+export declare class TsArrayType<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    readonly: boolean;
+    type: TsType<TBuilder>;
+    constructor(options: Options<TBuilder, TInjects>);
+    protected onWrite(builder: TBuilder): void;
+}
+export declare const tsArrayType: (<TBuilder extends SourceBuilder<never>>(type: Options<TBuilder>['type'], options?: Prettify<Omit<Options<TBuilder>, 'type'>>) => TsArrayType<TBuilder, never>) & {
+    write: typeof writeTsNodes;
+};
+export {};

package/types/lib/ast/nodes/arrow-function.d.ts

@@ -0,0 +1,29 @@
+import { AppendValue, AstNodeOptions, BasicAppendValue, Nullable, SourceBuilder } from '@goast/core';
+import { TsGenericParameter } from './generic-parameter';
+import { TsParameter } from './parameter';
+import { TsType } from './types';
+import { TsNode } from '../node';
+import { writeTsNodes } from '../utils/write-ts-nodes';
+type Injects = 'generics' | 'params' | 'returnType' | 'body';
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
+    async?: Nullable<boolean>;
+    generics?: Nullable<Nullable<TsGenericParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
+    parameters?: Nullable<Nullable<TsParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
+    returnType?: Nullable<TsType<TBuilder>>;
+    singleExpression?: Nullable<boolean>;
+    body?: Nullable<AppendValue<TBuilder>>;
+}>;
+export declare class TsArrowFunction<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    async: boolean;
+    generics: (TsGenericParameter<TBuilder> | BasicAppendValue<TBuilder>)[];
+    parameters: (TsParameter<TBuilder> | BasicAppendValue<TBuilder>)[];
+    returnType: TsType<TBuilder> | null;
+    singleExpression: boolean;
+    body: AppendValue<TBuilder> | null;
+    constructor(options: Options<TBuilder, TInjects>);
+    protected onWrite(builder: TBuilder): void;
+}
+export declare const tsArrowFunction: (<TBuilder extends SourceBuilder<never>>(options?: Options<TBuilder>) => TsArrowFunction<TBuilder, never>) & {
+    write: typeof writeTsNodes;
+};
+export {};

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

@@ -0,0 +1,20 @@
+import { SourceBuilder, AstNodeOptions, Nullable, ArrayItem, Prettify } from '@goast/core';
+import { TsArgument } from './argument';
+import { TsType, TsValue } from './types';
+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>, {
+    path: Nullable<TsType<TBuilder> | TsValue<TBuilder>>[];
+    arguments?: Nullable<Nullable<TsArgument<TBuilder> | TsValue<TBuilder>>[]>;
+}>;
+export declare class TsCall<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    path: (TsType<TBuilder> | TsValue<TBuilder>)[];
+    arguments: (TsArgument<TBuilder> | TsValue<TBuilder>)[] | null;
+    constructor(options: Options<TBuilder, TInjects>);
+    protected onWrite(builder: TBuilder): void;
+}
+export declare const tsCall: (<TBuilder extends SourceBuilder<never>>(path: Options<TBuilder>['path'] | ArrayItem<Options<TBuilder>['path']>, args?: Options<TBuilder>['arguments'], options?: Prettify<Omit<Options<TBuilder>, 'path' | 'arguments'>>) => TsCall<TBuilder, never>) & {
+    write: typeof writeTsNodes;
+};
+export {};