@goast/typescript 0.0.5 → 0.2.1

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

@@ -0,0 +1,18 @@
+import { TsNode } from '../node';
+import { writeTsNode, writeTsNodes } from '../utils/write-ts-nodes';
+export class TsTypeof extends TsNode {
+    constructor(options) {
+        super(options);
+        this.value = options.value;
+    }
+    onWrite(builder) {
+        builder.append('typeof ');
+        builder.append(this.inject.beforeValue);
+        writeTsNode(builder, this.value);
+        builder.append(this.inject.afterValue);
+    }
+}
+export const createTypeof = (value, options) => new TsTypeof(Object.assign(Object.assign({}, options), { value }));
+export const tsTypeof = Object.assign(createTypeof, {
+    write: writeTsNodes,
+});

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

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

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

@@ -0,0 +1,40 @@
+import { notNullish } from '@goast/core';
+import { TsNode } from '../node';
+import { writeTsNode, writeTsNodes } from '../utils/write-ts-nodes';
+export class TsUnionType extends TsNode {
+    constructor(options) {
+        super(options);
+        this.types = options.types.filter(notNullish);
+    }
+    onWrite(builder) {
+        const types = this.types.length === 0 ? ['never'] : resolveNestedUnionTypes(this);
+        if (types.length === 1) {
+            writeTsNode(builder, types[0]);
+        }
+        else {
+            const multiline = types.length > 3;
+            if (multiline) {
+                builder.appendLine().append('| ');
+            }
+            builder.forEach(types, (b, t) => b.parenthesize('()', (b) => writeTsNode(b, t)), {
+                separator: multiline ? '\n| ' : ' | ',
+            });
+        }
+    }
+}
+const createUnionType = (types, options) => new TsUnionType(Object.assign(Object.assign({}, options), { types }));
+export const tsUnionType = Object.assign(createUnionType, {
+    write: writeTsNodes,
+});
+function resolveNestedUnionTypes(node) {
+    const types = [];
+    for (const type of node.types) {
+        if (type instanceof TsUnionType) {
+            types.push(...resolveNestedUnionTypes(type));
+        }
+        else {
+            types.push(type);
+        }
+    }
+    return types;
+}

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

@@ -0,0 +1,34 @@
+import { TsNode } from '../node';
+import { writeTsNode, writeTsNodes } from '../utils/write-ts-nodes';
+export class TsVariable extends TsNode {
+    constructor(options) {
+        var _a, _b, _c, _d, _e;
+        super(options);
+        this.name = options.name;
+        this.doc = (_a = options.doc) !== null && _a !== void 0 ? _a : null;
+        this.type = (_b = options.type) !== null && _b !== void 0 ? _b : null;
+        this.value = (_c = options.value) !== null && _c !== void 0 ? _c : null;
+        this.export = (_d = options.export) !== null && _d !== void 0 ? _d : false;
+        this.readonly = (_e = options.readonly) !== null && _e !== void 0 ? _e : false;
+    }
+    onWrite(builder) {
+        if (this.export)
+            builder.append('export ');
+        builder.append(this.readonly ? 'const ' : 'let ');
+        builder.append(this.name);
+        if (this.type) {
+            builder.append(': ');
+            writeTsNode(builder, this.type);
+        }
+        if (this.value) {
+            builder.append(' = ');
+            writeTsNode(builder, this.value);
+        }
+        builder.append(';');
+        builder.appendLine();
+    }
+}
+const createVariable = (name, options) => new TsVariable(Object.assign(Object.assign({}, options), { name }));
+export const tsVariable = Object.assign(createVariable, {
+    write: writeTsNodes,
+});

package/esm/lib/ast/references/angular.js

@@ -0,0 +1,9 @@
+import { tsReference } from '../nodes/reference';
+// @angular/core
+export const inject = tsReference.factory('inject', '@angular/core');
+export const injectable = tsReference.factory('Injectable', '@angular/core');
+export const provider = tsReference.factory('Provider', '@angular/core');
+// @angular/common/http
+export const httpClient = tsReference.factory('HttpClient', '@angular/common/http');
+export const httpContext = tsReference.factory('HttpContext', '@angular/common/http');
+export const httpResponse = tsReference.genericFactory('HttpResponse', '@angular/common/http');

