@goast/typescript 0.0.1

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

@@ -0,0 +1,240 @@
+"use strict";
+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 file_builder_1 = require("../../../file-builder");
+const file_generator_1 = require("../../file-generator");
+class DefaultTypeScriptFetchClientGenerator extends file_generator_1.TypeScriptFileGenerator {
+    generate(ctx) {
+        const result = {};
+        let builder;
+        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());
+            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());
+            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(' */');
+        }
+    }
+    generateInterfaceSignature(ctx, builder) {
+        builder.append('export interface ').append(this.getInterfaceName(ctx));
+    }
+    generateInterfaceContent(ctx, builder) {
+        builder.forEach(ctx.service.endpoints, (builder, endpoint) => this.generateInterfaceServiceMethod(ctx, builder, endpoint));
+    }
+    generateInterfaceServiceMethod(ctx, builder, endpoint) {
+        builder
+            .ensurePreviousLineEmpty()
+            .append((builder) => this.generateServiceMethodDocumentation(ctx, builder, endpoint))
+            .ensureCurrentLineEmpty()
+            .append((builder) => this.generateServiceMethodSignature(ctx, builder, endpoint))
+            .appendLine(';');
+    }
+    generateDefaultOptions(ctx, builder) {
+        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('private readonly _options: FetchClientOptions;');
+    }
+    generateClassConstructor(ctx, builder) {
+        builder
+            .ensurePreviousLineEmpty()
+            .append('constructor(options?: FetchClientOptions)')
+            .parenthesize('{}', (builder) => this.generateClassConstructorContent(ctx, builder), {
+            indent: true,
+            multiline: true,
+        });
+    }
+    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.`);
+        });
+    }
+    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)}: ${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;
+    }
+    shouldGenerateInterface(ctx) {
+        return ctx.config.clientFileKind === 'interface' || ctx.config.clientFileKind === 'class-and-interface';
+    }
+    shouldGenerateClass(ctx) {
+        return ctx.config.clientFileKind === 'class' || ctx.config.clientFileKind === 'class-and-interface';
+    }
+    getInterfaceName(ctx) {
+        return (0, core_1.toCasing)(ctx.service.name, ctx.config.interfaceNameCasing);
+    }
+    getClassName(ctx) {
+        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);
+    }
+    getInterfaceFilePath(ctx) {
+        var _a, _b;
+        return (0, path_1.resolve)(ctx.config.outputDir, (_a = ctx.config.clientInterfaceDirPath) !== null && _a !== void 0 ? _a : ctx.config.clientDirPath, `${(0, core_1.toCasing)(ctx.service.name, (_b = ctx.config.interfaceFileNameCasing) !== null && _b !== void 0 ? _b : ctx.config.fileNameCasing)}.ts`);
+    }
+    getClassFilePath(ctx) {
+        return (0, path_1.resolve)(ctx.config.outputDir, ctx.config.clientDirPath, `${(0, core_1.toCasing)(ctx.service.name, ctx.config.fileNameCasing)}.ts`);
+    }
+    getUtilPath(ctx, fileName) {
+        return (0, path_1.resolve)(ctx.config.outputDir, ctx.config.utilsDirPath, fileName);
+    }
+}
+exports.DefaultTypeScriptFetchClientGenerator = DefaultTypeScriptFetchClientGenerator;

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

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeScriptClientsGenerator = void 0;
+const path_1 = require("path");
+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 file_builder_1 = require("../../../file-builder");
+const import_collection_1 = require("../../../import-collection");
+class TypeScriptClientsGenerator extends core_1.OpenApiServicesGenerationProviderBase {
+    constructor(clientGeneratorFactory) {
+        super();
+        this._clientGeneratorFactory =
+            clientGeneratorFactory !== null && clientGeneratorFactory !== void 0 ? clientGeneratorFactory : core_1.Factory.fromValue(new fetch_client_generator_1.DefaultTypeScriptFetchClientGenerator());
+    }
+    initResult() {
+        return {
+            clients: {},
+            clientIndexFilePath: undefined,
+            clientInterfaceIndexFilePath: undefined,
+        };
+    }
+    buildContext(context, config) {
+        return this.getProviderContext(context, config, models_1.defaultTypeScriptFetchClientsGeneratorConfig);
+    }
+    onGenerate(ctx) {
+        this.copyUtilsFiles(ctx);
+        const output = super.onGenerate(ctx);
+        output.clientIndexFilePath = this.generateIndexFile(ctx);
+        return output;
+    }
+    generateService(ctx, service) {
+        const clientGenerator = this._clientGeneratorFactory.create();
+        return clientGenerator.generate(Object.assign(Object.assign({}, ctx), { service }));
+    }
+    addServiceResult(ctx, service, result) {
+        ctx.output.clients[service.id] = result;
+    }
+    generateIndexFile(ctx) {
+        if (!this.shouldGenerateIndexFile(ctx)) {
+            return undefined;
+        }
+        const filePath = this.getIndexFilePath(ctx);
+        console.log(`Generating index file to ${filePath}...`);
+        (0, fs_extra_1.ensureDirSync)((0, path_1.dirname)(filePath));
+        const builder = new file_builder_1.TypeScriptFileBuilder(filePath, ctx.config);
+        this.generateIndexFileContent(ctx, builder);
+        (0, fs_extra_1.writeFileSync)(filePath, builder.toString());
+        return filePath;
+    }
+    getIndexFilePath(ctx) {
+        var _a;
+        return (0, path_1.resolve)(ctx.config.outputDir, (_a = ctx.config.indexFilePath) !== null && _a !== void 0 ? _a : 'clients.ts');
+    }
+    shouldGenerateIndexFile(ctx) {
+        return ctx.config.indexFilePath !== null;
+    }
+    generateIndexFileContent(ctx, builder) {
+        var _a, _b;
+        const exports = new import_collection_1.ImportExportCollection();
+        for (const clientId in ctx.output.clients) {
+            const client = ctx.output.clients[clientId];
+            if ((_a = client.class) === null || _a === void 0 ? void 0 : _a.filePath) {
+                exports.addExport(client.class.component, client.class.filePath);
+            }
+            if ((_b = client.interface) === null || _b === void 0 ? void 0 : _b.filePath) {
+                exports.addExport(client.interface.component, client.interface.filePath);
+            }
+        }
+        exports.writeTo(builder);
+    }
+    copyUtilsFiles(ctx) {
+        const sourceDir = (0, path_1.resolve)((0, path_1.dirname)(require.resolve('@goast/typescript')), '../assets/client/fetch');
+        const targetDir = (0, path_1.resolve)(ctx.config.outputDir, ctx.config.utilsDirPath);
+        (0, fs_extra_1.ensureDirSync)(targetDir);
+        const files = (0, fs_extra_1.readdirSync)(sourceDir);
+        for (const file of files) {
+            (0, fs_extra_1.copyFileSync)((0, path_1.resolve)(sourceDir, file), (0, path_1.resolve)(targetDir, file));
+        }
+    }
+}
+exports.TypeScriptClientsGenerator = TypeScriptClientsGenerator;

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./fetch-client-generator"), exports);
+tslib_1.__exportStar(require("./fetch-clients-generator"), exports);
+tslib_1.__exportStar(require("./models"), exports);

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultTypeScriptFetchClientsGeneratorConfig = void 0;
+const config_1 = require("../../../config");
+exports.defaultTypeScriptFetchClientsGeneratorConfig = Object.assign(Object.assign({}, config_1.defaultTypeScriptGeneratorConfig), { fileNameCasing: { casing: 'kebab', suffix: '-client' }, interfaceFileNameCasing: null, classNameCasing: { casing: 'pascal', suffix: 'Client' }, interfaceNameCasing: { prefix: 'I', casing: 'pascal', suffix: 'Client' }, methodCasing: 'camel', clientFileKind: 'class', clientDirPath: 'clients', clientInterfaceDirPath: 'clients/interfaces', indexFilePath: 'clients.ts', interfaceIndexFilePath: 'clients.ts', utilsDirPath: 'utils' });

package/cjs/lib/import-collection.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportExportCollection = void 0;
+const path_1 = require("path");
+const core_1 = require("@goast/core");
+const utils_1 = require("./utils");
+class ImportExportCollection {
+    constructor() {
+        this._imports = new Map();
+        this._exports = new Map();
+    }
+    get hasImports() {
+        return this._imports.size > 0;
+    }
+    get hasExports() {
+        return this._exports.size > 0;
+    }
+    get imports() {
+        return Array.from(this._imports.entries())
+            .map(([fromModule, importNames]) => Array.from(importNames).map((importName) => ({
+            kind: this.getImportKind(fromModule),
+            modulePath: fromModule,
+            name: importName,
+        })))
+            .flat();
+    }
+    addImport(importName, fromModule) {
+        const existingImport = this._imports.get(fromModule);
+        if (existingImport) {
+            existingImport.add(importName);
+        }
+        else {
+            this._imports.set(fromModule, new Set([importName]));
+        }
+    }
+    addExport(exportName, fromModule) {
+        const existingExport = this._exports.get(fromModule);
+        if (existingExport) {
+            existingExport.add(exportName);
+        }
+        else {
+            this._exports.set(fromModule, new Set([exportName]));
+        }
+    }
+    clear() {
+        this._imports.clear();
+        this._exports.clear();
+    }
+    toString(options, filePath, importModuleTransformer) {
+        const builder = new core_1.StringBuilder(options);
+        this.writeTo(builder, filePath, importModuleTransformer);
+        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');
+            }
+        }
+        if (this._imports.size > 0) {
+            const sortedImports = this.sortAndResolve(this._imports, filePath, importModuleTransformer);
+            this.writeImportsExports(builder, 'import', sortedImports);
+        }
+        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);
+        }
+    }
+    writeImportsExports(builder, keyword, data) {
+        const moduleData = [];
+        const fileData = [];
+        for (const x of data) {
+            if (x[1] === 'module') {
+                moduleData.push(x);
+            }
+            else {
+                fileData.push(x);
+            }
+        }
+        for (const [fromModule, _, names] of moduleData) {
+            builder.appendLine(`${keyword} { ${names.join(', ')} } from '${fromModule}';`);
+        }
+        if (moduleData.length > 0 && fileData.length > 0) {
+            builder.appendLine();
+        }
+        for (const [fromModule, _, names] of fileData) {
+            builder.appendLine(`${keyword} { ${names.join(', ')} } from '${fromModule}';`);
+        }
+    }
+    sortAndResolve(data, filePath, importModuleTransformer) {
+        return Array.from(data.entries())
+            .sort(([fromModuleA], [fromModuleB]) => fromModuleA.localeCompare(fromModuleB))
+            .map(([fromModule, names]) => [...this.resolveModulePath(fromModule, filePath, importModuleTransformer), Array.from(names).sort()]);
+    }
+    getImportKind(fromModule) {
+        const extName = (0, path_1.extname)(fromModule).toUpperCase();
+        return extName === '.TS' || extName === '.JS' || extName === '.JSON' ? 'file' : 'module';
+    }
+    resolveModulePath(fromModule, filePath, importModuleTransformer) {
+        const kind = this.getImportKind(fromModule);
+        return [
+            filePath && kind === 'file'
+                ? (0, utils_1.getModulePathRelativeToFile)(filePath, fromModule, importModuleTransformer)
+                : fromModule,
+            kind,
+        ];
+    }
+}
+exports.ImportExportCollection = ImportExportCollection;

package/cjs/lib/utils.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modifyString = exports.getModulePathRelativeToDirectory = exports.getModulePathRelativeToFile = exports.toTypeScriptPropertyName = exports.toTypeScriptStringLiteral = void 0;
+const path_1 = require("path");
+function doubleQuotedToSingleQuoted(value) {
+    return `'${value.slice(1, -1).replace(/'/g, "\\'")}'`;
+}
+function toTypeScriptStringLiteral(value, useSingleQuotes) {
+    return useSingleQuotes ? doubleQuotedToSingleQuoted(JSON.stringify(value)) : JSON.stringify(value);
+}
+exports.toTypeScriptStringLiteral = toTypeScriptStringLiteral;
+function toTypeScriptPropertyName(value, useSingleQuotes) {
+    if (value.match(/^[a-zA-Z_$][a-zA-Z_$0-9]*$/)) {
+        return value;
+    }
+    return useSingleQuotes ? doubleQuotedToSingleQuoted(JSON.stringify(value)) : JSON.stringify(value);
+}
+exports.toTypeScriptPropertyName = toTypeScriptPropertyName;
+function getModulePathRelativeToFile(from, to, transformer) {
+    return transformModulePath((0, path_1.relative)((0, path_1.dirname)(from), to).replace(/\\/g, '/'), transformer);
+}
+exports.getModulePathRelativeToFile = getModulePathRelativeToFile;
+function getModulePathRelativeToDirectory(from, to, transformer) {
+    return transformModulePath((0, path_1.relative)(from, to).replace(/\\/g, '/'), transformer);
+}
+exports.getModulePathRelativeToDirectory = getModulePathRelativeToDirectory;
+function transformModulePath(modulePath, transformer) {
+    if (!modulePath.startsWith('.')) {
+        modulePath = `./${modulePath}`;
+    }
+    if (transformer === 'omit-extension') {
+        return modulePath.replace(/\.[^/.]+$/, '');
+    }
+    else if (transformer === 'js-extension') {
+        return modulePath.replace(/\.[^/.]+$/, '.js');
+    }
+    else if (typeof transformer === 'function') {
+        return transformer(modulePath);
+    }
+    return modulePath;
+}
+function modifyString(value, modifier, ...args) {
+    var _a;
+    if (typeof modifier === 'string') {
+        return modifier;
+    }
+    if (modifier instanceof RegExp) {
+        const match = value.match(modifier);
+        return (_a = match === null || match === void 0 ? void 0 : match[0]) !== null && _a !== void 0 ? _a : value;
+    }
+    if (typeof modifier === 'function') {
+        return modifier(value, ...args);
+    }
+    return value;
+}
+exports.modifyString = modifyString;

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/esm/index.js

@@ -0,0 +1,6 @@
+export * from './lib/common-results';
+export * from './lib/config';
+export * from './lib/generators';
+export * from './lib/file-builder';
+export * from './lib/import-collection';
+export * from './lib/utils';

package/esm/lib/common-results.js

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

package/esm/lib/config.js

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