ts-openapi-codegen 1.0.0-beta.1 → 1.0.0-beta.3

package/dist/core/utils/__tests__/stripNamespace.test.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_test_1 = require("node:test");
+const stripNamespace_1 = require("../stripNamespace");
+(0, node_test_1.describe)('stripNamespace', () => {
+    (0, node_test_1.test)('@unit: should strip namespace', () => {
+        node_assert_1.default.strictEqual((0, stripNamespace_1.stripNamespace)('package/componentClass.yml#/components/TestComponent'), 'package/TestComponent');
+        node_assert_1.default.strictEqual((0, stripNamespace_1.stripNamespace)('package/componentClass.yml'), 'package/ComponentClass');
+        node_assert_1.default.strictEqual((0, stripNamespace_1.stripNamespace)('#/components/schemas/Item'), 'Item');
+        node_assert_1.default.strictEqual((0, stripNamespace_1.stripNamespace)('#/components/responses/Item'), 'Item');
+        node_assert_1.default.strictEqual((0, stripNamespace_1.stripNamespace)('#/components/parameters/Item'), 'Item');
+        node_assert_1.default.strictEqual((0, stripNamespace_1.stripNamespace)('#/components/examples/Item'), 'Item');
+        node_assert_1.default.strictEqual((0, stripNamespace_1.stripNamespace)('#/components/requestBodies/Item'), 'Item');
+        node_assert_1.default.strictEqual((0, stripNamespace_1.stripNamespace)('#/components/headers/Item'), 'Item');
+        node_assert_1.default.strictEqual((0, stripNamespace_1.stripNamespace)('#/components/securitySchemes/Item'), 'Item');
+        node_assert_1.default.strictEqual((0, stripNamespace_1.stripNamespace)('#/components/links/Item'), 'Item');
+        node_assert_1.default.strictEqual((0, stripNamespace_1.stripNamespace)('#/components/callbacks/Item'), 'Item');
+        node_assert_1.default.strictEqual((0, stripNamespace_1.stripNamespace)('/components/callbacks/item'), '/components/callbacks/Item');
+        node_assert_1.default.strictEqual((0, stripNamespace_1.stripNamespace)('/components/callbacks/some_special_item'), '/components/callbacks/SomeSpecialItem');
+        node_assert_1.default.strictEqual((0, stripNamespace_1.stripNamespace)('#/definitions/Item'), 'Item');
+        node_assert_1.default.strictEqual((0, stripNamespace_1.stripNamespace)('#/parameters/Item'), 'Item');
+        node_assert_1.default.strictEqual((0, stripNamespace_1.stripNamespace)('#/responses/Item'), 'Item');
+        node_assert_1.default.strictEqual((0, stripNamespace_1.stripNamespace)('#/securityDefinitions/Item'), 'Item');
+    });
+});

package/dist/core/utils/__tests__/unique.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=unique.test.d.ts.map

package/dist/core/utils/__tests__/unique.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unique.test.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/__tests__/unique.test.ts"],"names":[],"mappings":""}

package/dist/core/utils/__tests__/unique.test.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_test_1 = require("node:test");
+const unique_1 = require("../unique");
+(0, node_test_1.describe)('unique', () => {
+    (0, node_test_1.test)('@unit: should return correct index', () => {
+        node_assert_1.default.equal((0, unique_1.unique)('a', 0, ['a', 'b', 'c']), true);
+        node_assert_1.default.equal((0, unique_1.unique)('a', 1, ['a', 'b', 'c']), false);
+        node_assert_1.default.equal((0, unique_1.unique)('a', 2, ['a', 'b', 'c']), false);
+        node_assert_1.default.equal((0, unique_1.unique)('a', 0, ['a', 'b', 'c']), true);
+        node_assert_1.default.equal((0, unique_1.unique)('a', 1, ['z', 'a', 'b']), true);
+        node_assert_1.default.equal((0, unique_1.unique)('a', 2, ['y', 'z', 'a']), true);
+    });
+});

package/dist/core/utils/__tests__/writeClient.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=writeClient.test.d.ts.map

package/dist/core/utils/__tests__/writeClient.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeClient.test.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/__tests__/writeClient.test.ts"],"names":[],"mappings":""}