package/esm/lib/ast/references/easy-network-stub.js

@@ -0,0 +1,5 @@
+import { tsReference } from '../nodes/reference';
+export const easyNetworkStub = tsReference.factory('EasyNetworkStub', 'easy-network-stub');
+export const httpMethod = tsReference.factory('HttpMethod', 'easy-network-stub');
+export const routeResponseCallback = tsReference.genericFactory('RouteResponseCallback', 'easy-network-stub');
+export const errorResponse = tsReference.genericFactory('ErrorResponse', 'easy-network-stub');

package/esm/lib/ast/references/index.js

@@ -0,0 +1,7 @@
+import * as easyNetworkStub_1 from './easy-network-stub';
+export { easyNetworkStub_1 as easyNetworkStub };
+import * as angular_1 from './angular';
+export { angular_1 as angular };
+import * as rxjs_1 from './rxjs';
+export { rxjs_1 as rxjs };
+export * from './typescript';

package/esm/lib/ast/references/rxjs.js

@@ -0,0 +1,6 @@
+import { tsReference } from '../nodes/reference';
+export const observable = tsReference.factory('Observable', 'rxjs');
+export const firstValueFrom = tsReference.factory('firstValueFrom', 'rxjs');
+export const filter = tsReference.factory('filter', 'rxjs');
+export const map = tsReference.factory('map', 'rxjs');
+export const take = tsReference.factory('take', 'rxjs');

package/esm/lib/ast/references/typescript.js

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

package/esm/lib/ast/utils/get-type-script-builder-options.js

@@ -0,0 +1,15 @@
+import { defaultOpenApiGeneratorConfig } from '@goast/core';
+import { defaultTypeScriptGeneratorConfig } from '../../config';
+import { TypeScriptFileBuilder } from '../../file-builder';
+const tsConfigSymbol = Symbol();
+export function getTypeScriptBuilderOptions(builder) {
+    if (builder instanceof TypeScriptFileBuilder) {
+        return builder.options;
+    }
+    if (tsConfigSymbol in builder.options) {
+        return builder.options[tsConfigSymbol];
+    }
+    const options = Object.assign(Object.assign(Object.assign({}, defaultOpenApiGeneratorConfig), defaultTypeScriptGeneratorConfig), builder.options);
+    builder[tsConfigSymbol] = options;
+    return options;
+}

package/esm/lib/ast/utils/to-ts-node.js

