@goast/typescript 0.0.4 → 0.2.0

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

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultTypeScriptFetchClientGenerator = void 0;
 const path_1 = require("path");
-const fs_extra_1 = require("fs-extra");
 const core_1 = require("@goast/core");
+const ast_1 = require("../../../ast");
 const file_builder_1 = require("../../../file-builder");
 const file_generator_1 = require("../../file-generator");
 class DefaultTypeScriptFetchClientGenerator extends file_generator_1.TypeScriptFileGenerator {
@@ -13,204 +13,145 @@ class DefaultTypeScriptFetchClientGenerator extends file_generator_1.TypeScriptF
         if (this.shouldGenerateInterface(ctx)) {
             const filePath = this.getInterfaceFilePath(ctx);
             const name = this.getInterfaceName(ctx);
-            console.log(`Generating interface ${name} in ${filePath}...`);
-            (0, fs_extra_1.ensureDirSync)((0, path_1.dirname)(filePath));
-            builder = new file_builder_1.TypeScriptFileBuilder(filePath, ctx.config);
-            this.generateInterface(ctx, builder);
-            (0, fs_extra_1.writeFileSync)(filePath, builder.toString());
+            file_builder_1.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}...`);
-            (0, fs_extra_1.ensureDirSync)((0, path_1.dirname)(filePath));
-            if (!builder || builder.filePath !== filePath) {
-                builder = new file_builder_1.TypeScriptFileBuilder(filePath, ctx.config);
-            }
-            this.generateDefaultOptions(ctx, builder);
-            this.generateClass(ctx, builder);
-            (0, fs_extra_1.writeFileSync)(filePath, builder.toString());
+            file_builder_1.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 (0, core_1.appendValueGroup)([this.getInterface(ctx)], '\n');
     }
-    generateInterfaceSignature(ctx, builder) {
-        builder.append('export interface ').append(this.getInterfaceName(ctx));
+    getInterface(ctx) {
+        return ast_1.ts.interface(this.getInterfaceName(ctx), {
+            doc: ast_1.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 ast_1.ts.method((0, core_1.toCasing)(endpoint.name, ctx.config.methodCasing), {
+            doc: ast_1.ts.doc({ description: endpoint.description }),
+            parameters: [
+                params.length > 0
+                    ? ast_1.ts.parameter('params', {
+                        description: 'Parameters for the endpoint.',
+                        type: ast_1.ts.objectType({
+                            members: params.map((x) => ast_1.ts.property((0, core_1.toCasing)(x.name, ctx.config.propertyNameCasing), {
+                                type: this.getSchemaType(ctx, x.schema),
+                                optional: !x.required,
+                            })),
+                        }),
+                    })
+                    : null,
+                bodySchema &&
+                    ast_1.ts.parameter('body', {
+                        description: 'Body for the endpoint.',
+                        type: this.getSchemaType(ctx, bodySchema),
+                    }),
+            ],
+            returnType: ast_1.ts.refs.promise([ctx.refs.typedResponse([this.getSchemaType(ctx, responseSchema, ast_1.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 (0, core_1.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((0, core_1.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 ast_1.ts.variable(this.getDefaultOptionsConstantName(ctx), {
+            export: true,
+            readonly: true,
+            type: ctx.refs.fetchClientOptions(),
+            value: ast_1.ts.object({
+                members: [baseUrl && ast_1.ts.property('baseUrl', { value: ast_1.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 ${(0, core_1.getEndpointUrlPreview)(endpoint)}`)
-                .appendLineIf(hasParams, `@param params Parameters for the endpoint.`)
-                .append(`@returns The response of the call to the endpoint.`);
+    getClass(ctx) {
+        return ast_1.ts.class(this.getClassName(ctx), {
+            doc: ast_1.ts.doc({ description: ctx.service.description }),
+            export: true,
+            implements: this.shouldGenerateInterface(ctx)
+                ? [ast_1.ts.reference(this.getInterfaceName(ctx), this.getInterfaceFilePath(ctx))]
+                : undefined,
+            members: [
+                ast_1.ts.property('options', {
+                    doc: ast_1.ts.doc({ description: 'Options for the fetch client.' }),
+                    accessModifier: 'public',
+                    type: ctx.refs.fetchClientOptions(),
+                }),
+                ast_1.ts.constructor({
+                    parameters: [
+                        ast_1.ts.constructorParameter('options', {
+                            type: ast_1.ts.refs.partial([ctx.refs.fetchClientOptions()]),
+                            optional: true,
+                        }),
+                    ],
+                    body: (0, core_1.appendValueGroup)([(0, core_1.builderTemplate) `this.options = { ...${this.getDefaultOptionsConstantName(ctx)}, ...options };`], '\n'),
+                }),
+                ...ctx.service.endpoints.map((endpoint) => this.getServiceMethod(ctx, endpoint)),
+            ],
         });
     }