package/dist/core/utils/__tests__/writeClient.test.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_test_1 = require("node:test");
+const Enums_1 = require("../../types/Enums");
+const fileSystem_1 = require("../fileSystem");
+const getOutputPaths_1 = require("../getOutputPaths");
+const writeClient_1 = require("../writeClient");
+(0, node_test_1.test)('@unit: writeClient should write to filesystem', async () => {
+    const mkdirCalls = [];
+    const writeFileCalls = [];
+    // Сохраняем оригинальные реализации
+    const originalMkdir = fileSystem_1.fileSystem.mkdir;
+    const originalWriteFile = fileSystem_1.fileSystem.writeFile;
+    // Мокаем функции
+    fileSystem_1.fileSystem.mkdir = node_test_1.mock.fn(async (path) => {
+        mkdirCalls.push(path);
+        return path;
+    });
+    fileSystem_1.fileSystem.writeFile = node_test_1.mock.fn(async (path, content) => {
+        writeFileCalls.push([path, content]);
+    });
+    const client = {
+        server: 'http://localhost:8080',
+        version: 'v1',
+        models: [],
+        services: [],
+    };
+    const templates = {
+        index: () => 'index',
+        exports: {
+            model: () => 'model',
+            schema: () => 'schema',
+            service: () => 'service',
+        },
+        core: {
+            settings: () => 'settings',
+            apiError: () => 'apiError',
+            apiRequestOptions: () => 'apiRequestOptions',
+            apiResult: () => 'apiResult',
+            request: () => 'request',
+            cancelablePromise: () => 'cancelablePromise',
+            httpStatusCode: () => 'httpStatusCode',
+        },
+    };
+    const outputPaths = (0, getOutputPaths_1.getOutputPaths)({ output: './dist' });
+    await new writeClient_1.WriteClient().writeClient({
+        client,
+        templates,
+        outputPaths,
+        httpClient: Enums_1.HttpClient.FETCH,
+        useOptions: false,
+        useUnionTypes: false,
+        exportCore: true,
+        exportServices: true,
+        exportModels: true,
+        exportSchemas: true,
+        clean: true,
+    });
+    strict_1.default.ok(mkdirCalls.length > 0, 'mkdir should be called at least once');
+    strict_1.default.ok(writeFileCalls.length > 0, 'writeFile should be called at least once');
+    // Восстанавливаем оригинальные реализации
+    fileSystem_1.fileSystem.mkdir = originalMkdir;
+    fileSystem_1.fileSystem.writeFile = originalWriteFile;
+});

package/dist/core/utils/__tests__/writeClientCore.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=writeClientCore.test.d.ts.map

package/dist/core/utils/__tests__/writeClientCore.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeClientCore.test.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/__tests__/writeClientCore.test.ts"],"names":[],"mappings":""}

package/dist/core/utils/__tests__/writeClientCore.test.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_test_1 = require("node:test");
+const Enums_1 = require("../../types/Enums");
+const fileSystem_1 = require("../fileSystem");
+const writeClientCore_1 = require("../writeClientCore");
+(0, node_test_1.test)('@unit: writeClientCore writes to filesystem', async () => {
+    const writeFileCalls = [];
+    // Переприсваиваем функцию вручную с моком
+    const originalWriteFile = fileSystem_1.fileSystem.writeFile;
+    fileSystem_1.fileSystem.writeFile = node_test_1.mock.fn(async (path, content) => {
+        writeFileCalls.push([path, content]);
+    });
+    const client = {
+        server: 'http://localhost:8080',
+        version: '1.0',
+        models: [],
+        services: [],
+    };
+    const templates = {
+        index: () => 'index',
+        exports: {
+            model: () => 'model',
+            schema: () => 'schema',
+            service: () => 'service',
+        },
+        core: {
+            settings: () => 'settings',
+            apiError: () => 'apiError',
+            apiRequestOptions: () => 'apiRequestOptions',
+            apiResult: () => 'apiResult',
+            request: () => 'request',
+            cancelablePromise: () => 'cancelablePromise',
+            httpStatusCode: () => 'httpStatusCode',
+        },
+    };
+    const useCancelableRequest = true;
+    await (0, writeClientCore_1.writeClientCore)({ client, templates, outputCorePath: '/', httpClient: Enums_1.HttpClient.FETCH, useCancelableRequest });
+    node_assert_1.default.ok(writeFileCalls.some(([filePath, content]) => filePath.toString().includes('OpenAPI.ts') && content.toString().includes('settings')), 'Expected writeFile to be called with settings content for OpenAPI.ts');
+    node_assert_1.default.ok(writeFileCalls.some(([filePath, content]) => filePath.toString().includes('ApiError.ts') && content.toString().includes('apiError')), 'Expected writeFile to be called with apiError content for ApiError.ts');
+    node_assert_1.default.ok(writeFileCalls.some(([filePath, content]) => filePath.toString().includes('ApiRequestOptions.ts') && content.toString().includes('apiRequestOptions')), 'Expected writeFile to be called with apiRequestOptions content for ApiRequestOptions.ts');
+    node_assert_1.default.ok(writeFileCalls.some(([filePath, content]) => filePath.toString().includes('ApiResult.ts') && content.toString().includes('apiResult')), 'Expected writeFile to be called with apiResult content for ApiResult.ts');
+    node_assert_1.default.ok(writeFileCalls.some(([filePath, content]) => filePath.toString().includes('request.ts') && content.toString().includes('request')), 'Expected writeFile to be called with request content for request.ts');
+    node_assert_1.default.ok(writeFileCalls.some(([filePath, content]) => filePath.toString().includes('CancelablePromise.ts') && content.toString().includes('cancelablePromise')), 'Expected writeFile to be called with cancelablePromise content for CancelablePromise.ts');
+    node_assert_1.default.ok(writeFileCalls.some(([filePath, content]) => filePath.toString().includes('HttpStatusCode.ts') && content.toString().includes('httpStatusCode')), 'Expected writeFile to be called with httpStatusCode content for HttpStatusCode.ts');
+    // Восстанавливаем оригинальную функцию
+    fileSystem_1.fileSystem.writeFile = originalWriteFile;
+});

