wormajs 0.0.1

package/dist/core/parser/templateParser/helper.js

@@ -0,0 +1,333 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseResponse = parseResponse;
+exports.parseRequestBody = parseRequestBody;
+exports.getContentKey = getContentKey;
+exports.parseParameters = parseParameters;
+exports.transformApiMethods = transformApiMethods;
+exports.apiMethod2ApiDescriptor = apiMethod2ApiDescriptor;
+exports.apiDescriptor2apiMethod = apiDescriptor2apiMethod;
+const lodash_1 = require("lodash");
+const loader_1 = require("../../../core/loader");
+const logger_1 = require("../../../helper/logger");
+const utils_1 = require("../../../utils");
+async function parseResponse(responses, options) {
+    const { document, config, schemasMap, refNameMap } = options;
+    const successKey = (0, utils_1.getResponseSuccessKey)(responses);
+    const responseInfo = responses?.[successKey];
+    if (!responseInfo) {
+        return {
+            response: 'unknown',
+            responseComment: config.docComment !== false ? 'unknown' : '',
+        };
+    }
+    const responseObject = (0, utils_1.isReferenceObject)(responseInfo)
+        ? (0, utils_1.findBy$ref)(responseInfo.$ref, document)
+        : responseInfo;
+    const key = getContentKey(responseObject.content, config.responseMediaType);
+    const responseSchema = responseObject?.content?.[key]?.schema ?? {};
+    // P0: Single AST parse for both type + comment
+    const result = await loader_1.schemaLoader.transform(responseSchema, {
+        document,
+        deep: false,
+        noEnum: true,
+        commentType: config.docComment !== false ? 'doc' : 'line',
+        preText: '',
+        defaultRequire: config.defaultRequire,
+        refNameMap,
+        async onReference(ast) {
+            if (config.externalTypes?.includes(ast.keyName ?? '')) {
+                return;
+            }
+            if (ast.keyName && schemasMap && !schemasMap.has(ast.keyName)) {
+                const refResult = await loader_1.astLoader.transformTsStr(ast, {
+                    shallowDeep: true,
+                    commentType: 'doc',
+                    noEnum: true,
+                    format: true,
+                    export: true,
+                });
+                schemasMap.set(ast.keyName, refResult);
+            }
+        },
+    }, config.docComment !== false
+        ? {
+            document,
+            deep: true,
+            preText: '* ',
+            defaultRequire: config.defaultRequire,
+        }
+        : undefined);
+    return {
+        response: result.type,
+        responseComment: result.comment ?? '',
+    };
+}
+async function parseRequestBody(requestBody, options) {
+    if (!requestBody) {
+        return {
+            requestBody: '',
+            requestBodyComment: '',
+        };
+    }
+    const { document, config, schemasMap, refNameMap } = options;
+    const requestBodyObject = (0, utils_1.isReferenceObject)(requestBody)
+        ? (0, utils_1.findBy$ref)(requestBody.$ref, document)
+        : requestBody;
+    const key = getContentKey(requestBodyObject.content, config.bodyMediaType);
+    const requestBodySchema = requestBodyObject?.content?.[key]?.schema ?? {};
+    // P0: Single AST parse for both type + comment
+    const result = await loader_1.schemaLoader.transform(requestBodySchema, {
+        document,
+        deep: false,
+        noEnum: true,
+        commentType: config.docComment !== false ? 'doc' : 'line',
+        preText: '',
+        defaultRequire: config.defaultRequire,
+        refNameMap,
+        async onReference(ast) {
+            if (config.externalTypes?.includes(ast.keyName ?? '')) {
+                return;
+            }
+            if (ast.keyName && schemasMap && !schemasMap.has(ast.keyName)) {
+                const refResult = await loader_1.astLoader.transformTsStr(ast, {
+                    shallowDeep: true,
+                    commentType: 'doc',
+                    noEnum: true,
+                    format: true,
+                    export: true,
+                });
+                schemasMap.set(ast.keyName, refResult);
+            }
+        },
+    }, config.docComment !== false
+        ? {
+            document,
+            deep: true,
+            preText: '* ',
+            defaultRequire: config.defaultRequire,
+        }
+        : undefined);
+    return {
+        requestBody: result.type,
+        requestBodyComment: result.comment ?? '',
+    };
+}
+function getContentKey(content = {}, requireKey = 'application/json') {
+    const requireKeys = Array.isArray(requireKey) ? requireKey : [requireKey];
+    // 按数组顺序依次查找存在的 mediaType
+    for (const key of requireKeys) {
+        if (content[key]) {
+            return key;
+        }
+    }
+    // 如果都不存在，返回第一个 key 或默认值
+    return Object.keys(content)[0] || requireKeys[0];
+}
+async function parseParameters(parameters, options) {
+    const { document, config, schemasMap, refNameMap } = options;
+    const pathParametersSchema = {
+        type: 'object',
+    };
+    const queryParametersSchema = {
+        type: 'object',
+    };
+    const parseParameter = (parameter, parameters) => {
+        if (!parameters.properties) {
+            parameters.properties = {};
+        }
+        if (!parameters.required) {
+            parameters.required = [];
+        }
+        if (parameter.required) {
+            parameters.required.push(parameter.name);
+        }
+        parameters.properties[parameter.name] = {
+            ...parameter.schema,
+            description: parameter.description || '',
+            deprecated: !!parameter.deprecated,
+        };
+    };
+    const parseParametersSchema = async (parameters) => {
+        let parametersStr = '';
+        let parametersComment = '';
+        if (Object.keys(parameters.properties ?? {}).length) {
+            // P0: Single AST parse for both type + comment
+            const result = await loader_1.schemaLoader.transform(parameters, {
+                document,
+                deep: false,
+                noEnum: true,
+                commentType: config.docComment !== false ? 'doc' : 'line',
+                preText: '',
+                defaultRequire: config.defaultRequire,
+                refNameMap,
+                async onReference(ast) {
+                    if (config.externalTypes?.includes(ast.keyName ?? '')) {
+                        return;
+                    }
+                    if (ast.keyName && schemasMap && !schemasMap.has(ast.keyName)) {
+                        const refResult = await loader_1.astLoader.transformTsStr(ast, {
+                            shallowDeep: true,
+                            commentType: 'doc',
+                            noEnum: true,
+                            format: true,
+                            export: true,
+                        });
+                        schemasMap.set(ast.keyName, refResult);
+                    }
+                },
+            }, config.docComment !== false
+                ? {
+                    document,
+                    deep: true,
+                    preText: '* ',
+                    defaultRequire: config.defaultRequire,
+                }
+                : undefined);
+            parametersStr = result.type;
+            parametersComment = result.comment ?? '';
+        }
+        return [parametersStr, parametersComment];
+    };
+    for (const refParameter of parameters || []) {
+        const parameter = (0, utils_1.parseReference)(refParameter, document);
+        if (parameter.in === 'path') {
+            parseParameter(parameter, pathParametersSchema);
+        }
+        else if (parameter.in === 'query') {
+            parseParameter(parameter, queryParametersSchema);
+        }
+    }
+    const [pathParameters, pathParametersComment] = await parseParametersSchema(pathParametersSchema);
+    const [queryParameters, queryParametersComment] = await parseParametersSchema(queryParametersSchema);
+    return {
+        pathParameters,
+        queryParameters,
+        pathParametersComment,
+        queryParametersComment,
+    };
+}
+async function transformApiMethods(apiMethod, options) {
+    const { handleApi } = options.config;
+    if (!handleApi || typeof handleApi !== 'function') {
+        return apiMethod;
+    }
+    const { apiDescriptor, apiInfo } = apiMethod2ApiDescriptor(apiMethod, options);
+    // M2-B1: apiDescriptor 来自 apiMethod2ApiDescriptor 已做过 cloneDeep，无需二次克隆
+    let newApiDescriptor = apiDescriptor;
+    try {
+        newApiDescriptor = handleApi(newApiDescriptor);
+    }
+    catch (error) {
+        throw logger_1.logger.throwError(error);
+    }
+    if (!newApiDescriptor) {
+        return null;
+    }
+    Object.entries(newApiDescriptor.refNameMap || {}).forEach(([key, value]) => {
+        options.refNameMap.set(key, value);
+    });
+    const newApiMethod = apiDescriptor2apiMethod(newApiDescriptor, {
+        oldApiInfo: apiInfo,
+        operationObject: apiMethod.operationObject,
+    });
+    newApiMethod.operationObject = (0, utils_1.mergeObject)(apiMethod.operationObject, newApiMethod.operationObject, {
+        openApi: options.document,
+        map: options.map,
+        refNameMap: options.refNameMap,
+    });
+    return newApiMethod;
+}
+function apiMethod2ApiDescriptor(apiMethod, options) {
+    const { url, method } = apiMethod;
+    const { document, config } = options;
+    // 需要深拷贝：handleApi 可能修改 tags/security 等嵌套字段，浅拷贝会污染原始 operationObject
+    const operationObject = (0, lodash_1.cloneDeep)(apiMethod.operationObject);
+    const { requestBody, responses, parameters } = operationObject;
+    const apiDescriptor = {
+        ...operationObject,
+        requestBody: {},
+        responses: {},
+        parameters: [],
+        url,
+        method,
+    };
+    const successKey = (0, utils_1.getResponseSuccessKey)(responses);
+    const responseSuccess = responses?.[successKey];
+    const refNameMap = new Map();
+    let requestBodyObject = requestBody;
+    let responseObject = responseSuccess;
+    let requestKey = 'application/json';
+    let responseKey = 'application/json';
+    if (parameters) {
+        apiDescriptor.parameters = [];
+        parameters.forEach((parameter) => {
+            apiDescriptor.parameters?.push((0, utils_1.removeAll$ref)(parameter, document, { refNameMap }));
+        });
+    }
+    if (requestBody) {
+        requestBodyObject = (0, utils_1.parseReference)(requestBody, document, true);
+        requestKey = getContentKey(requestBodyObject.content, config.bodyMediaType);
+        apiDescriptor.requestBody = (0, utils_1.removeAll$ref)(requestBodyObject.content?.[requestKey].schema ?? {}, document, { refNameMap });
+    }
+    if (responseSuccess) {
+        responseObject = (0, utils_1.parseReference)(responseSuccess, document, true);
+        responseKey = getContentKey(responseObject.content, config.responseMediaType);
+        apiDescriptor.responses = (0, utils_1.removeAll$ref)(responseObject.content?.[responseKey].schema ?? {}, document, { refNameMap });
+    }
+    apiDescriptor.refNameMap = Object.fromEntries(refNameMap);
+    return {
+        apiDescriptor,
+        apiInfo: {
+            successKey,
+            requestKey,
+            responseKey,
+            requestBody: requestBodyObject,
+            response: responseObject,
+            hasResponse: !!responseSuccess,
+            hasRequestBody: !!requestBody,
+            hasParameters: !!parameters,
+        },
+    };
+}
+function apiDescriptor2apiMethod(apiDescriptor, options) {
+    const apiDescriptorValue = { ...apiDescriptor };
+    const operationObject = (0, lodash_1.cloneDeep)(options.operationObject); // 仍需深拷贝：content[key].schema 等深路径赋值后通过 mergeObject 回写
+    const { url, method } = apiDescriptorValue;
+    const { successKey, requestKey, responseKey, hasResponse, hasParameters, hasRequestBody, requestBody, response } = options.oldApiInfo;
+    if (!(0, lodash_1.isEmpty)(apiDescriptorValue.requestBody) || hasRequestBody) {
+        operationObject.requestBody = requestBody || { content: {} };
+        const { content } = operationObject.requestBody;
+        if (!content[requestKey]) {
+            content[requestKey] = {};
+        }
+        content[requestKey].schema = apiDescriptorValue.requestBody;
+    }
+    if (!(0, lodash_1.isEmpty)(apiDescriptorValue.responses) || hasResponse) {
+        if (!operationObject.responses) {
+            operationObject.responses = {};
+        }
+        operationObject.responses[successKey] = response || { content: {} };
+        if (!operationObject.responses[successKey].content) {
+            operationObject.responses[successKey].content = {};
+        }
+        const { content } = operationObject.responses[successKey];
+        if (!content[responseKey]) {
+            content[responseKey] = {};
+        }
+        content[responseKey].schema = apiDescriptorValue.responses;
+    }
+    if (!(0, lodash_1.isEmpty)(apiDescriptorValue.parameters) || hasParameters) {
+        operationObject.parameters = apiDescriptorValue.parameters;
+    }
+    delete apiDescriptorValue.requestBody;
+    delete apiDescriptorValue.responses;
+    delete apiDescriptorValue.parameters;
+    delete apiDescriptorValue.refNameMap;
+    Object.assign(operationObject, apiDescriptorValue);
+    return {
+        url,
+        method,
+        operationObject,
+    };
+}

