wormajs 0.0.2-beta.3 → 0.2.0

package/dist/plugins/presets/platform/shared.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeBase = normalizeBase;
+exports.defineUrlPlatformPlugin = defineUrlPlatformPlugin;
+exports.withCookie = withCookie;
+/** Remove trailing slashes from a base URL */
+function normalizeBase(baseUrl) {
+    while (baseUrl.endsWith('/')) {
+        baseUrl = baseUrl.slice(0, -1);
+    }
+    return baseUrl;
+}
+/**
+ * Factory for "URL-constructing" platform plugins.
+ *
+ * Unlike the old `platform()` helper, the platform base URL(s) are supplied as
+ * the plugin's own argument (e.g. `swagger('https://petstore.swagger.io')`)
+ * rather than being read from `config.input`. The plugin writes the resolved
+ * candidate URLs into `config.input` inside its `config` hook, so downstream
+ * fetching (which tries each URL in order and keeps the first success) works
+ * unchanged.
+ */
+function defineUrlPlatformPlugin(name, buildUrls) {
+    return (input) => {
+        const inputs = Array.isArray(input) ? [...new Set(input)] : [input];
+        return {
+            name,
+            config({ config }) {
+                config.input = inputs.flatMap(url => buildUrls(normalizeBase(String(url))));
+                return config;
+            },
+        };
+    };
+}
+/** Merge a cookie into config.fetchOptions.headers */
+function withCookie(config, cookie) {
+    config.fetchOptions = {
+        ...config.fetchOptions,
+        headers: {
+            ...config.fetchOptions?.headers,
+            cookie,
+        },
+    };
+    return config;
+}

package/dist/plugins/presets/platform/swagger.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.swagger = void 0;
+const constant_1 = require("../../../constant");
+const shared_1 = require("./shared");
+/**
+ * Swagger platform plugin.
+ *
+ * Pass the base URL of your Swagger UI / server; the plugin will try several
+ * common OpenAPI document endpoints (OAS3 first, then Swagger2, then the bare
+ * base URL) and let the framework pick the first one that responds.
+ *
+ * @param input - base URL string, or an array of base URLs
+ *
+ * @example
+ * ```ts
+ * import { swagger, alovaGlobals } from 'wormajs/plugin';
+ *
+ * defineConfig({
+ *   generator: [{
+ *     plugins: [swagger('https://petstore3.swagger.io'), alovaGlobals()],
+ *     output: './src/api',
+ *   }]
+ * });
+ * ```
+ */
+exports.swagger = (0, shared_1.defineUrlPlatformPlugin)(constant_1.PluginName.SWAGGER, base => [
+    `${base}/openapi.json`,
+    `${base}/v2/swagger.json`,
+    `${base}/api/v3/openapi.json`,
+    base,
+]);

