openapi-ts-request 1.11.0 → 1.12.1

package/dist/generator/serviceGenarator.js

@@ -15,6 +15,7 @@ const config_2 = require("./config");
 const file_1 = require("./file");
 const merge_1 = require("./merge");
 const patchSchema_1 = require("./patchSchema");
+const Helper = tslib_1.__importStar(require("./serviceGeneratorHelper"));
 const util_2 = require("./util");
 class ServiceGenerator {
     constructor(config, openAPIData) {
@@ -23,6 +24,8 @@ class ServiceGenerator {
         this.classNameList = [];
         this.schemaList = [];
         this.interfaceTPConfigs = [];
+        // 记录每个类型被哪些模块使用（用于拆分类型文件）
+        this.typeModuleMap = new Map();
         this.config = Object.assign({ templatesFolder: (0, path_1.join)(__dirname, '../../', 'templates') }, config);
         this.generateInfoLog();
         const includeTags = ((_a = this.config) === null || _a === void 0 ? void 0 : _a.includeTags) || [];
@@ -183,10 +186,56 @@ class ServiceGenerator {
         (0, util_2.handleDuplicateTypeNames)(this.interfaceTPConfigs);
         // 生成 ts 类型声明
         if (!isGenJavaScript) {
-            this.genFileFromTemplate(`${config_2.interfaceFileName}.ts`, config_2.TypescriptFileType.interface, {
-                nullable: this.config.nullable,
-                list: this.interfaceTPConfigs,
-            });
+            if (this.config.isSplitTypesByModule) {
+                // 按模块拆分类型文件
+                const { moduleTypes, commonTypes, enumTypes } = this.groupTypesByModule();
+                // 生成枚举文件
+                if (enumTypes.length > 0) {
+                    this.genFileFromTemplate(`${config_2.enumFileName}.ts`, config_2.TypescriptFileType.enum, {
+                        list: enumTypes,
+                    });
+                }
+                // 生成公共类型文件
+                if (commonTypes.length > 0) {
+                    // 分析公共类型需要导入的枚举
+                    const { enumImports } = this.getModuleImports(commonTypes, [], // 公共类型不依赖其他公共类型
+                    enumTypes);
+                    this.genFileFromTemplate(`${config_2.commonTypeFileName}.ts`, config_2.TypescriptFileType.moduleType, {
+                        nullable: this.config.nullable,
+                        list: commonTypes,
+                        enumImports, // 公共类型需要导入的枚举
+                    });
+                }
+                // 生成每个模块的类型文件
+                moduleTypes.forEach((types, moduleName) => {
+                    if (types.length > 0) {
+                        // 分析该模块需要导入哪些类型
+                        const { commonImports, enumImports } = this.getModuleImports(types, commonTypes, enumTypes);
+                        this.genFileFromTemplate(`${moduleName}.type.ts`, config_2.TypescriptFileType.moduleType, {
+                            nullable: this.config.nullable,
+                            list: types,
+                            commonImports, // 需要导入的公共类型
+                            enumImports, // 需要导入的枚举类型
+                        });
+                    }
+                });
+                // 生成 types.ts 作为统一导出入口
+                this.genFileFromTemplate(`${config_2.interfaceFileName}.ts`, config_2.TypescriptFileType.typeIndex, {
+                    hasEnumTypes: enumTypes.length > 0,
+                    hasCommonTypes: commonTypes.length > 0,
+                    moduleList: Array.from(moduleTypes.keys()).filter((moduleName) => {
+                        const types = moduleTypes.get(moduleName);
+                        return types ? types.length > 0 : false;
+                    }),
+                });
+            }
+            else {
+                // 传统方式：所有类型在一个文件
+                this.genFileFromTemplate(`${config_2.interfaceFileName}.ts`, config_2.TypescriptFileType.interface, {
+                    nullable: this.config.nullable,
+                    list: this.interfaceTPConfigs,
+                });
+            }
         }
         // 生成枚举翻译
         const enums = (0, lodash_1.filter)(this.interfaceTPConfigs, (item) => item.isEnum);
@@ -257,6 +306,8 @@ class ServiceGenerator {
         const lastTypes = this.interfaceTPConfigs;
         const includeTags = ((_b = this.config) === null || _b === void 0 ? void 0 : _b.includeTags) || [];
         const includePaths = ((_c = this.config) === null || _c === void 0 ? void 0 : _c.includePaths) || [];
+        // 记录每个 schema 被哪些模块使用（用于拆分类型）
+        const schemaUsageMap = new Map();
         // 强行替换掉请求参数params的类型，生成方法对应的 xxxxParams 类型
         (0, lodash_1.keys)(this.openAPIData.paths).forEach((pathKey) => {
             const pathItem = this.openAPIData.paths[pathKey];
@@ -280,6 +331,36 @@ class ServiceGenerator {
                 }
                 // 筛选出 pathItem 包含的 $ref 对应的schema
                 (0, util_2.markAllowedSchema)(JSON.stringify(pathItem), this.openAPIData);
+                // 如果启用了类型拆分，记录每个 schema 被哪些模块使用
+                if (this.config.isSplitTypesByModule) {
+                    const pathItemStr = JSON.stringify(pathItem);
+                    const refRegex = /"\$ref":\s*"#\/components\/schemas\/([^"]+)"/g;
+                    let match;
+                    while ((match = refRegex.exec(pathItemStr)) !== null) {
+                        const schemaName = match[1];
+                        if (!schemaName)
+                            continue;
+                        tags.forEach((tag) => {
+                            var _a;
+                            if (tag) {
+                                const tagTypeName = (0, util_2.resolveTypeName)(tag);
+                                const tagKey = this.config.isCamelCase
+                                    ? (0, util_1.camelCase)(tagTypeName)
+                                    : (0, lodash_1.lowerFirst)(tagTypeName);
+                                const className = ((_a = this.config.hook) === null || _a === void 0 ? void 0 : _a.customClassName)
+                                    ? this.config.hook.customClassName(tag)
+                                    : (0, util_2.replaceDot)(tagKey);
+                                if (!schemaUsageMap.has(schemaName)) {
+                                    schemaUsageMap.set(schemaName, new Set());
+                                }
+                                const moduleSet = schemaUsageMap.get(schemaName);
+                                if (moduleSet) {
+                                    moduleSet.add(className);
+                                }
+                            }
+                        });
+                    }
+                }
                 operationObject.parameters = (_b = operationObject.parameters) === null || _b === void 0 ? void 0 : _b.filter((item) => {
                     const parameter = this.resolveParameterRef(item);
                     return (parameter === null || parameter === void 0 ? void 0 : parameter.in) !== `${config_2.parametersInsEnum.header}`;
@@ -318,6 +399,22 @@ class ServiceGenerator {
                         props: [props],
                         isEnum: false,
                     });
+                    // 记录 Params 类型归属（属于对应的 tag/module）
+                    if (this.config.isSplitTypesByModule) {
+                        tags.forEach((tag) => {
+                            var _a;
+                            if (tag) {
+                                const tagTypeName = (0, util_2.resolveTypeName)(tag);
+                                const tagKey = this.config.isCamelCase
+                                    ? (0, util_1.camelCase)(tagTypeName)
+                                    : (0, lodash_1.lowerFirst)(tagTypeName);
+                                const className = ((_a = this.config.hook) === null || _a === void 0 ? void 0 : _a.customClassName)
+                                    ? this.config.hook.customClassName(tag)
+                                    : (0, util_2.replaceDot)(tagKey);
+                                this.markTypeUsedByModule(typeName, className);
+                            }
+                        });
+                    }
                 }
             });
         });
@@ -344,8 +441,9 @@ class ServiceGenerator {
                 (0, lodash_1.forEach)(result.props[0], (item) => {
                     if (item.enum) {
                         const enumObj = this.resolveEnumObject(item);
+                        const enumTypeName = `${(0, lodash_1.upperFirst)(item.name)}Enum`;
                         lastTypes.push({
-                            typeName: `${(0, lodash_1.upperFirst)(item.name)}Enum`,
+                            typeName: enumTypeName,
                             type: enumObj.type,
                             props: [],
                             isEnum: enumObj.isEnum,
@@ -353,6 +451,16 @@ class ServiceGenerator {
                             enumLabelType: enumObj.enumLabelType,
                             description: enumObj.description,
                         });
+                        // 记录枚举类型归属（继承父 schema 的归属）
+                        if (this.config.isSplitTypesByModule &&
+                            schemaUsageMap.has(schemaKey)) {
+                            const moduleSet = schemaUsageMap.get(schemaKey);
+                            if (moduleSet) {
+                                moduleSet.forEach((className) => {
+                                    this.markTypeUsedByModule(enumTypeName, className);
+                                });
+                            }
+                        }
                     }
                 });
             }
@@ -370,6 +478,15 @@ class ServiceGenerator {
                     enumLabelType: isEnum ? result.enumLabelType : '',
                     description: result.description,
                 });
+                // 记录 schema 类型归属
+                if (this.config.isSplitTypesByModule && schemaUsageMap.has(schemaKey)) {
+                    const moduleSet = schemaUsageMap.get(schemaKey);
+                    if (moduleSet) {
+                        moduleSet.forEach((className) => {
+                            this.markTypeUsedByModule(typeName, className);
+                        });
+                    }
+                }
             }
             if (this.config.isGenJsonSchemas) {
                 this.schemaList.push({
@@ -386,6 +503,11 @@ class ServiceGenerator {
             var _a, _b;
             // functionName tag 级别防重
             const tmpFunctionRD = {};
+            // 获取当前模块的 className (用于记录类型归属)
+            const fileName = (0, util_2.replaceDot)(tag) || `api${index}`;
+            const className = ((_a = this.config.hook) === null || _a === void 0 ? void 0 : _a.customClassName)
+                ? this.config.hook.customClassName(tag)
+                : fileName;
             const genParams = this.apiData[tag]
                 .filter((api) => 
             // 暂不支持变量, path 需要普通前缀请使用例如: apiPrefix: "`api`", path 需要变量前缀请使用例如: apiPrefix: "api"
@@ -418,6 +540,10 @@ class ServiceGenerator {
                             isEnum: false,
                             props: [],
                         });
+                        // 记录类型归属
+                        if (this.config.isSplitTypesByModule) {
+                            this.markTypeUsedByModule(bodyName, className);
+                        }
                         body.type = `${this.config.namespace}.${bodyName}`;
                     }
                     if (response === null || response === void 0 ? void 0 : response.isAnonymous) {
@@ -432,17 +558,26 @@ class ServiceGenerator {
                             isEnum: false,
                             props: [],
                         });
+                        // 记录类型归属
+                        if (this.config.isSplitTypesByModule) {
+                            this.markTypeUsedByModule(responseName, className);
+                        }
                         response.type = `${this.config.namespace}.${responseName}`;
                     }
                     const responsesType = this.getResponsesType(newApi.responses, functionName);
                     // 如果有多个响应类型，生成对应的类型定义
                     if (responsesType) {
+                        const responsesTypeName = (0, lodash_1.upperFirst)(`${functionName}Responses`);
                         this.interfaceTPConfigs.push({
-                            typeName: (0, lodash_1.upperFirst)(`${functionName}Responses`),
+                            typeName: responsesTypeName,
                             type: responsesType,
                             isEnum: false,
                             props: [],
                         });
+                        // 记录类型归属
+                        if (this.config.isSplitTypesByModule) {
+                            this.markTypeUsedByModule(responsesTypeName, className);
+                        }
                     }
                     let formattedPath = newApi.path.replace(/:([^/]*)|{([^}]*)}/gi, (_, str, str2) => `$\{${str || str2}}`);
                     // 为 path 中的 params 添加 alias
@@ -514,11 +649,7 @@ class ServiceGenerator {
             })
                 // 排序下，防止git乱
                 .sort((a, b) => a.path.localeCompare(b.path));