package/dist/core/parser/templateParser/index.js

@@ -0,0 +1,314 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.templateParser = exports.TemplateParser = void 0;
+const node_os_1 = require("node:os");
+const node_path_1 = __importDefault(require("node:path"));
+const loader_1 = require("../../../core/loader");
+const WorkerPool_1 = require("../../../core/WorkerPool");
+const poolManager_1 = require("../../../core/workerPool/poolManager");
+const getFrameworkTag_1 = __importDefault(require("../../../functions/getFrameworkTag"));
+const helper_1 = require("../../../helper");
+const document_1 = require("../../../helper/document");
+const openapi_1 = require("../../../utils/openapi");
+const helper_2 = require("./helper");
+/** M2-B4: 轻量并发 limiter，无额外依赖 */
+async function pMap(items, fn, concurrency) {
+    const results = Array.from({ length: items.length });
+    let idx = 0;
+    async function worker() {
+        while (idx < items.length) {
+            const i = idx++;
+            results[i] = await fn(items[i]);
+        }
+    }
+    await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, () => worker()));
+    return results;
+}
+/** 根据 CPU 核数自动计算合理并发上限 */
+function autoConcurrency() {
+    const cpuCount = Math.max(1, (0, node_os_1.cpus)().length);
+    return Math.min(64, Math.max(8, cpuCount * 4));
+}
+class TemplateParser {
+    constructor() {
+        this.name = 'templateParser';
+        this.schemasMap = new Map();
+        this.operationIdSet = new Set();
+        this.pathMap = [];
+        this.refNameMap = new Map();
+        /** M1-A4: 用 Map 索引替代 tagedApis.find() 线性查找，O(n·t) → O(n+t) */
+        this.tagMap = new Map();
+        this.openApiHelper = new document_1.OpenApiHelper();
+    }
+    async parse(document, options) {
+        this.document = document;
+        this.options = options;
+        const templateData = await this.parseBaseInfo();
+        await this.parseApiMethods(this.openApiHelper.load(document).getApiMethods(), templateData);
+        this.clear();
+        return templateData;
+    }
+    clear() {
+        this.schemasMap.clear();
+        this.operationIdSet.clear();
+        this.pathMap.splice(0, this.pathMap.length);
+        this.refNameMap.clear();
+        this.tagMap.clear();
+    }
+    async parseBaseInfo() {
+        const generatorHelper = await helper_1.GeneratorHelper.load(this.options.generatorConfig);
+        const templateType = await generatorHelper.getTemplateType(this.options.projectPath);
+        const { info, openapi } = this.document;
+        const templateData = {
+            title: info.title,
+            openapi,
+            version: info.version,
+            description: info.description,
+            contact: info.contact,
+            framework: await (0, getFrameworkTag_1.default)(this.options.projectPath),
+            baseUrl: this.document.servers?.[0]?.url || '',
+            allApis: [],
+            tagedApis: [],
+            components: [],
+            componentNames: [],
+            type: templateType,
+            config: {},
+        };
+        return templateData;
+    }
+    async transformApiMethods(apiMethod) {
+        const { url, method, operationObject } = apiMethod;
+        operationObject.operationId = loader_1.standardLoader.transformOperationId(operationObject, {
+            url,
+            method,
+            map: this.operationIdSet,
+        });
+        operationObject.tags = loader_1.standardLoader.transformTags(operationObject.tags);
+        const result = await (0, helper_2.transformApiMethods)(apiMethod, {
+            document: this.document,
+            refNameMap: this.refNameMap,
+            config: this.options.generatorConfig,
+            map: this.pathMap,
+        });
+        return result;
+    }
+    async parseApiMethods(apiMethods, templateData) {
+        const concurrency = autoConcurrency();
+        const apiMethodArray = (await pMap(apiMethods, apiMethod => this.transformApiMethods(apiMethod), concurrency)).filter(apiMethod => !!apiMethod);
+        const refsMap = Object.fromEntries(this.refNameMap);
+        const usedRefs = this.openApiHelper
+            .saveApiMethods(apiMethodArray)
+            .filterUsedReferences(Object.keys(refsMap));
+        this.refNameMap = new Map(Object.entries((0, openapi_1.optimizeRefsMap)(refsMap, usedRefs)));
+        // M4-C1: Pre-process schemas via worker pool for parallel schema→TS conversion
+        const poolSize = (0, WorkerPool_1.pickPoolSize)(apiMethodArray.length);
+        if (poolSize > 0) {
+            const tasks = this.collectSchemaTasks(apiMethodArray);
+            if (tasks.length > 0) {
+                // .js for production, .ts for vitest/dev; existsSync may fail in mocked fs
+                const jsWp = node_path_1.default.resolve(__dirname, '../../workerPool/worker.js');
+                const tsWp = node_path_1.default.resolve(__dirname, '../../workerPool/worker.ts');
+                const { existsSync: fex } = await Promise.resolve().then(() => __importStar(require('node:fs')));
+                const workerScript = fex(jsWp) ? jsWp : tsWp;
+                // P2: Reuse worker pool via PoolManager singleton — avoids create/destroy overhead across repeated generate() calls
+                const pool = poolManager_1.PoolManager.getInstance().get({
+                    key: `schemaWorker_${this.options.projectPath}`,
+                    workerScript,
+                    sharedContext: {
+                        document: this.document,
+                        config: {
+                            defaultRequire: this.options.generatorConfig.defaultRequire,
+                            externalTypes: this.options.generatorConfig.externalTypes,
+                        },
+                        refNameMapEntries: [...this.refNameMap.entries()],
+                    },
+                    poolSize,
+                });
+                const results = await pool.processBatch(tasks);
+                for (const { key, result } of results) {
+                    this.schemasMap.set(key, result);
+                }
+            }
+        }
+        (await pMap(apiMethodArray, apiMethod => this.transformApis(apiMethod), concurrency))
+            .flat()
+            .forEach((api) => {
+            this.parseApi(api, templateData);
+        });
+        templateData.components = [...new Set(this.schemasMap.values())];
+        templateData.componentNames = [...this.schemasMap.keys()];
+        // 按名称字典序排序，确保输出顺序确定性（避免并发场景下 Map 插入顺序漂移）
+        const sorted = [...this.schemasMap.entries()].sort(([a], [b]) => a.localeCompare(b));
+        templateData.componentNames = sorted.map(([k]) => k);
+        templateData.components = sorted.map(([, v]) => v);
+    }
+    /**
+     * M4-C1: Collect all unique schema objects from API methods for batch processing.
+     * Mirrors the schema construction logic from parseParameters/parseRequestBody/parseResponse
+     * but without calling getTsStr — only collects the SchemaObjects for deferred processing.
+     */
+    collectSchemaTasks(apiMethodArray) {
+        const tasks = [];
+        const seen = new Set();
+        const genConfig = this.options.generatorConfig;
+        function add(schema) {
+            if (!schema || typeof schema !== 'object')
+                return false;
+            const hash = JSON.stringify(schema);
+            if (seen.has(hash))
+                return false;
+            seen.add(hash);
+            const key = `schema_${seen.size}`;
+            tasks.push({ key, schema });
+            return true;
+        }
+        for (const apiMethod of apiMethodArray) {
+            const { operationObject } = apiMethod;
+            // Collect parameter schemas (mirroring parseParameters)
+            if (operationObject.parameters) {
+                const pathSchema = { type: 'object', properties: {}, required: [] };
+                const querySchema = { type: 'object', properties: {}, required: [] };
+                for (const refParam of operationObject.parameters) {
+                    const param = (0, openapi_1.parseReference)(refParam, this.document);
+                    if (param.in === 'path') {
+                        const target = pathSchema;
+                        if (param.required)
+                            target.required.push(param.name);
+                        target.properties[param.name] = {
+                            ...param.schema,
+                            description: param.description || '',
+                            deprecated: !!param.deprecated,
+                        };
+                    }
+                    else if (param.in === 'query') {
+                        const target = querySchema;
+                        if (param.required)
+                            target.required.push(param.name);
+                        target.properties[param.name] = {
+                            ...param.schema,
+                            description: param.description || '',
+                            deprecated: !!param.deprecated,
+                        };
+                    }
+                }
+                if (Object.keys(pathSchema.properties).length)
+                    add(pathSchema);
+                if (Object.keys(querySchema.properties).length)
+                    add(querySchema);
+            }
+            // Collect request body schema (mirroring parseRequestBody)
+            if (operationObject.requestBody) {
+                const rb = (0, openapi_1.parseReference)(operationObject.requestBody, this.document, true);
+                const bodyKey = (0, helper_2.getContentKey)(rb.content, genConfig.bodyMediaType);
+                const schema = rb.content?.[bodyKey]?.schema;
+                add(schema);
+            }
+            // Collect response schema (mirroring parseResponse)
+            if (operationObject.responses) {
+                const successKey = (0, openapi_1.getResponseSuccessKey)(operationObject.responses);
+                const resp = (0, openapi_1.parseReference)(operationObject.responses[successKey], this.document);
+                if (resp) {
+                    const respKey = (0, helper_2.getContentKey)(resp.content, genConfig.responseMediaType);
+                    const schema = resp.content?.[respKey]?.schema;
+                    add(schema);
+                }
+            }
+        }
+        return tasks;
+    }
+    async transformApis(apiMethod) {
+        const { method, url: path, operationObject } = apiMethod;
+        const apis = [];
+        const tags = operationObject.tags ?? [];
+        for (const tag of tags) {
+            const { queryParameters, queryParametersComment, pathParameters, pathParametersComment } = await (0, helper_2.parseParameters)(operationObject.parameters, {
+                document: this.document,
+                config: this.options.generatorConfig,
+                schemasMap: this.schemasMap,
+                refNameMap: this.refNameMap,
+            });
+            const { requestBodyComment, requestBody } = await (0, helper_2.parseRequestBody)(operationObject.requestBody, {
+                document: this.document,
+                config: this.options.generatorConfig,
+                schemasMap: this.schemasMap,
+                refNameMap: this.refNameMap,
+            });
+            const { responseComment, response } = await (0, helper_2.parseResponse)(operationObject.responses, {
+                document: this.document,
+                config: this.options.generatorConfig,
+                schemasMap: this.schemasMap,
+                refNameMap: this.refNameMap,
+            });
+            const api = {
+                tag,
+                method: method.toUpperCase(),
+                summary: operationObject.summary?.replace(/\n/g, '') ?? '',
+                path,
+                name: operationObject.operationId ?? '',
+                response,
+                requestBody,
+                queryParameters,
+                queryParametersComment,
+                pathParameters,
+                pathParametersComment,
+                responseComment,
+                requestBodyComment,
+                callingCode: '',
+            };
+            api.callingCode = await loader_1.callingCodeLoader.transformApi(api);
+            apis.push(api);
+        }
+        return apis;
+    }
+    parseApi(api, templateData) {
+        templateData.allApis.push(api);
+        let tagApis = this.tagMap.get(api.tag);
+        if (!tagApis) {
+            tagApis = {
+                tagName: api.tag,
+                apis: [],
+            };
+            this.tagMap.set(api.tag, tagApis);
+            templateData.tagedApis.push(tagApis);
+        }
+        tagApis.apis.push(api);
+    }
+}
+exports.TemplateParser = TemplateParser;
+exports.templateParser = new TemplateParser();

package/dist/core/workerPool/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerPool = exports.pickPoolSize = void 0;
+var WorkerPool_1 = require("../WorkerPool");
+Object.defineProperty(exports, "pickPoolSize", { enumerable: true, get: function () { return WorkerPool_1.pickPoolSize; } });
+Object.defineProperty(exports, "WorkerPool", { enumerable: true, get: function () { return WorkerPool_1.WorkerPool; } });