package/dist/plugins/presets/platform/yapi.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yapi = yapi;
+const constant_1 = require("../../../constant");
+const shared_1 = require("./shared");
+/**
+ * YApi platform plugin.
+ *
+ * YApi projects are private, so the OpenAPI document must be exported through
+ * YApi's own export endpoint, authenticated with your login cookie. The plugin
+ * builds the export URL from the server base URL (`url`) plus the required
+ * `pid` and the optional `type` / `status` / `isWiki` query params (which
+ * default to `OpenAPIV2`, `all`, and `true` respectively).
+ *
+ * `url`, `pid` and `cookie` are required — the plugin throws a clear error when
+ * any is missing.
+ *
+ * @param options - `{ url, pid, cookie?, type?, status?, isWiki?, timeout? }`
+ *
+ * @example
+ * ```ts
+ * import { yapi, alovaGlobals } from 'wormajs/plugin';
+ *
+ * defineConfig({
+ *   generator: [{
+ *     plugins: [
+ *       yapi({
+ *         url: 'https://yapi.xxx.com',
+ *         pid: 123,
+ *         cookie: '_yapi_token=xxx; _yapi_uid=yyy',
+ *       }),
+ *       alovaGlobals(),
+ *     ],
+ *     output: './src/api',
+ *   }]
+ * });
+ * ```
+ */
+function yapi(options) {
+    return {
+        name: constant_1.PluginName.YAPI,
+        async config({ config }) {
+            const baseUrl = options.url;
+            if (!baseUrl) {
+                throw new Error('[yapi] `url` is required — the YApi server base URL '
+                    + '(e.g. yapi({ url: "https://yapi.xxx.com", pid: 123, cookie: "..." })).');
+            }
+            const pid = options.pid;
+            if (pid == null) {
+                throw new Error('[yapi] `pid` is required — the YApi project id used to build the export URL '
+                    + '(e.g. yapi({ url: "https://yapi.xxx.com", pid: 123, cookie: "..." })).');
+            }
+            const cookie = options.cookie ?? config.fetchOptions?.headers?.cookie;
+            if (!cookie) {
+                throw new Error('[yapi] `cookie` is required. YApi projects are private, so the export '
+                    + 'endpoint needs your login cookie to fetch the OpenAPI document.\n'
+                    + '  e.g. yapi({ url: "https://yapi.xxx.com", pid: 123, cookie: "_yapi_token=xxx; ..." })');
+            }
+            const type = options.type ?? 'OpenAPIV2';
+            const status = options.status ?? 'all';
+            const isWiki = options.isWiki ?? true;
+            const base = (0, shared_1.normalizeBase)(baseUrl);
+            config.input = `${base}/api/plugin/exportSwagger`
+                + `?type=${encodeURIComponent(type)}`
+                + `&pid=${encodeURIComponent(String(pid))}`
+                + `&status=${encodeURIComponent(status)}`
+                + `&isWiki=${isWiki}`;
+            (0, shared_1.withCookie)(config, cookie);
+            if (options.timeout != null) {
+                config.fetchOptions = { ...config.fetchOptions, timeout: options.timeout };
+            }
+            return config;
+        },
+    };
+}

package/dist/plugins/presets/rename.js