package/dist/core/utils/__tests__/writeClientIndex.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=writeClientIndex.test.d.ts.map

package/dist/core/utils/__tests__/writeClientIndex.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeClientIndex.test.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/__tests__/writeClientIndex.test.ts"],"names":[],"mappings":""}

package/dist/core/utils/__tests__/writeClientIndex.test.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_test_1 = require("node:test");
+const fileSystem_1 = require("../fileSystem");
+const writeClientIndex_1 = require("../writeClientIndex");
+(0, node_test_1.test)('@unit: writeClientIndex writes to filesystem', async () => {
+    const writeFileCalls = [];
+    // Переприсваиваем функцию вручную с моком
+    const originalWriteFile = fileSystem_1.fileSystem.writeFile;
+    fileSystem_1.fileSystem.writeFile = node_test_1.mock.fn(async (path, content) => {
+        writeFileCalls.push([path, content]);
+    });
+    const templates = {
+        index: () => 'index',
+        exports: {
+            model: () => 'model',
+            schema: () => 'schema',
+            service: () => 'service',
+        },
+        core: {
+            settings: () => 'settings',
+            apiError: () => 'apiError',
+            apiRequestOptions: () => 'apiRequestOptions',
+            apiResult: () => 'apiResult',
+            request: () => 'request',
+            cancelablePromise: () => 'cancelablePromise',
+            httpStatusCode: () => 'httpStatusCode',
+        },
+    };
+    await (0, writeClientIndex_1.writeClientIndex)({ templates, outputPath: '/', core: [], models: [], schemas: [], services: [] });
+    node_assert_1.default.ok(writeFileCalls.some(([filePath, content]) => filePath.toString().includes('index.ts') && content.toString().includes('index')), 'Expected writeFile to be called with index content for index.ts');
+    // Восстанавливаем оригинальную функцию
+    fileSystem_1.fileSystem.writeFile = originalWriteFile;
+});

package/dist/core/utils/__tests__/writeClientModels.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=writeClientModels.test.d.ts.map

package/dist/core/utils/__tests__/writeClientModels.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeClientModels.test.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/__tests__/writeClientModels.test.ts"],"names":[],"mappings":""}