-            const fileName = (0, util_2.replaceDot)(tag) || `api${index}`;
-            let className = fileName;
-            if ((_a = this.config.hook) === null || _a === void 0 ? void 0 : _a.customClassName) {
-                className = this.config.hook.customClassName(tag);
-            }
+            // fileName 和 className 已在方法开始时声明
             if (genParams.length) {
                 this.classNameList.push({
                     fileName: className,
@@ -706,28 +837,10 @@ class ServiceGenerator {
         return null;
     }
     resolveFileTP(obj) {
-        var _a;
-        let ret = [];
-        const resolved = this.resolveObject(obj);
-        const props = (((_a = resolved.props) === null || _a === void 0 ? void 0 : _a.length) > 0 &&
-            resolved.props[0].filter((p) => p.format === 'binary' ||
-                p.format === 'base64' ||
-                (0, util_2.isBinaryArraySchemaObject)(p))) ||
-            [];
-        if (props.length > 0) {
-            ret = props.map((p) => {
-                // 这里 p.type 是自定义type, 注意别混淆
-                return {
-                    title: p.name,
-                    multiple: p.type === `${config_1.SchemaObjectType.array}` ||
-                        p.type === `${config_1.SchemaObjectType.stringArray}`,
-                };
-            });
-        }
-        if (resolved.type) {
-            ret = [...ret, ...this.resolveFileTP(resolved.type)];
-        }
-        return ret;
+        return Helper.resolveFileTP({
+            obj,
+            resolveObjectFunc: (schemaObject) => this.resolveObject(schemaObject),
+        });
     }
     getResponseTP(responses = {}) {
         var _a;
@@ -804,47 +917,13 @@ class ServiceGenerator {
      * @returns 多状态码响应类型定义字符串，如果没有响应则返回 null
      */
     getResponsesType(responses = {}, functionName) {
-        if ((0, lodash_1.isEmpty)(responses) ||
-            ~(0, lodash_1.findIndex)(this.interfaceTPConfigs, (item) => item.typeName === (0, lodash_1.upperFirst)(`${functionName}Responses`))) {
-            return null;
-        }
-        const { components } = this.openAPIData;
-        // 生成主响应类型名称
-        const mainResponseTypeName = (0, lodash_1.upperFirst)(`${functionName}Response`);
-        const responseEntries = this.parseResponseEntries(responses, components);
-        const responseTypes = responseEntries.map(({ statusCode, type, description = '' }) => {
-            var _a;
-            // 检查是否已存在对应的主响应类型，如果存在则复用，避免重复定义
-            const existType = this.interfaceTPConfigs.find((item) => item.typeName === mainResponseTypeName);
-            const lastType = existType ? mainResponseTypeName : type;
-            // 格式化描述文本，让描述支持换行
-            const formattedDescription = config_2.lineBreakReg.test(description)
-                ? (_a = description.split('\n')) === null || _a === void 0 ? void 0 : _a.join('\n * ')
-                : description;
-            // 生成带注释的类型定义
-            return formattedDescription
-                ? `  /**\n   * ${formattedDescription}\n   */\n  ${statusCode}: ${lastType};`
-                : `  ${statusCode}: ${lastType};`;
-        });
-        // 返回完整的对象类型定义
-        return `{\n${responseTypes.join('\n')}\n}`;
-    }
-    /**
-     * 解析响应条目，提取每个状态码对应的类型和描述信息
-     *
-     * @param responses OpenAPI 响应对象
-     * @param components OpenAPI 组件对象，用于解析引用类型
-     * @returns 响应条目数组，包含状态码、类型和描述
-     */
-    parseResponseEntries(responses, components) {
-        return (0, lodash_1.keys)(responses).map((statusCode) => {
-            const response = this.resolveRefObject(responses[statusCode]);
-            if (!response) {
-                return { statusCode, type: 'unknown', description: '' };
-            }
-            const responseType = this.getResponseTypeFromContent(response, components);
-            const description = response.description || '';
-            return { statusCode, type: responseType, description };
+        return Helper.getResponsesType({
+            responses,
+            functionName,
+            interfaceTPConfigs: this.interfaceTPConfigs,
+            components: this.openAPIData.components,
+            getResponseTypeFromContentFunc: (params) => this.getResponseTypeFromContent(params.response, params.components),
+            resolveRefObjectFunc: (refObject) => this.resolveRefObject(refObject),
         });
     }
     /**
@@ -856,90 +935,22 @@ class ServiceGenerator {
      * @returns TypeScript 类型字符串
      */
     getResponseTypeFromContent(response, components) {
-        var _a;
-        if (!response.content) {
-            return 'unknown';
-        }
-        const resContent = response.content;
-        const resContentMediaTypes = (0, lodash_1.keys)(resContent);
-        // 检测二进制流媒体类型
-        const binaryMediaTypes = (0, util_2.getBinaryMediaTypes)(this.config.binaryMediaTypes);
-        const binaryMediaType = resContentMediaTypes.find((mediaType) => (0, util_2.isBinaryMediaType)(mediaType, binaryMediaTypes));
-        const mediaType = resContentMediaTypes.includes('application/json')
-            ? 'application/json'
-            : binaryMediaType || resContentMediaTypes[0];
-        if (!(0, lodash_1.isObject)(resContent) || !mediaType) {
-            return 'unknown';
-        }
-        // 如果是二进制媒体类型，直接返回二进制类型
-        if ((0, util_2.isBinaryMediaType)(mediaType, binaryMediaTypes)) {
-            return (0, util_2.getBinaryResponseType)();
-        }
-        let schema = (resContent[mediaType].schema ||
-            config_2.DEFAULT_SCHEMA);
-        if ((0, util_2.isReferenceObject)(schema)) {
-            const refName = (0, util_2.getLastRefName)(schema.$ref);
-            const childrenSchema = components.schemas[refName];
-            // 如果配置了 dataFields，尝试从指定字段提取类型
-            if ((0, util_2.isNonArraySchemaObject)(childrenSchema) && this.config.dataFields) {
-                schema = (((_a = this.config.dataFields
-                    .map((field) => childrenSchema.properties[field])
-                    .filter(Boolean)) === null || _a === void 0 ? void 0 : _a[0]) ||
-                    resContent[mediaType].schema ||
-                    config_2.DEFAULT_SCHEMA);
-            }
-            return this.getType(schema);
-        }
-        else if ((0, util_2.isSchemaObject)(schema)) {
-            // 设置属性的 required 状态
-            (0, lodash_1.keys)(schema.properties).map((fieldName) => {
-                var _a, _b;
-                schema.properties[fieldName]['required'] =
-                    (_b = (_a = schema.required) === null || _a === void 0 ? void 0 : _a.includes(fieldName)) !== null && _b !== void 0 ? _b : false;
-            });
-            return this.getType(schema);
-        }
-        else {
-            return this.getType(schema);
-        }
+        return Helper.getResponseTypeFromContent({
+            response,
+            components,
+            config: this.config,
+            getType: (schema) => this.getType(schema),
+        });
     }
     getParamsTP(parameters = [], path = null) {
-        const templateParams = {};
-        if (parameters === null || parameters === void 0 ? void 0 : parameters.length) {
-            (0, lodash_1.forEach)(config_2.parametersIn, (source) => {
-                const params = parameters
-                    .map((p) => this.resolveRefObject(p))
-                    .filter((p) => p.in === source)
-                    .map((p) => {
-                    var _a, _b, _c, _d, _e;
-                    const isDirectObject = (((_a = p.schema) === null || _a === void 0 ? void 0 : _a.type) === 'object' ||
-                        p.type) === 'object';
-                    const refName = (0, util_2.getLastRefName)(((_b = p.schema) === null || _b === void 0 ? void 0 : _b.$ref) ||
-                        p.$ref);
-                    const deRefObj = (0, lodash_1.entries)((_c = this.openAPIData.components) === null || _c === void 0 ? void 0 : _c.schemas).find(([k]) => k === refName) || [];
-                    const isRefObject = ((_d = deRefObj[1]) === null || _d === void 0 ? void 0 : _d.type) === 'object' &&
-                        !(0, lodash_1.isEmpty)((_e = deRefObj[1]) === null || _e === void 0 ? void 0 : _e.properties);
-                    return Object.assign(Object.assign({}, p), { isObject: isDirectObject || isRefObject, type: this.getType(p.schema || config_2.DEFAULT_SCHEMA, this.config.namespace) });
-                });
-                if (params.length) {
-                    templateParams[source] = params;
-                }
-            });
-        }
-        if (path && path.length > 0) {
-            const regex = /\{(\w+)\}/g;
-            templateParams.path = templateParams.path || [];
-            let match = null;
-            while ((match = regex.exec(path))) {
-                if (!templateParams.path.some((p) => p.name === match[1])) {
-                    templateParams.path.push(Object.assign(Object.assign({}, config_2.DEFAULT_PATH_PARAM), { name: match[1] }));
-                }
-            }
-            // 如果 path 没有内容，则将删除 path 参数，避免影响后续的 hasParams 判断
-            if (!templateParams.path.length)
-                delete templateParams.path;
-        }
-        return templateParams;
+        return Helper.getParamsTP({
+            parameters,
+            path,
+            namespace: this.config.namespace,
+            openAPIData: this.openAPIData,
+            getType: (schema, namespace) => this.getType(schema, namespace),
+            resolveParameterRefFunc: (params) => this.resolveParameterRef(params.param),
+        });
     }
     resolveObject(schemaObject) {
         // 不使用 schemaObject: ISchemaObject = {}
@@ -967,158 +978,54 @@ class ServiceGenerator {
         return schemaObject;
     }
     resolveArray(schemaObject) {
-        var _a;
-        if ((0, util_2.isReferenceObject)(schemaObject.items)) {
-            const refName = (0, util_2.getRefName)(schemaObject.items);
-            return {
-                type: `${refName}[]`,
-            };
-        }
-        else if ((_a = schemaObject.items) === null || _a === void 0 ? void 0 : _a.enum) {
-            return {
-                type: this.getType(schemaObject, this.config.namespace),
-            };
-        }
-        // 这里需要解析出具体属性，但由于 parser 层还不确定，所以暂时先返回 unknown[]
-        return { type: 'unknown[]' };
+        return Helper.resolveArray({
+            schemaObject,
+            namespace: this.config.namespace,
+            getType: (schema, namespace) => this.getType(schema, namespace),
+        });
     }
     resolveProperties(schemaObject) {
-        return {
-            props: [this.getProps(schemaObject)],
-        };
+        return Helper.resolveProperties({
+            schemaObject,
+            getProps: (schema) => this.getProps(schema),
+        });
     }
     resolveEnumObject(schemaObject) {
-        var _a;
-        const enumArray = schemaObject.enum;
-        let enumStr = '';
-        let enumLabelTypeStr = '';
-        if (config_2.numberEnum.includes(schemaObject.type) || (0, util_2.isAllNumber)(enumArray)) {
-            if (this.config.isSupportParseEnumDesc && schemaObject.description) {
-                const enumMap = (0, util_2.parseDescriptionEnum)(schemaObject.description);
-                enumStr = `{${(0, lodash_1.map)(enumArray, (value) => {
-                    const enumLabel = enumMap.get(Number(value));
-                    return `${enumLabel}=${Number(value)}`;
-                }).join(',')}}`;
-            }
-            else {
-                enumStr = `{${(0, lodash_1.map)(enumArray, (value) => `"NUMBER_${value}"=${Number(value)}`).join(',')}}`;
-            }
-        }
-        else if ((0, util_2.isAllNumeric)(enumArray)) {
-            enumStr = `{${(0, lodash_1.map)(enumArray, (value) => `"STRING_NUMBER_${value}"="${value}"`).join(',')}}`;
-        }
-        else {
-            enumStr = `{${(0, lodash_1.map)(enumArray, (value) => `"${value}"="${value}"`).join(',')}}`;
-        }
-        // 翻译枚举
-        if (schemaObject['x-enum-varnames'] && schemaObject['x-enum-comments']) {
-            enumLabelTypeStr = `{${(0, lodash_1.map)(enumArray, (value, index) => {
-                const enumKey = schemaObject['x-enum-varnames'][index];
-                return `${value}:"${schemaObject['x-enum-comments'][enumKey]}"`;
-            }).join(',')}}`;
-        }
-        else if ((_a = schemaObject === null || schemaObject === void 0 ? void 0 : schemaObject['x-apifox']) === null || _a === void 0 ? void 0 : _a['enumDescriptions']) {
-            enumLabelTypeStr = `{${(0, lodash_1.map)(enumArray, (value) => {
-                const enumLabel = schemaObject['x-apifox']['enumDescriptions'][value];
-                return `${value}:"${enumLabel}"`;
-            }).join(',')}}`;
-        }
-        else if (schemaObject === null || schemaObject === void 0 ? void 0 : schemaObject['x-apifox-enum']) {
-            enumLabelTypeStr = `{${(0, lodash_1.map)(enumArray, (value) => {
-                var _a;
-                const enumLabel = (_a = (0, lodash_1.find)(schemaObject['x-apifox-enum'], (item) => item.value === value)) === null || _a === void 0 ? void 0 : _a.description;
-                return `${value}:"${enumLabel}"`;
-            }).join(',')}}`;
-        }
-        else {
-            if (config_2.numberEnum.includes(schemaObject.type) || (0, util_2.isAllNumber)(enumArray)) {
-                if ((this.config.isSupportParseEnumDesc ||
-                    this.config.supportParseEnumDescByReg) &&
-                    schemaObject.description) {
-                    const enumMap = this.config.isSupportParseEnumDesc
-                        ? (0, util_2.parseDescriptionEnum)(schemaObject.description)
-                        : (0, util_2.parseDescriptionEnumByReg)(schemaObject.description, this.config.supportParseEnumDescByReg);
-                    enumLabelTypeStr = `{${(0, lodash_1.map)(enumArray, (value) => {
-                        const enumLabel = enumMap.get(Number(value));
-                        return `${Number(value)}:"${enumLabel}"`;
-                    }).join(',')}}`;
-                }
-                else {
-                    enumLabelTypeStr = `{${(0, lodash_1.map)(enumArray, (value) => `${Number(value) >= 0 ? Number(value) : `"${value}"`}:"NUMBER_${value}"`).join(',')}}`;
-                }
-            }
-            else if ((0, util_2.isAllNumeric)(enumArray)) {
-                enumLabelTypeStr = `{${(0, lodash_1.map)(enumArray, (value) => `"${value}":"STRING_NUMBER_${value}"`).join(',')}}`;
-            }
-            else {
-                enumLabelTypeStr = `{${(0, lodash_1.map)(enumArray, (value) => `"${value}":"${value}"`).join(',')}}`;
-            }
-        }
-        return {
-            isEnum: true,
-            type: Array.isArray(enumArray) ? enumStr : 'string',
-            enumLabelType: enumLabelTypeStr,
-            description: schemaObject.description,
-        };
+        return Helper.resolveEnumObject({
+            schemaObject,
+            config: {
+                isSupportParseEnumDesc: this.config.isSupportParseEnumDesc,
+                supportParseEnumDescByReg: this.config.supportParseEnumDescByReg,
+            },
+        });
     }
     resolveAllOfObject(schemaObject) {
-        const props = (0, lodash_1.map)(schemaObject.allOf, (item) => {
-            return (0, util_2.isReferenceObject)(item)
-                ? [Object.assign(Object.assign({}, item), { type: this.getType(item) })]
-                : this.getProps(item);
+        return Helper.resolveAllOfObject({
+            schemaObject,
+            getType: (schema, namespace) => this.getType(schema, namespace),
+            getProps: (schema) => this.getProps(schema),
         });
-        if (schemaObject.properties) {
-            const extProps = this.getProps(schemaObject);
-            return { props: [...props, extProps] };
-        }
-        return { props };
     }
     // 获取 TS 类型的属性列表
     getProps(schemaObject) {
-        var _a;
-        const requiredPropKeys = (_a = schemaObject === null || schemaObject === void 0 ? void 0 : schemaObject.required) !== null && _a !== void 0 ? _a : false;
-        const properties = schemaObject.properties;
-        return (0, lodash_1.keys)(properties).map((propKey) => {
-            const schema = ((properties === null || properties === void 0 ? void 0 : properties[propKey]) || config_2.DEFAULT_SCHEMA);
-            // 剔除属性键值中的特殊符号，因为函数入参变量存在特殊符号会导致解析文件失败
-            // eslint-disable-next-line no-useless-escape
-            propKey = propKey.replace(/[\[|\]]/g, '');
-            // 复用 schema 部分字段
-            return Object.assign(Object.assign({}, schema), { name: propKey, type: this.getType(schema), desc: [schema.title, schema.description]
-                    .filter((item) => item)
-                    .join(' ')
-                    .replace(config_2.lineBreakReg, ''), 
-                // 如果没有 required 信息，默认全部是非必填
-                required: requiredPropKeys
-                    ? requiredPropKeys.some((key) => key === propKey)
-                    : false });
+        return Helper.getProps({
+            schemaObject,
+            getType: (schema, namespace) => this.getType(schema, namespace),
+            openAPIData: this.openAPIData,
         });
     }
     resolveParameterRef(param) {
-        var _a, _b;
-        if (!(0, util_2.isReferenceObject)(param)) {
-            return param;
-        }
-        // 解析 $ref 引用，从 components.parameters 中获取实际定义
-        const refName = (0, util_2.getLastRefName)(param.$ref);
-        const parameter = (_b = (_a = this.openAPIData.components) === null || _a === void 0 ? void 0 : _a.parameters) === null || _b === void 0 ? void 0 : _b[refName];
-        return parameter || null;
+        return Helper.resolveParameterRef({
+            param,
+            openAPIData: this.openAPIData,
+        });
     }
     resolveRefObject(refObject) {
-        if (!(0, util_2.isReferenceObject)(refObject)) {
-            return refObject;
-        }
-        const refPaths = refObject.$ref.split('/');
-        if (refPaths[0] === '#') {
-            const schema = (0, util_2.resolveRefs)(this.openAPIData, refPaths.slice(1));
-            if (!schema) {
-                throw new Error(`[GenSDK] Data Error! Notfoud: ${refObject.$ref}`);
-            }
-            return Object.assign(Object.assign({}, (this.resolveRefObject(schema) || {})), { type: (0, util_2.isReferenceObject)(schema)
-                    ? this.resolveRefObject(schema).type
-                    : schema.type });
-        }
-        return refObject;
+        return Helper.resolveRefObject({
+            refObject,
+            openAPIData: this.openAPIData,
+            resolveRefObjectFunc: (params) => this.resolveRefObject(params.refObject),
+        });
     }
     log(message) {
         if (this.config.enableLogging) {
@@ -1175,5 +1082,78 @@ class ServiceGenerator {
         }
         return false; // 对于其他类型，返回 false
     }
+    /**
+     * 记录类型被某个模块使用
+     * @param typeName 类型名称
+     * @param moduleName 模块名称
+     */
+    markTypeUsedByModule(typeName, moduleName) {
+        if (!this.typeModuleMap.has(typeName)) {
+            this.typeModuleMap.set(typeName, new Set());
+        }
+        const moduleSet = this.typeModuleMap.get(typeName);
+        if (moduleSet) {
+            moduleSet.add(moduleName);
+        }
+    }
+    /**
+     * 获取模块需要导入的类型
+     * @param moduleTypes 模块类型列表
+     * @param commonTypes 公共类型列表
+     * @param enumTypes 枚举类型列表
+     * @returns 导入信息
+     */
+    getModuleImports(moduleTypes, commonTypes, enumTypes) {
+        return Helper.getModuleImports({
+            moduleTypes,
+            commonTypes,
+            enumTypes,
+        });
+    }
+    /**
+     * 分组类型：按模块、公共类型和枚举
+     * @returns 分组后的类型
+     */
+    groupTypesByModule() {
+        const moduleTypes = new Map();
+        const commonTypes = [];
+        const enumTypes = [];
+        // 初始化每个模块的类型数组
+        this.classNameList.forEach((controller) => {
+            moduleTypes.set(controller.fileName, []);
+        });
+        // 遍历所有类型，根据使用情况分组
+        this.interfaceTPConfigs.forEach((typeItem) => {
+            // 枚举类型单独处理，放入 enumTypes
+            if (typeItem.isEnum) {
+                enumTypes.push(typeItem);
+                return;
+            }
+            const modules = this.typeModuleMap.get(typeItem.typeName);
+            if (!modules || modules.size === 0) {
+                // 未被任何模块使用的类型，放入公共类型
+                commonTypes.push(typeItem);
+            }
+            else if (modules.size === 1) {
+                // 只被一个模块使用，放入该模块
+                const moduleName = Array.from(modules)[0];
+                const moduleTypeList = moduleTypes.get(moduleName);
+                if (moduleTypeList) {
+                    moduleTypeList.push(typeItem);
+                }
+                else {
+                    // 如果模块不存在（可能是因为过滤），放入公共类型
+                    commonTypes.push(typeItem);
+                }
+            }
+            else {
+                // 被多个模块使用，放入公共类型
+                commonTypes.push(typeItem);
+            }
+        });
+        // 处理公共类型的依赖：如果公共类型依赖某个模块类型，将该类型也移到公共类型
+        Helper.moveCommonTypeDependenciesToCommon({ moduleTypes, commonTypes });
+        return { moduleTypes, commonTypes, enumTypes };
+    }
 }
 exports.default = ServiceGenerator;