@@ -0,0 +1,20 @@
+import { tsObject } from '../nodes/object';
+import { tsProperty } from '../nodes/property';
+import { tsString } from '../nodes/string';
+import { tsTuple } from '../nodes/tuple';
+export function toTsNode(value) {
+    if (Array.isArray(value)) {
+        return tsTuple(value.map((x) => toTsNode(x)));
+    }
+    if (typeof value === 'object' && value !== null) {
+        const result = tsObject();
+        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/esm/lib/ast/utils/write-ts-generic-parameters.js

@@ -0,0 +1,7 @@
+import { toArray, notNullish } from '@goast/core';
+import { writeTsNodes } from './write-ts-nodes';
+export function writeTsGenericParameters(builder, nodes) {
+    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/esm/lib/ast/utils/write-ts-members.js

@@ -0,0 +1,14 @@
+import { notNullish, isAppendValue } from '@goast/core';
+import { writeTsNode } from './write-ts-nodes';
+import { tsDoc } from '../nodes/doc';
+import { TsMethod } from '../nodes/method';
+import { TsProperty } from '../nodes/property';
+export function writeTsMembers(builder, members, options) {
+    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 === null || options === void 0 ? void 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/esm/lib/ast/utils/write-ts-nodes.js

@@ -0,0 +1,19 @@
+import { toArray, notNullish } from '@goast/core';
+import { TsNode } from '../node';
+export function writeTsNode(builder, node) {
+    if (node instanceof TsNode) {
+        node.write(builder);
+    }
+    else {
+        builder.append(node);
+    }
+}
+export function writeTsNodes(builder, nodes, options) {
+    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 === null || options === void 0 ? void 0 : options.separator });
+    }
+}

package/esm/lib/ast/utils/write-ts-parameters.js

@@ -0,0 +1,10 @@
+import { toArray, notNullish } from '@goast/core';
+import { writeTsNodes } from './write-ts-nodes';
+export function writeTsParameters(builder, nodes) {
+    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/esm/lib/config.js

@@ -1,12 +1,14 @@
 export const defaultTypeScriptGeneratorConfig = {
-    charsTreatedAsEmptyLine: ['{'],
     indent: { type: 'spaces', count: 2 },
     importModuleTransformer: 'omit-extension',
+    fileNameCasing: 'kebab',
     typeNameCasing: 'pascal',
-    methodNameCasing: 'camel',
+    functionNameCasing: 'camel',
     propertyNameCasing: 'camel',
     enumValueNameCasing: 'pascal',
-    constantCasing: { casing: 'snake', wordCasing: 'all-upper' },
+    constantNameCasing: { casing: 'snake', wordCasing: 'all-upper' },
+    genericParamNameCasing: { casing: 'pascal', prefix: 'T' },
+    paramNameCasing: 'camel',
     preferUnknown: true,
     useSingleQuotes: true,
 };

package/esm/lib/file-builder.js

@@ -1,13 +1,24 @@
-import { SourceBuilder, notNullish } from '@goast/core';
+import { dirname } from 'path';
+import { ensureDirSync, writeFileSync } from 'fs-extra';
+import { SourceBuilder, isAppendValue } from '@goast/core';
+import { TsNode } from './ast/node';
+import { defaultTypeScriptGeneratorConfig } from './config';
 import { ImportExportCollection } from './import-collection';
+export function isTypeScriptAppendValue(value) {
+    return isAppendValue(value) || value instanceof TsNode;
+}
 export class TypeScriptFileBuilder extends SourceBuilder {
     get options() {
         return super.options;
     }
     constructor(filePath, options) {
-        super(options);
-        this.imports = new ImportExportCollection();
+        super(options !== null && options !== void 0 ? options : defaultTypeScriptGeneratorConfig);
         this.filePath = filePath;
+        this.imports = new ImportExportCollection({
+            filePath: filePath,
+            importModuleTransformer: this.options.importModuleTransformer,
+            useSingleQuotes: this.options.useSingleQuotes,
+        });
     }
     addImport(name, moduleNameOrfilePath) {
         this.imports.addImport(name, moduleNameOrfilePath);
@@ -22,93 +33,23 @@ export class TypeScriptFileBuilder extends SourceBuilder {
         this.imports.clear();
     }
     toString(addPadding = true) {
-        return new SourceBuilder(this.options)
-            .append((builder) => this.imports.writeTo(builder, this.filePath, this.options.importModuleTransformer))
-            .appendIf(addPadding, (builder) => builder.ensurePreviousLineEmpty())
-            .append(super.toString())
-            .appendIf(addPadding, (builder) => builder.ensureCurrentLineEmpty())
-            .toString();
-    }
-    appendGenericArguments(...genericArguments) {
-        genericArguments = genericArguments.filter(notNullish);
-        if (genericArguments.length === 0)
-            return this;
-        const multiline = genericArguments.length > 1;
-        return this.parenthesize('<>', (builder) => builder.appendSeparated(genericArguments, multiline ? ',\n' : ', '), {
-            multiline,
-            indent: multiline,
-        });
-    }
-    appendParameter(parameter) {
-        var _a;
-        if (!parameter)
-            return;
-        if (typeof parameter === 'object') {
-            return this.append(parameter.name)
-                .appendIf(parameter.isOptional === true, '?')
-                .appendIf(parameter.type !== undefined, ': ', (builder) => {
-                if (!parameter.type)
-                    throw new Error('Unreachable error');
-                return typeof parameter.type === 'object'
-                    ? builder.appendExternalTypeUsage(parameter.type)
-                    : builder.append(parameter.type);
-            })
-                .appendGenericArguments(...((_a = parameter.genericArguments) !== null && _a !== void 0 ? _a : []))
-                .appendIf(parameter.defaultValue !== undefined, ' = ', parameter.defaultValue);
+        const builder = new SourceBuilder(this.options);
+        this.imports.writeTo(builder);
+        const baseString = super.toString();
+        if (baseString && addPadding) {
+            builder.ensurePreviousLineEmpty();
         }
-        else {
-            return this.append(parameter);
+        builder.append(baseString);
+        if (addPadding) {
+            builder.ensureCurrentLineEmpty();
         }
+        return builder.toString();
     }
-    appendParameters(...parameters) {
-        parameters = parameters.filter(notNullish);
-        if (parameters.length === 0)
-            return this.append('()');
-        const multiline = parameters.length > 1;
-        return this.parenthesize('()', (builder) => builder.forEach(parameters, (builder, param) => builder.appendParameter(param), {
-            separator: multiline ? ',\n' : ', ',
-        }), { multiline, indent: multiline });
-    }
-    appendObjectLiteral(...properties) {
-        properties = properties.filter(notNullish);
-        if (properties.length === 0)
-            return this.append('{}');
-        const multiline = properties.length > 1;
-        return this.parenthesize('{}', (builder) => builder
-            .appendIf(!multiline, ' ')
-            .appendSeparated(properties, multiline ? ',\n' : ', ')
-            .appendIf(!multiline, ' '), { multiline, indent: multiline });
-    }
-    appendArrayLiteral(...items) {
-        items = items.filter(notNullish);
-        if (items.length === 0)
-            return this.append('[]');
-        const multiline = items.length > 1;
-        return this.parenthesize('[]', (builder) => builder.appendSeparated(items, multiline ? ',\n' : ', '), {
-            multiline,
-            indent: multiline,
-        });
-    }
-    appendCodeBlock(...content) {
-        return this.parenthesize('{}', (builder) => builder.append(...content).ensureCurrentLineEmpty(), {
-            multiline: true,
-        });
-    }
-    appendComment(style, comment) {
-        if (!comment)
-            return this;
-        if (typeof comment === 'string') {
-            comment = comment.trim();
+    appendSingle(value) {
+        super.appendSingle(value);
+        if (value instanceof TsNode) {
+            value.write(this);
         }
-        return style === '//'
-            ? this.appendLineWithLinePrefix('// ', comment)
-            : this.appendLine(style === '/**/' ? '/*' : '/**')
-                .appendWithLinePrefix(' * ', comment)
-                .ensureCurrentLineEmpty()
-                .appendLine(' */');
-    }
-    appendDocumentation(documentation) {
-        return this.appendComment('/***/', documentation);
     }
     appendModelUsage(type) {
         this.append(type.component);
@@ -117,124 +58,25 @@ export class TypeScriptFileBuilder extends SourceBuilder {
         }
         return this;
     }
-    appendExternalTypeUsage(type) {
-        return this.append(type.name).addImport(type.name, type.module);
-    }
-    appendTypeDeclaration(options) {
-        return this.appendDocumentation(options.documentation)
-            .appendIf(options.omitExport !== true, 'export ')
-            .append('type ')
-            .append(options.name)
-            .append(' = ')
-            .append(options.type)
-            .appendLine(';');
-    }
-    appendAnnotation(options) {
-        var _a;
-        if (options.module)
-            this.addImport(options.name, options.module);
-        return this.append(`@${options.name}`).appendParameters(...((_a = options.args) !== null && _a !== void 0 ? _a : []));
+    writeToFile(filePath) {
+        if (!filePath)
+            filePath = this.filePath;
+        if (!filePath)
+            throw new Error('File path is required');
+        ensureDirSync(dirname(filePath));
+        writeFileSync(filePath, this.toString());
     }
-    appendAnnotations(annotations, separator) {
-        if (annotations.length === 0)
-            return this;
-        return this.forEach(annotations, (builder, annotation) => builder.appendAnnotation(annotation).append(separator));
+    static generate(options) {
+        TypeScriptFileBuilder.tryGenerate(options);
     }
-    appendClass(options) {
-        var _a;
-        return this.appendComment('/***/', options.documentation)
-            .appendAnnotations((_a = options.annotations) !== null && _a !== void 0 ? _a : [], '\n')
-            .appendIf(options.omitExport !== true, 'export ')
-            .appendIf(options.isAbstract === true, 'abstract ')
-            .append('class ')
-            .append(options.name)
-            .indent((builder) => {
-            var _a;
-            return builder
-                .appendGenericArguments(...((_a = options === null || options === void 0 ? void 0 : options.genericArguments) !== null && _a !== void 0 ? _a : []))
-                .appendIf(options.extends !== undefined, '\nextends ', options.extends)
-                .appendIf(options.implements !== undefined && options.implements.length > 0, ' implements ', (builder) => { var _a; return builder.appendSeparated((_a = options.implements) !== null && _a !== void 0 ? _a : [], ', '); });
-        })
-            .append(options.extends || (options.implements !== undefined && options.implements.length > 0) ? '\n' : ' ')
-            .appendCodeBlock(options.body)
-            .appendLine();
-    }
-    appendConstructor(options) {
-        var _a, _b;
-        return this.appendComment('/***/', options.documentation)
-            .appendAnnotations((_a = options.annotations) !== null && _a !== void 0 ? _a : [], '\n')
-            .append('constructor')
-            .appendParameters(...((_b = options === null || options === void 0 ? void 0 : options.parameters) !== null && _b !== void 0 ? _b : []))
-            .append(' ')
-            .appendCodeBlock(options.body)
-            .appendLine();
-    }
-    appendMethod(options) {
-        var _a, _b, _c;
-        return this.appendComment('/***/', options.documentation)
-            .appendAnnotations((_a = options.annotations) !== null && _a !== void 0 ? _a : [], '\n')
-            .appendIf(options.accessibility !== undefined, options.accessibility, ' ')
-            .appendIf(options.isAbstract === true, 'abstract ')
-            .appendIf(options.isStatic === true, 'static ')
-            .appendIf(options.isAsync === true, 'async ')
-            .append(options.name)
-            .appendGenericArguments(...((_b = options === null || options === void 0 ? void 0 : options.genericArguments) !== null && _b !== void 0 ? _b : []))
-            .appendParameters(...((_c = options === null || options === void 0 ? void 0 : options.parameters) !== null && _c !== void 0 ? _c : []))
-            .appendIf(options.returnType !== undefined, ': ', options.returnType)
-            .append(' ')
-            .appendCodeBlock(options.body)
-            .appendLine();
-    }
-    appendProperty(options) {
-        var _a, _b, _c, _d, _e;
-        if (options.kind === 'getter' || options.kind === 'setter' || options.kind === 'getter-setter') {
-            if (options.kind === 'getter-setter' || options.kind === 'getter') {
-                this.appendComment('/***/', options.documentation)
-                    .appendAnnotations([...((_a = options.annotations) !== null && _a !== void 0 ? _a : []), ...((_b = options.getterAnnotations) !== null && _b !== void 0 ? _b : [])], '\n')
-                    .appendIf(options.accessibility !== undefined, options.accessibility, ' ')
-                    .appendIf(options.isAbstract === true, 'abstract ')
-                    .appendIf(options.isStatic === true, 'static ')
-                    .append('get ', options.name, '()')
-                    .appendIf(options.type !== undefined, ': ', options.type)
-                    .if(options.isAbstract === true, (builder) => builder.append(';'), (builder) => builder.append(' ').appendCodeBlock(options.getter))
-                    .ensureCurrentLineEmpty();
-            }
-            if (options.kind === 'getter-setter' || options.kind === 'setter') {
-                this.appendComment('/***/', options.documentation)
-                    .appendAnnotations([...((_c = options.annotations) !== null && _c !== void 0 ? _c : []), ...((_d = options.setterAnnotations) !== null && _d !== void 0 ? _d : [])], '\n')
-                    .appendIf(options.accessibility !== undefined, options.accessibility, ' ')
-                    .appendIf(options.isAbstract === true, 'abstract ')
-                    .appendIf(options.isStatic === true, 'static ')
-                    .append('set ', options.name)
-                    .parenthesize('()', (builder) => builder.append('value: ', options.type))
-                    .if(options.isAbstract === true, (builder) => builder.append(';'), (builder) => builder.append(' ').appendCodeBlock(options.setter))
-                    .ensureCurrentLineEmpty();
-            }
-            return this;
+    static tryGenerate({ filePath, generator, options, logName, }) {
+        if (!filePath)
+            return;
+        if (logName) {
+            console.log(`Generating ${logName} to ${filePath}...`);
         }
-        return this.appendComment('/***/', options.documentation)
-            .appendAnnotations((_e = options.annotations) !== null && _e !== void 0 ? _e : [], '\n')
-            .appendIf(options.accessibility !== undefined, options.accessibility, ' ')
-            .appendIf(options.isAbstract === true, 'abstract ')
-            .appendIf(options.isStatic === true, 'static ')
-            .appendIf(options.isReadonly === true, 'readonly ')
-            .append(options.name)
-            .appendIf(options.isOptional === true, '?')
-            .appendIf(options.type !== undefined, ': ', options.type)
-            .appendIf(options.initializer !== undefined, ' = ', options.initializer)
-            .appendLine(';');
-    }
-    appendFunction(options) {
-        var _a, _b;
-        const kind = (_a = options.kind) !== null && _a !== void 0 ? _a : 'arrow-function';
-        return this.appendIf(kind === 'arrow-function' && !!options.name, 'const ', options.name, ' = ')
-            .appendIf(options.isAsync === true, 'async ')
-            .appendIf(kind === 'function', 'function')
-            .appendIf(kind === 'function' && !!options.name, ' ', options.name)
-            .appendParameters(...((_b = options === null || options === void 0 ? void 0 : options.parameters) !== null && _b !== void 0 ? _b : []))
-            .appendIf(options.returnType !== undefined, ': ', options.returnType)
-            .append(' ')
-            .appendIf(kind === 'arrow-function', '=> ')
-            .parenthesizeIf(kind === 'function' || options.singleLine !== true, '{}', (builder) => builder.append(options.body), { multiline: true });
+        const builder = new TypeScriptFileBuilder(filePath, options);
+        generator(builder);
+        builder.writeToFile();
     }
 }

package/esm/lib/generators/file-generator.js

@@ -1,22 +1,6 @@
-import { toCasing } from '@goast/core';
-import { toTypeScriptPropertyName, toTypeScriptStringLiteral } from '../utils';
+import { ts } from '../ast';
 export class TypeScriptFileGenerator {
     getAnyType(context) {
-        return context.config.preferUnknown ? 'unknown' : 'any';
-    }
-    toTypeName(context, name) {
-        return toCasing(name, context.config.typeNameCasing);
-    }
-    toMethodName(context, name) {
-        return toTypeScriptPropertyName(toCasing(name, context.config.methodNameCasing), context.config.useSingleQuotes);
-    }
-    toPropertyName(context, name, keepCasing = false) {
-        return toTypeScriptPropertyName(keepCasing ? name : toCasing(name, context.config.propertyNameCasing), context.config.useSingleQuotes);
-    }
-    toEnumValueName(context, name) {
-        return toTypeScriptPropertyName(toCasing(name, context.config.enumValueNameCasing), context.config.useSingleQuotes);
-    }
-    toStringLiteral(context, text) {
-        return toTypeScriptStringLiteral(text, context.config.useSingleQuotes);
+        return context.config.preferUnknown ? ts.refs.unknown() : ts.refs.any();
     }
 }

package/esm/lib/generators/index.js

@@ -2,3 +2,4 @@ export * from './file-generator';
 export * from './models';
 export * from './services/angular-services';
 export * from './services/fetch-clients';
+export * from './services/easy-network-stub';