package/dist/core/utils/__tests__/writeClientModels.test.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_test_1 = require("node:test");
+const Enums_1 = require("../../types/Enums");
+const fileSystem_1 = require("../fileSystem");
+const writeClientModels_1 = require("../writeClientModels");
+(0, node_test_1.test)('@unit: writeClientModels writes to filesystem', async () => {
+    const writeFileCalls = [];
+    // Переприсваиваем функцию вручную с моком
+    const originalWriteFile = fileSystem_1.fileSystem.writeFile;
+    fileSystem_1.fileSystem.writeFile = node_test_1.mock.fn(async (path, content) => {
+        writeFileCalls.push([path, content]);
+    });
+    const models = [
+        {
+            export: 'interface',
+            name: 'MyModel',
+            path: 'MyModel',
+            type: 'MyModel',
+            base: 'MyModel',
+            template: null,
+            link: null,
+            description: null,
+            isDefinition: true,
+            isReadOnly: false,
+            isRequired: false,
+            isNullable: false,
+            imports: [],
+            enum: [],
+            enums: [],
+            properties: [],
+            alias: '',
+        },
+    ];
+    const templates = {
+        index: () => 'index',
+        exports: {
+            model: () => 'model',
+            schema: () => 'schema',
+            service: () => 'service',
+        },
+        core: {
+            settings: () => 'settings',
+            apiError: () => 'apiError',
+            apiRequestOptions: () => 'apiRequestOptions',
+            apiResult: () => 'apiResult',
+            request: () => 'request',
+            cancelablePromise: () => 'cancelablePromise',
+            httpStatusCode: () => 'httpStatusCode',
+        },
+    };
+    await (0, writeClientModels_1.writeClientModels)({
+        models,
+        templates,
+        outputModelsPath: '/',
+        httpClient: Enums_1.HttpClient.FETCH,
+        useUnionTypes: false,
+    });
+    node_assert_1.default.ok(writeFileCalls.some(([filePath, content]) => filePath.toString().includes('MyModel.ts') && content.toString().includes('model')), 'Expected writeFile to be called with model content for MyModel.ts');
+    // Восстанавливаем оригинальную функцию
+    fileSystem_1.fileSystem.writeFile = originalWriteFile;
+});

package/dist/core/utils/__tests__/writeClientSchemas.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=writeClientSchemas.test.d.ts.map

package/dist/core/utils/__tests__/writeClientSchemas.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeClientSchemas.test.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/__tests__/writeClientSchemas.test.ts"],"names":[],"mappings":""}

package/dist/core/utils/__tests__/writeClientSchemas.test.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_test_1 = require("node:test");
+const Enums_1 = require("../../types/Enums");
+const fileSystem_1 = require("../fileSystem");
+const writeClientSchemas_1 = require("../writeClientSchemas");
+(0, node_test_1.test)('@unit: writeClientSchemas writes to filesystem', async () => {
+    const writeFileCalls = [];
+    // Переприсваиваем функцию вручную с моком
+    const originalWriteFile = fileSystem_1.fileSystem.writeFile;
+    fileSystem_1.fileSystem.writeFile = node_test_1.mock.fn(async (path, content) => {
+        writeFileCalls.push([path, content]);
+    });
+    const models = [
+        {
+            export: 'interface',
+            name: 'MyModel',
+            alias: '',
+            path: 'MyModel',
+            type: 'MyModel',
+            base: 'MyModel',
+            template: null,
+            link: null,
+            description: null,
+            isDefinition: true,
+            isReadOnly: false,
+            isRequired: false,
+            isNullable: false,
+            imports: [],
+            enum: [],
+            enums: [],
+            properties: [],
+        },
+    ];
+    const templates = {
+        index: () => 'index',
+        exports: {
+            model: () => 'model',
+            schema: () => 'schema',
+            service: () => 'service',
+        },
+        core: {
+            settings: () => 'settings',
+            apiError: () => 'apiError',
+            apiRequestOptions: () => 'apiRequestOptions',
+            apiResult: () => 'apiResult',
+            request: () => 'request',
+            cancelablePromise: () => 'cancelablePromise',
+            httpStatusCode: () => 'httpStatusCode',
+        },
+    };
+    await (0, writeClientSchemas_1.writeClientSchemas)({
+        models,
+        templates,
+        outputSchemasPath: '/',
+        httpClient: Enums_1.HttpClient.FETCH,
+        useUnionTypes: false,
+    });
+    node_assert_1.default.ok(writeFileCalls.some(([filePath, content]) => filePath.toString().includes('MyModelSchema.ts') && content.toString().includes('schema')), 'Expected writeFile to be called with schema content for MyModelSchema.ts');
+    // Восстанавливаем оригинальную функцию
+    fileSystem_1.fileSystem.writeFile = originalWriteFile;
+});

package/dist/core/utils/__tests__/writeClientServices.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=writeClientServices.test.d.ts.map

package/dist/core/utils/__tests__/writeClientServices.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeClientServices.test.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/__tests__/writeClientServices.test.ts"],"names":[],"mappings":""}