@@ -27,8 +27,12 @@ function toPascalCase(str) {
  * Applies renaming rules to the specified value
  * @returns The renamed value, or original value if not matched
  */
-function applyRenameRule(value, config, apiDescriptor) {
-    if (!(0, utils_1.isMatch)(value, config.match)) {
+function applyRenameRule(value, config, apiDescriptor, level = 0) {
+    // Skip non-string values (e.g. a missing or empty operationId) to avoid runtime errors
+    if (typeof value !== 'string') {
+        return value;
+    }
+    if (!(0, utils_1.isMatch)(value, config.match, level)) {
         return value;
     }
     if (config.transform) {
@@ -38,7 +42,7 @@ function applyRenameRule(value, config, apiDescriptor) {
         return value;
     }
     if (config.style === 'kebabCase' && config.scope === 'refName') {
-        throw new Error(`Invalid rename style: ${config.style}、${config.scope}`);
+        throw new Error(`Invalid rename style: ${config.style}, ${config.scope}`);
     }
     switch (config.style) {
         case 'camelCase':
@@ -53,6 +57,59 @@ function applyRenameRule(value, config, apiDescriptor) {
             throw new Error(`Invalid rename style: ${config.style}`);
     }
 }
+/**
+ * Validates that no duplicate names exist after renaming.
+ * Throws an error with details if duplicates are found within the same scope.
+ *
+ * @param names the renamed names to check for duplicates
+ * @param scopeLabel used to identify the scope in the error message
+ * @param apiDescriptor the API descriptor the names belong to
+ * @param originalNames optional, the original keys before renaming (same order
+ *   as `names`). When provided, the error message also lists which original keys
+ *   were mapped to each duplicated name, making the conflict easier to locate.
+ */
+function assertNoDuplicates(names, scopeLabel, apiDescriptor, originalNames) {
+    if (!names || names.length === 0)
+        return;
+    const counts = new Map();
+    for (const name of names) {
+        counts.set(name, (counts.get(name) ?? 0) + 1);
+    }
+    const duplicates = [...counts.entries()]
+        .filter(([, count]) => count > 1)
+        .map(([name]) => name);
+    if (duplicates.length === 0)
+        return;
+    // When original keys are available, group them by the duplicated (renamed) name
+    // so users can see exactly which keys collided.
+    let detail = '';
+    if (originalNames && originalNames.length === names.length) {
+        const grouped = new Map();
+        for (let i = 0; i < names.length; i++) {
+            if (duplicates.includes(names[i])) {
+                const list = grouped.get(names[i]) ?? [];
+                list.push(originalNames[i]);
+                grouped.set(names[i], list);
+            }
+        }
+        detail = [...grouped.entries()]
+            .map(([renamed, originals]) => `    ${renamed} <- [${originals.join(', ')}]`)
+            .join('\n');
+    }
+    else {
+        detail = `    ${duplicates.join(', ')}`;
+    }
+    const method = apiDescriptor.method ? String(apiDescriptor.method).toUpperCase() : '';
+    const url = apiDescriptor.url ?? '';
+    throw new Error(`[rename] Duplicate names found after renaming (scope=${scopeLabel}):\n`
+        + `  Conflicting (renamed) keys and their original keys:\n`
+        + `${detail}\n`
+        + `  Reason: different original names were mapped to the same name after `
+        + `match/transform/style processing, which would cause naming conflicts or `
+        + `missing references in the generated code.\n`
+        + `  Please adjust the rename config to avoid mapping multiple names to the same result.\n`
+        + `  API: ${method} ${url}`);
+}
 /**
  * renames URL path by processing each segment individually
  * while keeping path parameter placeholders
@@ -65,27 +122,77 @@ function renameUrl(url, config, apiDescriptor) {
         if ((segment.startsWith('{') && segment.endsWith('}')) || !segment) {
             return segment;
         }
-        return applyRenameRule(segment, config, apiDescriptor);
+        return applyRenameRule(segment, config, apiDescriptor, 0);
     })
         .join('/')
         .replace(/^\/{2,}/g, '/');
 }
 /**
- * Transforms object properties using the renaming rules
+ * Recursively processes a schema (supports nested objects and arrays),
+ * applying property renaming to nested objects.
+ * @param schema current schema
+ * @param config rename configuration
+ * @param apiDescriptor API descriptor
+ * @param level current nesting level (starts from 0)
+ * @param scopeLabel used to identify the scope in duplicate-name errors
+ */
+function transformSchema(schema, config, apiDescriptor, level, scopeLabel) {
+    if (!schema || typeof schema !== 'object')
+        return schema;
+    // Nested object: recursively process its properties
+    if ('properties' in schema && schema.properties) {
+        return transformProperties(schema, config, apiDescriptor, level, scopeLabel);
+    }
+    // Array: recursively process items (supports a single schema or an array of schemas)
+    if (schema.items && typeof schema.items === 'object') {
+        if (Array.isArray(schema.items)) {
+            return {
+                ...schema,
+                items: schema.items.map((item) => transformSchema(item, config, apiDescriptor, level, scopeLabel)),
+            };
+        }
+        return {
+            ...schema,
+            items: transformSchema(schema.items, config, apiDescriptor, level, scopeLabel),
+        };
+    }
+    return schema;
+}
+/**
+ * Transforms object properties using the renaming rules (supports deep recursive renaming)
+ * @param obj object whose properties to transform
+ * @param config rename configuration
+ * @param apiDescriptor API descriptor
+ * @param level current nesting level (starts from 0), passed through to the match function
+ * @param scopeLabel used to identify the scope in duplicate-name errors
  */
-function transformProperties(obj, config, apiDescriptor) {
-    if (!obj || typeof obj !== 'object' || !('properties' in obj)) {
+function transformProperties(obj, config, apiDescriptor, level = 0, scopeLabel = config.scope ?? 'data') {
+    if (!obj || typeof obj !== 'object' || !('properties' in obj) || !obj.properties) {
         return obj;
     }
-    const properties = { ...obj.properties };
+    const properties = obj.properties;
     const newProperties = {};
+    const newKeys = [];
+    // Record the oldKey -> newKey mapping, used to keep the same-level required array in sync
+    const keyMap = new Map();
     for (const key in properties) {
-        const newKey = applyRenameRule(key, config, apiDescriptor);
-        newProperties[newKey] = properties[key];
+        const newKey = applyRenameRule(key, config, apiDescriptor, level);
+        newKeys.push(newKey);
+        keyMap.set(key, newKey);
+        newProperties[newKey] = transformSchema(properties[key], config, apiDescriptor, level + 1, scopeLabel);
+    }
+    // Duplicate property names within the same object level would overwrite each other, so report an error
+    assertNoDuplicates(newKeys, scopeLabel, apiDescriptor, Object.keys(properties));
+    // Keep the required array of the current level in sync with the renamed property names;
+    // otherwise the generator would crash during normalization because required references a non-existent property
+    let newRequired = obj.required;
+    if (Array.isArray(newRequired)) {
+        newRequired = newRequired.map((r) => keyMap.get(r) ?? r);
     }
     return {
         ...obj,
         properties: newProperties,
+        ...(newRequired !== obj.required ? { required: newRequired } : {}),
     };
 }
 /**
@@ -99,7 +206,7 @@ function transformParameters(parameters, type, config, apiDescriptor) {
         if (param.in === type) {
             return {
                 ...param,
-                name: applyRenameRule(param.name, config, apiDescriptor),
+                name: applyRenameRule(param.name, config, apiDescriptor, 0),
             };
         }
         return param;
@@ -110,10 +217,14 @@ function transformRefNameMap(refNameMap, config, apiDescriptor) {
         return refNameMap;
     }
     const newRefNameMap = {};
+    const newValues = [];
     for (const key in refNameMap) {
-        const newValue = applyRenameRule(refNameMap[key], config, apiDescriptor);
+        const newValue = applyRenameRule(refNameMap[key], config, apiDescriptor, 0);
+        newValues.push(newValue);
         newRefNameMap[key] = newValue;
     }
+    // Different $refs mapping to the same type name would generate duplicate interfaces, so report an error
+    assertNoDuplicates(newValues, 'refName', apiDescriptor, Object.keys(refNameMap));
     return newRefNameMap;
 }
 /**
@@ -125,6 +236,7 @@ function transformRefNameMap(refNameMap, config, apiDescriptor) {
  * - pathParams: Renames path parameters and their placeholders in URL
  * - data: Renames request body properties
  * - response: Renames response body properties
+ * - name: Renames the generated API function name (operationId)
  */
 function renameApiDescriptor(apiDescriptor, config) {
     if (!apiDescriptor)
@@ -134,33 +246,49 @@ function renameApiDescriptor(apiDescriptor, config) {
     switch (scope) {
         case constant_1.RenameScope.PARAMS:
             if (newDescriptor.parameters) {
+                const originalParams = newDescriptor.parameters.filter(p => p.in === constant_1.ParameterIn.QUERY).map(p => p.name);
                 newDescriptor.parameters = transformParameters(newDescriptor.parameters, constant_1.ParameterIn.QUERY, config, apiDescriptor);
+                // Duplicate query parameter names would be indistinguishable when calling the API, so report an error
+                assertNoDuplicates(newDescriptor.parameters.filter(p => p.in === constant_1.ParameterIn.QUERY).map(p => p.name), 'params', apiDescriptor, originalParams);
             }
             break;
         case constant_1.RenameScope.PATH_PARAMS:
             if (newDescriptor.parameters) {
+                const originalParams = newDescriptor.parameters.filter(p => p.in === constant_1.ParameterIn.PATH).map(p => p.name);
                 newDescriptor.parameters = transformParameters(newDescriptor.parameters, constant_1.ParameterIn.PATH, config, apiDescriptor);
-            }
-            if (newDescriptor.url) {
-                newDescriptor.url = newDescriptor.url.replace(/\{([^}]+)\}/g, (match, paramName) => {
-                    const newName = applyRenameRule(paramName, config, apiDescriptor);
-                    return `{${newName}}`;
-                });
+                if (newDescriptor.url) {
+                    newDescriptor.url = newDescriptor.url.replace(/\{([^}]+)\}/g, (match, paramName) => {
+                        const newName = applyRenameRule(paramName, config, apiDescriptor, 0);
+                        return `{${newName}}`;
+                    });
+                }
+                // Duplicate path parameter names would make URL placeholders no longer match the parameters, so report an error
+                assertNoDuplicates((newDescriptor.parameters ?? []).filter(p => p.in === constant_1.ParameterIn.PATH).map(p => p.name), 'pathParams', apiDescriptor, originalParams);
             }
             break;
         case constant_1.RenameScope.DATA:
             if (newDescriptor.requestBody) {
-                newDescriptor.requestBody = transformProperties(newDescriptor.requestBody, config, apiDescriptor);
+                newDescriptor.requestBody = transformProperties(newDescriptor.requestBody, config, apiDescriptor, 0, 'data');
             }
             break;
         case constant_1.RenameScope.RESPONSE:
             if (newDescriptor.responses) {
-                newDescriptor.responses = transformProperties(newDescriptor.responses, config, apiDescriptor);
+                newDescriptor.responses = transformProperties(newDescriptor.responses, config, apiDescriptor, 0, 'response');
             }
             break;
         case constant_1.RenameScope.URL:
             if (newDescriptor.url) {
+                const originalUrlNames = newDescriptor.url
+                    .split('/')
+                    .filter(Boolean)
+                    .map(segment => (segment.startsWith('{') && segment.endsWith('}') ? segment.slice(1, -1) : segment));
                 newDescriptor.url = renameUrl(newDescriptor.url, config, apiDescriptor);
+                // Duplicate path segments would make the URL unable to distinguish different resources, so report an error
+                const urlNames = newDescriptor.url
+                    .split('/')
+                    .filter(Boolean)
+                    .map(segment => (segment.startsWith('{') && segment.endsWith('}') ? segment.slice(1, -1) : segment));
+                assertNoDuplicates(urlNames, 'url', apiDescriptor, originalUrlNames);
             }
             break;
         case constant_1.RenameScope.REF_NAME:
@@ -168,6 +296,11 @@ function renameApiDescriptor(apiDescriptor, config) {
                 newDescriptor.refNameMap = transformRefNameMap(newDescriptor.refNameMap, config, apiDescriptor);
             }
             break;
+        case constant_1.RenameScope.NAME:
+            if (newDescriptor.operationId != null) {
+                newDescriptor.operationId = applyRenameRule(newDescriptor.operationId, config, apiDescriptor, 0);
+            }
+            break;
         default:
             // No action needed, keep original descriptor
             break;
@@ -185,7 +318,7 @@ function rename(config) {
             throw new Error('at least one of `style` or `transform` is required');
         }
         if (conf.style === 'kebabCase' && conf.scope === 'refName') {
-            throw new Error(`Invalid rename style: ${conf.style}、${conf.scope}`);
+            throw new Error(`Invalid rename style: ${conf.style}, ${conf.scope}`);
         }
     }
     return {

package/dist/plugins/presets/tagModifier.js

@@ -38,6 +38,10 @@ function processApiTags(apiDescriptor, handler) {
     // Process each tag and filter out null/undefined results
     newDescriptor.tags = newDescriptor.tags
         .map((tag) => {
+        // Resolve the tag to keep when the modification cannot be applied:
+        // keep the original tag only if it is itself valid, otherwise drop it.
+        // This guarantees that the final output never contains an invalid tag.
+        const keepOriginalOrDrop = () => isValidTagName(tag) ? tag : null;
         try {
             // Call user provided handler function
             const modifiedTag = handler(tag);
@@ -47,12 +51,12 @@ function processApiTags(apiDescriptor, handler) {
             }
             // Validate if modified tag follows naming conventions
             if (!isValidTagName(modifiedTag)) {
-                return tag; // Keep original tag if invalid
+                return keepOriginalOrDrop(); // Keep original tag if valid, otherwise drop
             }
             return modifiedTag.trim(); // Return trimmed modified tag
         }
         catch {
-            return tag; // Return original tag on error
+            return keepOriginalOrDrop(); // Keep original tag if valid, otherwise drop on error
         }
     })
         .filter((tag) => tag != null); // Filter out null/undefined values

package/dist/plugins/presets/utils.js

@@ -4,23 +4,24 @@ exports.extend = extend;
 exports.isMatch = isMatch;
 const prepareConfig_1 = require("../../functions/prepareConfig");
 /**
- * 扩展生成器配置：
- * 根据传入的 newConfig（对象或函数）与基础 config 生成合并后的配置。
- * 当未提供 newConfig 时，直接回退到原始 config。
- * @param config 基础配置
- * @param newConfig 需要扩展的配置或用于生成扩展配置的函数
- * @returns 合并且标准化后的配置
+ * Extends the generator configuration:
+ * merges the provided newConfig (object or function) with the base config to produce the merged config.
+ * When newConfig is not provided, falls back to the original config.
+ * @param config base configuration
+ * @param newConfig config to merge, or a function that produces the merged config
+ * @returns the merged and normalized configuration
  */
 function extend(config, newConfig) {
-    // 根据 newConfig 类型计算扩展配置：函数则调用生成配置，否则直接使用对象；未提供则回退到原始 config
+    // Compute the extension config based on newConfig's type: call it if it's a function,
+    // otherwise use it directly; fall back to the original config if not provided
     const pluginExtendsConfig = typeof newConfig === 'function' ? newConfig(config) : (newConfig ?? config);
-    // 使用 extendsConfig 进行配置合并与标准化，确保最终结构满足生成器需求
+    // Use extendsConfig to merge and normalize, ensuring the final structure meets the generator's requirements
     return (0, prepareConfig_1.extendsConfig)(config, pluginExtendsConfig);
 }
 /**
  * Tests if value matches the specified rule
  */
-function isMatch(value, match) {
+function isMatch(value, match, level = 0) {
     if (!match)
         return true;
     if (typeof match === 'string') {
@@ -30,7 +31,7 @@ function isMatch(value, match) {
         return match.test(value);
     }
     if (typeof match === 'function') {
-        return match(value);
+        return match(value, level);
     }
     return false;
 }

package/dist/template/index.js

@@ -4,7 +4,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPresetTemplatePath = getPresetTemplatePath;
-exports.registerProcessTypeHelper = registerProcessTypeHelper;
 exports.config = config;
 exports.alovaGlobals = alovaGlobals;
 exports.alova = alova;
@@ -21,27 +20,6 @@ function getPresetTemplatePath(presetName) {
     // 编译后在 dist/template/presets 目录
     return node_path_1.default.join(__dirname, 'presets', presetName);
 }
-/**
- * Register processType helper on an hbs instance.
- *
- * Scans the type string for every PascalCase identifier that is in componentNames
- * (and not already prefixed with "ComponentTypes.") and prefixes it.
- * Works uniformly for top-level names, generics, object literals, and arrays.
- */
-function registerProcessTypeHelper(hbs) {
-    hbs.registerHelper('processType', (_typeStr, _componentNames) => {
-        const typeStr = _typeStr;
-        const componentNames = _componentNames;
-        if (!typeStr || !Array.isArray(componentNames) || componentNames.length === 0) {
-            return new hbs.SafeString(typeStr || 'unknown');
-        }
-        const componentSet = new Set(componentNames);
-        const result = typeStr.replace(/(?<!ComponentTypes\.)(\b[A-Z]\w*\b)/g, (match) => {
-            return componentSet.has(match) ? `ComponentTypes.${match}` : match;
-        });
-        return new hbs.SafeString(result);
-    });
-}
 // ========== Template Preset Plugins ==========
 /**
  * worma.config 模板预设 - plugin mode
@@ -100,9 +78,6 @@ function alova(opts) {
         getTemplate() {
             return { path: getPresetTemplatePath(constant_1.PresetTemplateName.ALOVA) };
         },
-        onHandlebarsCreated({ hbs }) {
-            registerProcessTypeHelper(hbs);
-        },
         beforeCodeGenerate({ data }) {
             data.config = {
                 ...data.config,
@@ -122,9 +97,6 @@ function axios(opts) {
         getTemplate() {
             return { path: getPresetTemplatePath(constant_1.PresetTemplateName.AXIOS) };
         },
-        onHandlebarsCreated({ hbs }) {
-            registerProcessTypeHelper(hbs);
-        },
         beforeCodeGenerate({ data }) {
             data.config = {
                 ...data.config,
@@ -144,9 +116,6 @@ function fetch(opts) {
         getTemplate() {
             return { path: getPresetTemplatePath(constant_1.PresetTemplateName.FETCH) };
         },
-        onHandlebarsCreated({ hbs }) {
-            registerProcessTypeHelper(hbs);
-        },
         beforeCodeGenerate({ data }) {
             data.config = {
                 ...data.config,
@@ -166,9 +135,6 @@ function ky(opts) {
         getTemplate() {
             return { path: getPresetTemplatePath(constant_1.PresetTemplateName.KY) };
         },
-        onHandlebarsCreated({ hbs }) {
-            registerProcessTypeHelper(hbs);
-        },
         beforeCodeGenerate({ data }) {
             data.config = {
                 ...data.config,

package/dist/template/presets/alova/partials/dts-extra-config.handlebars

@@ -1,8 +1,8 @@
 {{#or pathParameters queryParameters requestBody}}
 type {{{name}}}ExtraConfig = {
-  {{#if pathParameters}}pathParams: {{processType pathParameters @root.componentNames}};
-  {{/if}}{{#if queryParameters}}params: {{processType queryParameters @root.componentNames}};
-  {{/if}}{{#if requestBody}}data: {{processType requestBody @root.componentNames}};
+  {{#if pathParameters}}pathParams: {{addNamespace pathParameters @root.componentNames}};
+  {{/if}}{{#if queryParameters}}params: {{addNamespace queryParameters @root.componentNames}};
+  {{/if}}{{#if requestBody}}data: {{addNamespace requestBody @root.componentNames}};
   {{/if}}
 };
 {{/or}}

package/dist/template/presets/alova/partials/dts-fn-declare.handlebars

@@ -1 +1 @@
-export declare function {{{name}}}<Config extends Alova2MethodConfig<{{processType response @root.componentNames}}> & {{{name}}}ExtraConfig>(config: Config): Alova2Method<ExtractResponded<Config, '{{{name}}}', {{processType response @root.componentNames}}>>;
+export declare function {{{name}}}<Config extends Alova2MethodConfig<{{addNamespace response @root.componentNames}}> & {{{name}}}ExtraConfig>(config: Config): Alova2Method<ExtractResponded<Config, '{{{name}}}', {{addNamespace response @root.componentNames}}>>;

package/dist/template/presets/alova/typescript/services/{tag}.ts.handlebars

@@ -12,15 +12,15 @@ import type * as ComponentTypes from '../components';
 {{#each apis}}
 
 interface {{{name}}}ExtraConfig {
-  {{#if pathParameters}}pathParams: {{processType pathParameters @root.componentNames}};
-  {{/if}}{{#if queryParameters}}params: {{processType queryParameters @root.componentNames}};
-  {{/if}}{{#if requestBody}}data: {{processType requestBody @root.componentNames}};
+  {{#if pathParameters}}pathParams: {{addNamespace pathParameters @root.componentNames}};
+  {{/if}}{{#if queryParameters}}params: {{addNamespace queryParameters @root.componentNames}};
+  {{/if}}{{#if requestBody}}data: {{addNamespace requestBody @root.componentNames}};
   {{/if}}
 }
 {{> api-jsdoc}}
-export function {{{name}}}<Config extends Alova2MethodConfig<{{processType response @root.componentNames}}> & {{{name}}}ExtraConfig>(config: Config): Alova2Method<ExtractResponded<Config, '{{{name}}}', {{processType response @root.componentNames}}>> {
+export function {{{name}}}<Config extends Alova2MethodConfig<{{addNamespace response @root.componentNames}}> & {{{name}}}ExtraConfig>(config: Config): Alova2Method<ExtractResponded<Config, '{{{name}}}', {{addNamespace response @root.componentNames}}>> {
   const { url, data, mergedConfig } = buildPayload('{{{path}}}', {{{tag}}}DefaultConfig, {{{name}}}.name, config);
-  return alovaInstance.Request<ExtractResponded<Config, '{{{name}}}', {{processType response @root.componentNames}}>>({
+  return alovaInstance.Request<ExtractResponded<Config, '{{{name}}}', {{addNamespace response @root.componentNames}}>>({
     ...mergedConfig,
     url,
     data,

package/dist/template/presets/axios/partials/dts-types.handlebars

@@ -1,7 +1,7 @@
-type {{{name}}}Response = {{processType response @root.componentNames}};
+type {{{name}}}Response = {{addNamespace response @root.componentNames}};
 type {{{name}}}ExtraConfig = Omit<AxiosRequestConfig, 'data' | 'params'> & {
-  {{#if pathParameters}}pathParams: {{processType pathParameters @root.componentNames}};
-  {{/if}}{{#if queryParameters}}params: {{processType queryParameters @root.componentNames}};
-  {{/if}}{{#if requestBody}}data: {{processType requestBody @root.componentNames}};
+  {{#if pathParameters}}pathParams: {{addNamespace pathParameters @root.componentNames}};
+  {{/if}}{{#if queryParameters}}params: {{addNamespace queryParameters @root.componentNames}};
+  {{/if}}{{#if requestBody}}data: {{addNamespace requestBody @root.componentNames}};
   {{/if}}
 };

package/dist/template/presets/axios/typescript/services/{tag}.ts.handlebars

@@ -9,11 +9,11 @@ import { {{{tagName}}}DefaultConfig } from '.';
 
 {{#each tagedApis}}
 {{#each apis}}
-type {{{name}}}Response = {{processType response @root.componentNames}};
+type {{{name}}}Response = {{addNamespace response @root.componentNames}};
 type {{{name}}}ExtraConfig = Omit<AxiosRequestConfig, 'data' | 'params'> & {
-  {{#if pathParameters}}pathParams: {{processType pathParameters @root.componentNames}};
-  {{/if}}{{#if queryParameters}}params: {{processType queryParameters @root.componentNames}};
-  {{/if}}{{#if requestBody}}data: {{processType requestBody @root.componentNames}};
+  {{#if pathParameters}}pathParams: {{addNamespace pathParameters @root.componentNames}};
+  {{/if}}{{#if queryParameters}}params: {{addNamespace queryParameters @root.componentNames}};
+  {{/if}}{{#if requestBody}}data: {{addNamespace requestBody @root.componentNames}};
   {{/if}}
 };
 {{> api-jsdoc}}

package/dist/template/presets/config/common/worma.config.js.handlebars

@@ -1,5 +1,5 @@
 const { defineConfig } = require('wormajs');
-const { platform, aiDoc{{#if templateImport}}, {{{templateImport}}}{{/if}} } = require('wormajs/plugin');
+const { swagger, aiDoc{{#if templateImport}}, {{{templateImport}}}{{/if}} } = require('wormajs/plugin');
 
 // For more config detailed visit:
 // https://github.com/alovajs/devtools