-    generateServiceMethodSignature(ctx, builder, endpoint) {
-        builder
-            .append((0, core_1.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) {
-        var _a, _b, _c;
-        const successResponse = (_a = endpoint.responses.find((x) => x.statusCode === 200)) !== null && _a !== void 0 ? _a : endpoint.responses.find((x) => x.statusCode && x.statusCode > 200 && x.statusCode < 300);
-        const schema = (_c = (_b = successResponse === null || successResponse === void 0 ? void 0 : successResponse.contentOptions) === null || _b === void 0 ? void 0 : _b.find((x) => x.schema !== undefined)) === null || _c === void 0 ? void 0 : _c.schema;
-        builder.append('Promise').parenthesize('<>', (builder) => this.generateTypedResponse(ctx, builder, schema));
-    }
-    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)));
-    }
-    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('return (this.options.fetch ?? fetch)')
-            .parenthesize('()', (builder) => builder.append('url, ').parenthesize('{}', (builder) => {
-            var _a, _b;
-            return builder
-                .appendLine('method: ', this.toStringLiteral(ctx, (0, core_1.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(' as ', (builder) => this.generateServiceMethodReturnValue(ctx, builder, endpoint), ';');
-    }
-    getTypeName(ctx, builder, schemaId) {
-        if (!schemaId) {
-            return 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 = (0, core_1.appendValueGroup)([
+            (0, core_1.builderTemplate) `const url = new ${ctx.refs.urlBuilder()}(this.options.baseUrl)${core_1.builderTemplate.indent `
+          .withPath(${ast_1.ts.string(endpoint.path)})${(b) => b.forEach(endpoint.parameters, (b, p) => {
+                switch (p.target) {
+                    case 'path':
+                        b.append((0, core_1.builderTemplate) `\n.withPathParam(${ast_1.ts.string(p.name)}, params.${(0, core_1.toCasing)(p.name, ctx.config.paramNameCasing)})`);
+                        break;
+                    case 'query':
+                        b.append((0, core_1.builderTemplate) `\n.withQueryParam(${ast_1.ts.string(p.name)}, params.${(0, core_1.toCasing)(p.name, ctx.config.paramNameCasing)})`);
+                        break;
+                }
+            })}
+          .build();`}`,
+            (0, core_1.builderTemplate) `const response = (this.options.fetch ?? fetch)(url, ${ast_1.ts.object({
+                members: [
+                    ast_1.ts.property('method', { value: ast_1.ts.string((0, core_1.toCasing)(endpoint.method, 'all-upper')) }),
+                    ast_1.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) ? ast_1.ts.property('body', { value: 'JSON.stringify(body)' }) : null,
+                ],
+            })});`,
+            (0, core_1.builderTemplate) `Object.defineProperty(response, 'isVoidResponse', { value: ${this.getResponseSchema(ctx, endpoint) ? 'false' : 'true'} });`,
+            (0, core_1.builderTemplate) `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';
@@ -225,7 +166,7 @@ class DefaultTypeScriptFetchClientGenerator extends file_generator_1.TypeScriptF
         return (0, core_1.toCasing)(ctx.service.name, ctx.config.classNameCasing);
     }
     getDefaultOptionsConstantName(ctx) {
-        return (0, core_1.toCasing)(this.getClassName(ctx) + '-default-options', ctx.config.constantCasing);
+        return (0, core_1.toCasing)(this.getClassName(ctx) + '-default-options', ctx.config.constantNameCasing);
     }
     getInterfaceFilePath(ctx) {
         var _a, _b;
@@ -237,5 +178,10 @@ class DefaultTypeScriptFetchClientGenerator extends file_generator_1.TypeScriptF
     getUtilPath(ctx, fileName) {
         return (0, path_1.resolve)(ctx.config.outputDir, ctx.config.utilsDirPath, fileName);
     }
+    getResponseSchema(ctx, endpoint) {
+        var _a, _b, _c;
+        const successResponse = (_a = endpoint.responses.find((x) => x.statusCode === 200)) !== null && _a !== void 0 ? _a : endpoint.responses.find((x) => x.statusCode && x.statusCode > 200 && x.statusCode < 300);
+        return (_c = (_b = successResponse === null || successResponse === void 0 ? void 0 : successResponse.contentOptions) === null || _b === void 0 ? void 0 : _b.find((x) => x.schema !== undefined)) === null || _c === void 0 ? void 0 : _c.schema;
+    }
 }
 exports.DefaultTypeScriptFetchClientGenerator = DefaultTypeScriptFetchClientGenerator;

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

@@ -6,6 +6,7 @@ const fs_extra_1 = require("fs-extra");
 const core_1 = require("@goast/core");
 const fetch_client_generator_1 = require("./fetch-client-generator");
 const models_1 = require("./models");
+const refs_1 = require("./refs");
 const file_builder_1 = require("../../../file-builder");
 const import_collection_1 = require("../../../import-collection");
 class TypeScriptClientsGenerator extends core_1.OpenApiServicesGenerationProviderBase {
@@ -22,7 +23,10 @@ class TypeScriptClientsGenerator extends core_1.OpenApiServicesGenerationProvide
         };
     }
     buildContext(context, config) {
-        return this.getProviderContext(context, config, models_1.defaultTypeScriptFetchClientsGeneratorConfig);
+        const providerContext = this.getProviderContext(context, config, models_1.defaultTypeScriptFetchClientsGeneratorConfig);
+        return Object.assign(providerContext, {
+            refs: (0, refs_1.getReferenceFactories)(providerContext.config),
+        });
     }
     onGenerate(ctx) {
         this.copyUtilsFiles(ctx);

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getReferenceFactories = void 0;
+const path_1 = require("path");
+const ast_1 = require("../../../ast");
+// See packages/typescript/assets/client/fetch for reference
+function getReferenceFactories(options) {
+    const utilsDirPath = (0, path_1.resolve)(options.outputDir, options.utilsDirPath);
+    const fetchClientUtilsPath = (0, path_1.resolve)(utilsDirPath, 'fetch-client.utils.ts');
+    return {
+        // fetch-client.utils.ts
+        typedResponse: ast_1.ts.reference.genericFactory('TypedResponse', fetchClientUtilsPath),
+        fetchClientOptions: ast_1.ts.reference.factory('FetchClientOptions', fetchClientUtilsPath),
+        urlBuilder: ast_1.ts.reference.factory('UrlBuilder', fetchClientUtilsPath),
+    };
+}
+exports.getReferenceFactories = getReferenceFactories;

package/cjs/lib/import-collection.js

@@ -1,13 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImportExportCollection = void 0;
+exports.ImportExportCollection = exports.defaultImportExportCollectionOptions = void 0;
 const path_1 = require("path");
 const core_1 = require("@goast/core");
+const config_1 = require("./config");
 const utils_1 = require("./utils");
+exports.defaultImportExportCollectionOptions = {
+    importModuleTransformer: config_1.defaultTypeScriptGeneratorConfig.importModuleTransformer,
+    useSingleQuotes: config_1.defaultTypeScriptGeneratorConfig.useSingleQuotes,
+};
 class ImportExportCollection {
-    constructor() {
+    constructor(options) {
         this._imports = new Map();
         this._exports = new Map();
+        this._options = Object.assign(Object.assign({}, exports.defaultImportExportCollectionOptions), options);
     }
     get hasImports() {
         return this._imports.size > 0;
@@ -46,34 +52,26 @@ class ImportExportCollection {
         this._imports.clear();
         this._exports.clear();
     }
-    toString(options, filePath, importModuleTransformer) {
+    toString(options) {
         const builder = new core_1.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) {
@@ -84,14 +82,15 @@ 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/esm/lib/ast/_index.js

@@ -0,0 +1,37 @@
+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 { 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';
+import * as refs_1 from './references';
+export { refs_1 as refs };
+export { getTypeScriptBuilderOptions as getBuilderOptions } from './utils/get-type-script-builder-options';
+export { toTsNode as toNode } from './utils/to-ts-node';

package/esm/lib/ast/common.js

@@ -0,0 +1 @@
+export {};

package/esm/lib/ast/index.js

@@ -0,0 +1,2 @@
+import * as ts_1 from './_index';
+export { ts_1 as ts };

package/esm/lib/ast/node.js

@@ -0,0 +1,6 @@
+import { AstNode } from '@goast/core';
+export class TsNode extends AstNode {
+    constructor(options) {
+        super(options);
+    }
+}

package/esm/lib/ast/nodes/argument.js

@@ -0,0 +1,16 @@
+import { TsNode } from '../node';
+import { writeTsNode } from '../utils/write-ts-nodes';
+import { writeTsParameters } from '../utils/write-ts-parameters';
+export class TsArgument extends TsNode {
+    constructor(options) {
+        super(options);
+        this.value = options.value;
+    }
+    onWrite(builder) {
+        writeTsNode(builder, this.value);
+    }
+}
+const createArgument = (value, options) => new TsArgument(Object.assign(Object.assign({}, options), { value }));
+export const tsArgument = Object.assign(createArgument, {
+    write: writeTsParameters,
+});

package/esm/lib/ast/nodes/array-type.js

@@ -0,0 +1,23 @@
+import { TsNode } from '../node';
+import { writeTsNode, writeTsNodes } from '../utils/write-ts-nodes';
+export class TsArrayType extends TsNode {
+    constructor(options) {
+        var _a;
+        super(options);
+        this.readonly = (_a = options.readonly) !== null && _a !== void 0 ? _a : false;
+        this.type = options.type;
+    }
+    onWrite(builder) {
+        if (this.readonly)
+            builder.append('readonly ');
+        builder
+            .append(this.inject.beforeType)
+            .parenthesize('()', (b) => writeTsNode(b, this.type))
+            .append(this.inject.afterType);
+        builder.append('[]');
+    }
+}
+const createArrayType = (type, options) => new TsArrayType(Object.assign(Object.assign({}, options), { type }));
+export const tsArrayType = Object.assign(createArrayType, {
+    write: writeTsNodes,
+});

package/esm/lib/ast/nodes/arrow-function.js

@@ -0,0 +1,47 @@
+import { notNullish } from '@goast/core';
+import { tsGenericParameter } from './generic-parameter';
+import { tsParameter } from './parameter';
+import { TsNode } from '../node';
+import { writeTsNode, writeTsNodes } from '../utils/write-ts-nodes';
+export class TsArrowFunction extends TsNode {
+    constructor(options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        super(options);
+        this.async = (_a = options.async) !== null && _a !== void 0 ? _a : false;
+        this.generics = (_c = (_b = options.generics) === null || _b === void 0 ? void 0 : _b.filter(notNullish)) !== null && _c !== void 0 ? _c : [];
+        this.parameters = (_e = (_d = options.parameters) === null || _d === void 0 ? void 0 : _d.filter(notNullish)) !== null && _e !== void 0 ? _e : [];
+        this.returnType = (_f = options.returnType) !== null && _f !== void 0 ? _f : null;
+        this.singleExpression = (_g = options.singleExpression) !== null && _g !== void 0 ? _g : false;
+        this.body = (_h = options.body) !== null && _h !== void 0 ? _h : null;
+    }
+    onWrite(builder) {
+        if (this.async) {
+            builder.append('async ');
+        }
+        builder.append(this.inject.beforeGenerics);
+        tsGenericParameter.write(builder, this.generics);
+        builder.append(this.inject.afterGenerics);
+        builder.append(this.inject.beforeParams);
+        tsParameter.write(builder, this.parameters);
+        builder.append(this.inject.afterParams);
+        if (this.returnType) {
+            builder.append(': ');
+            builder.append(this.inject.beforeReturnType);
+            writeTsNode(builder, this.returnType);
+            builder.append(this.inject.afterReturnType);
+        }
+        builder.append(' => ');
+        builder.append(this.inject.beforeBody);
+        if (this.singleExpression && this.body) {
+            builder.append(this.body);
+        }
+        else {
+            builder.parenthesize('{}', this.body, { multiline: !!this.body });
+        }
+        builder.append(this.inject.afterBody);
+    }
+}
+const createArrowFunction = (options) => new TsArrowFunction(options !== null && options !== void 0 ? options : {});
+export const tsArrowFunction = Object.assign(createArrowFunction, {
+    write: writeTsNodes,
+});