package/dist/core/utils/__tests__/writeClientServices.test.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_test_1 = require("node:test");
+const Enums_1 = require("../../types/Enums");
+const fileSystem_1 = require("../fileSystem");
+const writeClientServices_1 = require("../writeClientServices");
+(0, node_test_1.test)('@unit: writeClientServices  writes to filesystem', async () => {
+    const writeFileCalls = [];
+    // Переприсваиваем функцию вручную с моком
+    const originalWriteFile = fileSystem_1.fileSystem.writeFile;
+    fileSystem_1.fileSystem.writeFile = node_test_1.mock.fn(async (path, content) => {
+        writeFileCalls.push([path, content]);
+    });
+    const services = [
+        {
+            name: 'MyService',
+            originName: 'MyService',
+            operations: [],
+            imports: [],
+        },
+    ];
+    const templates = {
+        index: () => 'index',
+        exports: {
+            model: () => 'model',
+            schema: () => 'schema',
+            service: () => 'service',
+        },
+        core: {
+            settings: () => 'settings',
+            apiError: () => 'apiError',
+            apiRequestOptions: () => 'apiRequestOptions',
+            apiResult: () => 'apiResult',
+            request: () => 'request',
+            cancelablePromise: () => 'cancelablePromise',
+            httpStatusCode: () => 'httpStatusCode',
+        },
+    };
+    await (0, writeClientServices_1.writeClientServices)({
+        services,
+        templates,
+        outputPaths: {
+            outputCore: '/',
+            outputModels: '/',
+            outputServices: '/',
+        },
+        httpClient: Enums_1.HttpClient.FETCH,
+        useUnionTypes: false,
+        useOptions: false,
+        useCancelableRequest: false,
+    });
+    node_assert_1.default.ok(writeFileCalls.some(([filePath, content]) => filePath.toString().includes('MyService.ts') && content.toString().includes('service')), 'Expected writeFile to be called with service content for MyService.ts');
+    // Восстанавливаем оригинальную функцию
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    fileSystem_1.fileSystem.writeFile = originalWriteFile;
+});

package/dist/core/utils/areEqual.d.ts

@@ -0,0 +1,3 @@
+import { Model } from "../types/shared/Model.model";
+export declare function areEqual(a: Model, b: Model): boolean;
+//# sourceMappingURL=areEqual.d.ts.map

package/dist/core/utils/areEqual.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"areEqual.d.ts","sourceRoot":"","sources":["../../../src/core/utils/areEqual.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAC;AAEpD,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,OAAO,CAMpD"}

package/dist/core/utils/areEqual.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.areEqual = areEqual;
+function areEqual(a, b) {
+    const equal = a.type === b.type && a.base === b.base && a.template === b.template;
+    if (equal && a.link && b.link) {
+        return areEqual(a.link, b.link);
+    }
+    return equal;
+}

package/dist/core/utils/encode.d.ts

@@ -0,0 +1,2 @@
+export declare function encode(value: string): string;
+//# sourceMappingURL=encode.d.ts.map

package/dist/core/utils/encode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode.d.ts","sourceRoot":"","sources":["../../../src/core/utils/encode.ts"],"names":[],"mappings":"AAAA,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE5C"}

package/dist/core/utils/encode.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encode = encode;
+function encode(value) {
+    return value.replace(/^[^a-zA-Z_$]+/g, '').replace(/[^\w$]+/g, '_');
+}

package/dist/core/utils/escapeDescription.d.ts

@@ -0,0 +1,2 @@
+export declare function escapeDescription(value: string): string;
+//# sourceMappingURL=escapeDescription.d.ts.map

package/dist/core/utils/escapeDescription.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"escapeDescription.d.ts","sourceRoot":"","sources":["../../../src/core/utils/escapeDescription.ts"],"names":[],"mappings":"AAAA,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEvD"}

package/dist/core/utils/escapeDescription.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeDescription = escapeDescription;
+function escapeDescription(value) {
+    return value.replace(/([^\\])`/g, '$1\\`').replace(/(\*\/)/g, '*_/');
+}

package/dist/core/utils/escapeName.d.ts

@@ -0,0 +1,2 @@
+export declare function escapeName(value: string): string;
+//# sourceMappingURL=escapeName.d.ts.map

package/dist/core/utils/escapeName.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"escapeName.d.ts","sourceRoot":"","sources":["../../../src/core/utils/escapeName.ts"],"names":[],"mappings":"AAAA,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQhD"}

package/dist/core/utils/escapeName.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeName = escapeName;
+function escapeName(value) {
+    if (value) {
+        const validName = /^[a-zA-Z_$][\w$]+$/g.test(value);
+        if (!validName) {
+            return `'${value}'`;
+        }
+    }
+    return value;
+}

package/dist/core/utils/extendEnum.d.ts

@@ -0,0 +1,10 @@
+import type { Enum } from '../types/shared/Enum.model';
+import type { WithEnumExtension } from '../types/shared/extensions/WithEnumExtension.model';
+/**
+ * Extend the enum with the x-enum properties. This adds the capability
+ * to use names and descriptions inside the generated enums.
+ * @param enumerators
+ * @param definition
+ */
+export declare function extendEnum(enumerators: Enum[], definition: WithEnumExtension): Enum[];
+//# sourceMappingURL=extendEnum.d.ts.map

package/dist/core/utils/extendEnum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extendEnum.d.ts","sourceRoot":"","sources":["../../../src/core/utils/extendEnum.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,4BAA4B,CAAC;AACvD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oDAAoD,CAAC;AAE5F;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,WAAW,EAAE,IAAI,EAAE,EAAE,UAAU,EAAE,iBAAiB,GAAG,IAAI,EAAE,CAUrF"}

package/dist/core/utils/extendEnum.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendEnum = extendEnum;
+/**
+ * Extend the enum with the x-enum properties. This adds the capability
+ * to use names and descriptions inside the generated enums.
+ * @param enumerators
+ * @param definition
+ */
+function extendEnum(enumerators, definition) {
+    const names = definition['x-enum-varnames'];
+    const descriptions = definition['x-enum-descriptions'];
+    return enumerators.map((enumerator, index) => ({
+        name: names?.[index] || enumerator.name,
+        description: descriptions?.[index] || enumerator.description,
+        value: enumerator.value,
+        type: enumerator.type,
+    }));
+}

package/dist/core/utils/fileSystem.d.ts

@@ -0,0 +1,12 @@
+import { copyFile as __copyFile, exists as __exists, readFile as __readFile, writeFile as __writeFile } from 'fs';
+import mkdirp from 'mkdirp';
+declare const fileSystem: {
+    readFile: typeof __readFile.__promisify__;
+    writeFile: typeof __writeFile.__promisify__;
+    copyFile: typeof __copyFile.__promisify__;
+    exists: typeof __exists.__promisify__;
+    mkdir: typeof mkdirp;
+    rmdir: (path: string) => Promise<void>;
+};
+export { fileSystem };
+//# sourceMappingURL=fileSystem.d.ts.map

package/dist/core/utils/fileSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileSystem.d.ts","sourceRoot":"","sources":["../../../src/core/utils/fileSystem.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,IAAI,QAAQ,EAAE,QAAQ,IAAI,UAAU,EAAE,SAAS,IAAI,WAAW,EAAE,MAAM,IAAI,CAAC;AAClH,OAAO,MAAM,MAAM,QAAQ,CAAC;AAI5B,QAAA,MAAM,UAAU;;;;;;kBAMA,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC;CAOrC,CAAC;AAEF,OAAO,EAAE,UAAU,EAAE,CAAC"}

package/dist/core/utils/fileSystem.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileSystem = void 0;
+const fs_1 = require("fs");
+const mkdirp_1 = __importDefault(require("mkdirp"));
+const rimraf_1 = __importDefault(require("rimraf"));
+const util_1 = require("util");
+const fileSystem = {
+    readFile: (0, util_1.promisify)(fs_1.readFile),
+    writeFile: (0, util_1.promisify)(fs_1.writeFile),
+    copyFile: (0, util_1.promisify)(fs_1.copyFile),
+    exists: (0, util_1.promisify)(fs_1.exists),
+    mkdir: mkdirp_1.default,
+    rmdir: (path) => new Promise((resolve, reject) => {
+        (0, rimraf_1.default)(path, (error) => {
+            if (error)
+                reject(error);
+            else
+                resolve();
+        });
+    }),
+};
+exports.fileSystem = fileSystem;

package/dist/core/utils/flatMap.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Calls a defined callback function on each element of an array.
+ * Then, flattens the result into a new array.
+ */
+export declare function flatMap<U, T>(array: T[], callback: (value: T, index: number, array: T[]) => U[]): U[];
+//# sourceMappingURL=flatMap.d.ts.map

package/dist/core/utils/flatMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flatMap.d.ts","sourceRoot":"","sources":["../../../src/core/utils/flatMap.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,GAAG,CAAC,EAAE,CAMrG"}