gen-api-types 1.0.14 → 1.0.17

package/README.en.md

@@ -10,8 +10,9 @@ With this tool, we can mark request interface classes and methods through TypeSc
 
 > Note:
 >
-> 1. Because this tool uses TypeScript decorators, and decorators currently (TypeScript 5.0) do not support decorating plain functions directly, APIs must be written as **API classes + static API methods**.
-> 2. This tool needs to dynamically execute TypeScript code (importing API classes and calling the marked static API methods), so it runs through the bundled `tsx` dependency. No global `tsx` installation is required.
+> 1. Because this tool uses TypeScript method decorators, APIs must be written as **API classes + API methods**.
+> 2. The CLI dynamically imports and executes marked API modules through the project's bundled `tsx` runtime. No global `tsx` installation is required.
+> 3. API methods are executed for real in the CLI process. Make sure required environment variables, network access, and authentication are available.
 
 #### Installation
 
@@ -23,14 +24,17 @@ npm install gen-api-types -D
 
 #### Usage
 
-##### 1. Mark interface class names and methods
+##### 1. Mark API classes and methods
 
 ```ts
 import { gen_type_c, gen_type_m } from 'gen-api-types'
 
 @gen_type_c()
 export class TestApi {
-	@gen_type_m({ args: [100], typeName: 'XXX' })
+	@gen_type_m({
+		args: [100],
+		typeName: 'XXX',
+	})
 	static async getList(id: number): Promise<XXX> {
 		return asleep(1000).then(() => {
 			return { name: 'zs', id }
@@ -38,7 +42,7 @@ export class TestApi {
 	}
 
 	@gen_type_m()
-	static getWeather(): Promise<Response_TestApi_getWeather> {
+	getWeather(): Promise<Response_TestApi_getWeather> {
 		return fetch('http://t.weather.sojson.com/api/weather/city/101030100').then(r => r.json())
 	}
 }
@@ -46,14 +50,26 @@ export class TestApi {
 
 As shown in the code above:
 
-- `@gen_type_c` decorator function is used to mark interface classes. Since the tool dynamically analyzes all ts files in the specified directory, marking interface classes helps quickly locate them.
-- `@gen_type_m` decorator function marks the request methods that need to be converted. It can accept a configuration object with two fields:
-  1. `typeName: string` Interface return type name. If not specified, the default name will be: `Response_${ClassName}_${MethodName}`
-  2. `args: any[]` Method parameter list. The tool will pass this list when calling the request method.
+- `@gen_type_c()` marks an API class.
+- `@gen_type_m()` marks a method to execute and convert.
+- `args: any[]` contains the arguments passed to the method. Both static and non-static methods are supported.
+- `typeName: string` is the generated type name. If omitted, it defaults to `Response_${ClassName}_${MethodName}`.
+- Prefer the exported `gen_type_c` and `gen_type_m` aliases. `GatDecorator` is the internal container used for constant-based decorator names and is not required in business code.
+
+Decorator options may span multiple lines:
+
+```ts
+@gen_type_m({
+	args: [100],
+	typeName: 'XXX'
+})
+```
 
 > Note:
 
-If TypeScript reports the decorator error: "The runtime will invoke the decorator with 2 arguments, but the decorator expects 3", set `compilerOptions.experimentalDecorators` to `true` in tsconfig.
+If TypeScript reports the decorator error "The runtime will invoke the decorator with 2 arguments, but the decorator expects 3", set `compilerOptions.experimentalDecorators` to `true` in `tsconfig.json`.
+
+The CLI currently applies a 3-second execution timeout to each API method. Timeouts, synchronous exceptions, and rejected promises are reported as execution failures. A timeout stops waiting for the result but cannot cancel an underlying request that has already started.
 
 ##### 2. Execute command
 
@@ -85,18 +101,18 @@ You can also use it by configuring scripts in package.json:
 }
 ```
 
+The CLI scans `.ts` files in the input directories, finds marked classes and methods, and dynamically imports the modules containing them. The decorators execute the API methods during module import; the declaration file is generated after all marked methods finish.
+
 Command output:
 
 ```shell
 🚀 Start generating API types...
 sourceFilesGlob [ 'src\\**\\*.ts' ]
-📋 Processing UserApi.getList ...
-📋 Processing UserApi.getWeather ...
 Request results:
   ┌────────────────┬──────────────────────────────────────┐
   │ (index)        │ Values                               │
   ├────────────────┼──────────────────────────────────────┤
-  │ ✔️ successList │ 'UserApi.getList UserApi.getWeather' │
+  │ ✔️ successList │ 'TestApi.getList TestApi.getWeather' │
   │ ❌ errorList   │ ''                                   │
   └────────────────┴──────────────────────────────────────┘
 ✅ API type generation completed
@@ -147,3 +163,48 @@ Generated output example:
 export type XXX = { name: string };
 export type Response_TestApi_getWeather = {...}
 ```
+
+##### 4. Vite plugin
+
+Decorators are needed for type generation, but they normally should not execute when the business application runs or builds. In a Vite project, use the plugin to remove `gen_type_c` and `gen_type_m` from the transformed business code:
+
+```ts
+// vite.config.ts
+import { defineConfig } from 'vite'
+import { removeGatDecorators } from 'gen-api-types'
+
+export default defineConfig({
+	plugins: [removeGatDecorators()],
+})
+```
+
+The plugin processes `.ts` and `.tsx` files and supports single-line and multi-line decorator options. Use the `gen_type_c` and `gen_type_m` aliases in business code; direct `GatDecorator.gen_type_m()` calls do not match the plugin's current decorator names.
+
+The Vite plugin only affects Vite's transform pipeline. It is not involved when the CLI imports and executes API modules.
+
+#### VS Code Extension
+
+If you use `gen-api-types` in VS Code, you can install the companion extension [gen-api-types-vsce](https://github.com/xuejiangping/gen-api-types-vsce) to generate API return types from the context menu.
+
+![alt text](docs/images/image.png)
+
+The extension does not bundle the CLI. It invokes the version of `gen-api-types` installed locally in the current project.
+
+After installing the extension, right-click in a `.ts` or `.tsx` file containing the decorated APIs and select `Generate API Return Types (gen-api-types)`. By default, the extension will:
+
+- Use the directory containing the current TypeScript file as the `api_dirs` argument
+- Generate the type file in the same directory as the current TypeScript file
+- Use `api-types.d.ts` as the default output file name
+- Ask for confirmation before overwriting an existing output file
+
+You can configure the CLI arguments in the VS Code settings:
+
+| Extension setting            | CLI argument           | Default behavior                                      |
+| ---------------------------- | ---------------------- | ----------------------------------------------------- |
+| `gen-api-types.projectRoot`  | `-r, --project_root`   | Workspace root containing the current TypeScript file |
+| `gen-api-types.outputFile`   | `-O, --output_file`    | `api-types.d.ts`                                      |
+| `gen-api-types.outputDir`    | `-o, --output_dir`     | Directory containing the current TypeScript file      |
+| `gen-api-types.tsConfigPath` | `-t, --ts_config_path` | Not passed; the CLI uses its default value            |
+| `gen-api-types.isExported`   | `--isExported`         | `false`                                               |
+
+The extension is essentially a VS Code entry point for the CLI. Type analysis, API execution, and type-file generation are still handled by `gen-api-types`.

package/README.md

@@ -10,8 +10,9 @@
 
 > 注意：
 >
-> 1. 由于需要使用到ts装饰器特性，而装饰器目前（ts 5.0）不支持直接标记普通函数，所以我们的接口必须以 **接口类+静态api方法** 的形式书写
-> 2. 该工具需要动态执行 ts 代码（import接口类，然后调用标记的静态api方法），因此会通过内置依赖的 `tsx` 执行工具运行，无需额外全局安装 `tsx`。
+> 1. 由于需要使用 TypeScript 方法装饰器，接口需要以 **API 类 + API 方法** 的形式书写。
+> 2. CLI 会动态导入并执行标记的 API 模块，因此通过项目内置的 `tsx` 运行，不需要全局安装 `tsx`。
+> 3. API 方法会在 CLI 进程中真实执行，请确保运行所需的环境变量、网络权限和鉴权配置已经准备好。
 
 #### 安装教程
 
@@ -19,19 +20,21 @@
 
 ```shell
 npm install gen-api-types -D
-
 ```
 
 #### 使用说明
 
-##### 1. 标记接口类名和方法
+##### 1. 标记 API 类和方法
 
 ```ts
 import { gen_type_c, gen_type_m } from 'gen-api-types'
 
 @gen_type_c()
 export class TestApi {
-	@gen_type_m({ args: [100], typeName: 'XXX' })
+	@gen_type_m({
+		args: [100],
+		typeName: 'XXX',
+	})
 	static async getList(id: number): Promise<XXX> {
 		return asleep(1000).then(() => {
 			return { name: 'zs', id }
@@ -39,7 +42,7 @@ export class TestApi {
 	}
 
 	@gen_type_m()
-	static getWeather(): Promise<Response_TestApi_getWeather> {
+	getWeather(): Promise<Response_TestApi_getWeather> {
 		return fetch('http://t.weather.sojson.com/api/weather/city/101030100').then(r => r.json())
 	}
 }
@@ -47,14 +50,26 @@ export class TestApi {
 
 如上面代码所示:
 
-- `@gen_type_c`装饰器函数，用来标记接口类。因为工具会动态分析指定目录下的所有 ts 文件，标记接口类，可以帮助我们快速定位接口类
-- `@gen_type_m`装饰器函数标记需要转换的请求方法。它可以接收一个配置对象，包含两个字段。
-  1.  `typeName: string` 接口返回类型名称，若不指定该字段，默认生成名称为： `Response_${类名}_${方法名}`
-  2.  `args：any[] ` 方法参数列表,工具调用请求方法时，会将参数列表传入
+- `@gen_type_c()` 标记 API 类。
+- `@gen_type_m()` 标记需要执行并生成类型的方法。
+- `args: any[]` 是调用方法时传入的参数，支持静态方法和非静态方法。
+- `typeName: string` 是生成的类型名称；不指定时默认为 `Response_${类名}_${方法名}`。
+- 推荐使用导出的 `gen_type_c`、`gen_type_m` 别名。`GatDecorator` 是内部用于按常量名称注册装饰器的容器，不是业务代码必须使用的入口。
+
+装饰器参数可以跨多行书写：
+
+```ts
+@gen_type_m({
+	args: [100],
+	typeName: 'XXX'
+})
+```
 
 > 注意：
 
-若使用装饰器时ts报错: "运行时将使用 2 个自变量调用修饰器，但修饰器需要 3 个",请将tsconfig中`compilerOptions.experimentalDecorators`设置为`true`
+若使用装饰器时 TypeScript 报错“运行时将使用 2 个自变量调用修饰器，但修饰器需要 3 个”，请将 `tsconfig.json` 中的 `compilerOptions.experimentalDecorators` 设置为 `true`。
+
+CLI 默认会为单个 API 方法设置 5 秒执行超时。超时、同步异常或 Promise rejection 都会被记录为该方法的执行失败；超时只能停止等待，不能取消已经发出的底层请求。
 
 ##### 2. 执行命令
 
@@ -86,13 +101,13 @@ Options:
 }
 ```
 
+CLI 会扫描输入目录中的 `.ts` 文件，找到标记的类和方法后，动态导入包含这些方法的模块。模块导入时装饰器会执行 API 方法，所有方法完成后再生成声明文件。
+
 命令输出：
 
 ```shell
 🚀 开始生成API类型...
 sourceFilesGlob [ 'src\\**\\*.ts' ]
-📋 处理 TestApi.getList ...
-📋 处理 TestApi.getWeather ...
 请求结果：
   ┌────────────────┬──────────────────────────────────────┐
   │ (index)        │ Values                               │
@@ -149,6 +164,24 @@ export type XXX = { name: string };
 export type Response_TestApi_getWeather = {...}
 ```
 
+##### 4. Vite 插件
+
+装饰器只用于生成类型，业务项目正常运行或构建时通常不需要执行这些装饰器。Vite 项目可以使用插件移除 `gen_type_c` 和 `gen_type_m`，避免装饰器在业务运行时产生副作用：
+
+```ts
+// vite.config.ts
+import { defineConfig } from 'vite'
+import { removeGatDecorators } from 'gen-api-types'
+
+export default defineConfig({
+	plugins: [removeGatDecorators()],
+})
+```
+
+插件只处理 `.ts` 和 `.tsx` 文件，并支持单行或多行装饰器参数。推荐在业务代码中使用 `gen_type_c`、`gen_type_m` 别名；如果直接使用 `GatDecorator.gen_type_m()`，不会匹配插件当前的装饰器名称。
+
+Vite 插件只影响 Vite 的转换流程，不参与 CLI 的 API 执行流程。
+
 #### VS Code 插件
 
 如果你在 VS Code 中使用 `gen-api-types` ，可以安装配套插件 [gen-api-types-vsce](https://github.com/xuejiangping/gen-api-types-vsce)，通过右键菜单生成 API 返回类型。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gen-api-types",
-  "version": "1.0.14",
+  "version": "1.0.17",
   "description": "一个自动生成请求接口返回类型的 cli 小工具",
   "main": "./src/index.ts",
   "exports": {
@@ -19,7 +19,8 @@
     "test": "vitest",
     "publish:patch": "npm version patch && git push --tags  && npm publish",
     "preinstall": "echo preinstall 。。。",
-    "postinstall": "echo postinstall 。。。"
+    "postinstall": "echo postinstall 。。。",
+    "gat": "gat -o test/output test/api "
   },
   "keywords": [
     "generate types",
@@ -43,6 +44,7 @@
   },
   "devDependencies": {
     "@types/node": "^24.3.1",
+    "vite": "^8.2.2",
     "vitest": "^3.2.4"
   }
 }

package/src/argv/index.ts

@@ -61,7 +61,7 @@ export const { positionals, values: { project_root, output_file, output_dir, ts_
 
 if (help) {
   console.log(`
-  gen-api-types [options] [positionals
+  gen-api-types [options] [positionals]
 
   Options:
     -h, --help                  输出帮助信息

package/src/cli/index.ts

@@ -2,11 +2,11 @@
 
 
 import * as path from 'path';
-import { Decorator, Project } from 'ts-morph';
+import { Project } from 'ts-morph';
 import { pathToFileURL } from 'url';
-import { isExported, output_dir, output_file, positionals } from '../argv';
-import { C_DECO_NAME, M_DECO_NAME } from '../constant';
-import { GenTypeOptions } from '../decotators';
+import { isExported, output_dir, output_file, positionals, ts_config_path } from '../argv';
+import { DECO_NAME_C, DECO_NAME_M } from '../constant';
+import { ExecuteApiMethodResult, executeState } from '../state';
 import { TypeTransformer } from '../transformer';
 import { formatResultList } from '../utils';
 
@@ -19,36 +19,15 @@ const out_put_target = path.resolve(output_dir, output_file)
 // console.log('sourceFilesGlob', sourceFilesGlob)
 // debugger
 
-type ApiMethodInfo = {
-  className: string,
-  methodName: string,
-  fullMethodName: string,
-  modulePath: string,
-  args: any[],
-  typeName: string,
-}
-
-function parserDecoArgs(deco: Decorator): GenTypeOptions {
-  const errMsg = `装饰器参数错误`
-  try {
-    const optionStr = deco.getArguments()[0]?.getText()
-    if (!optionStr) return {}
-    const option = eval(`(()=>(${optionStr}))()`)
-    if (typeof option === 'object') return option
-    else throw new Error(errMsg)
-  } catch (error) {
-    console.warn('parserDecoArgs error', error)
-    return {}
-  }
 
-}
-function getApiMethodsInfo() {
+function getModulePathSet() {
   console.log('sourceFilesGlob', sourceFilesGlob)
-  const apiMethodsInfo: ApiMethodInfo[] = []
+  const modulePathSet: Set<string> = new Set()
   // 2. 使用ts-morph创建项目，便于解析源码
   // const project = new Project({ tsConfigFilePath: ts_config_path });
-  const project = new Project({});
-
+  const project = new Project({
+    tsConfigFilePath: ts_config_path
+  });
   project.addSourceFilesAtPaths(sourceFilesGlob);
   // console.log('project.getSourceFiles().length', project.getSourceFiles().length)
   // debugger
@@ -57,82 +36,38 @@ function getApiMethodsInfo() {
 
     const classes = sourceFile.getClasses();
     for (const classDeclaration of classes) {
-      const c_deco = classDeclaration.getDecorator(C_DECO_NAME)
+      const c_deco = classDeclaration.getDecorator(DECO_NAME_C)
       if (!c_deco) continue
       const methods = classDeclaration.getMethods();
       for (const method of methods) {
-
         const className = classDeclaration.getName()!;
         const methodName = method.getName();
         const fullMethodName = `${className}.${methodName}`;
 
-        if (!method.isStatic()) {
-          console.warn(`⚠️  ${fullMethodName} is not static method,only static method can be transformed`)
-          continue
-        }
         // 4. 检查方法是否被我们的装饰器标记
-        const m_deco = method.getDecorator(M_DECO_NAME)
+        const m_deco = method.getDecorator(DECO_NAME_M)
         if (!m_deco) continue
+        executeState.emit(executeState.ADD_TASK, fullMethodName)
+        const modulePath = sourceFile.getFilePath()
+        if (!modulePathSet.has(modulePath)) modulePathSet.add(modulePath)
 
-        const { args = [], typeName = `Response_${className}_${methodName}` } = parserDecoArgs(m_deco)
-        apiMethodsInfo.push({
-          className, methodName, fullMethodName, modulePath: sourceFile.getFilePath(),
-          typeName, args
-        })
 
       }
     }
   }
-  return apiMethodsInfo
+  return modulePathSet
 }
 
-type ExecuteApiMethodResult = {
-  data?: any, typeName: string, fullMethodName: string, error?: any
-}
-async function executeApiMethods(apiMethodsInfo: ApiMethodInfo[]): Promise<ExecuteApiMethodResult[]> {
-  const apiModuleMap = new Map<string, any>();
-  const taskList = apiMethodsInfo.map(async (apiMethodInfo) => {
-    const { className, methodName, fullMethodName, modulePath, args, typeName } = apiMethodInfo
-    console.log(`📋 处理 ${fullMethodName} ...`);
-    let apiModule = null
-    if (apiModuleMap.has(modulePath)) apiModule = apiModuleMap.get(modulePath)
-    else {
-      // apiModule = await import(modulePath)
-      // debugger
-      // console.log('modulePath', modulePath)
-      // console.log('pathToFileURL(modulePath).href', pathToFileURL(modulePath).href)
-
-      try {
-        apiModule = await import(pathToFileURL(modulePath).href)
-        // console.log('apiMethod', apiModule)
-        if (apiModule) apiModuleMap.set(modulePath, apiModule)
-      } catch (error) {
-        console.log(`import ${modulePath} error \r\n`, error)
-        return { error: `module error`, fullMethodName, typeName }
-      }
-    }
-
-
-    const apiMethod = apiModule?.[className]?.[methodName]
-    if (apiMethod && typeof apiMethod === 'function') {
-      try {
-        // console.log(`🔍 Calling ${fullMethodName} with args:`, args);
-        const result = apiMethod.apply(apiModule, args)
-        const data = await Promise.resolve(result)
-        return { data, typeName, fullMethodName }
-      } catch (error) {
-        console.error(`❌ ${fullMethodName} execute error:`, error)
-        return { error, fullMethodName, typeName }
-      }
-    } else {
-      console.error(`❌ 无法获取 ${fullMethodName} 方法， 或不是可调用方法 `)
-      return {
-        error: `method error`, fullMethodName, typeName
-      }
-    }
-  })
 
-  return Promise.all(taskList)
+/**
+ * 引入包含标记的方法的模块，触发装饰器执行，记录执行结果
+ * @param modulePathSet 
+ * @returns 
+ */
+async function importApiModule<T extends string>(modulePathSet: Set<T>) {
+  return Promise.all(
+    Array.from(modulePathSet).map(modulePath => import(pathToFileURL(modulePath).href))
+  )
 
 }
 
@@ -155,13 +90,20 @@ function createDeclarationFile(successList: ExecuteApiMethodResult[]) {
 
 
 async function main() {
+  console.log('🚀 开始生成API类型...');
+  const modulePathSet = getModulePathSet();
+  if (modulePathSet.size == 0) {
+
+    console.error('⚠️ 未找到需要转换的API,请检查api_dir 和 gen_type装饰器标注是否正确!')
+    process.exit(1)
+  }
   try {
-    console.log('🚀 开始生成API类型...');
-    const apiMethodsInfo = getApiMethodsInfo();
-    if (apiMethodsInfo.length == 0) return console.warn('⚠️ 未找到需要转换的API,请检查api_dir 和 get_type装饰器标注是否正确!')
-    const executeList = await executeApiMethods(apiMethodsInfo);
+    await importApiModule(modulePathSet);
+    // executeState.addListener(executeState.TASKLIST_CLEAR, executeResultList=>{
+    // })
 
-    const { successList: executeSuccessList, errorList: executeErrorList } = formatResultList(executeList)
+    const executeResultList = await executeState.promise
+    const { successList: executeSuccessList, errorList: executeErrorList } = formatResultList(executeResultList)
     if (executeErrorList.length) {
       console.group('请求结果：')
       console.table({
@@ -185,8 +127,12 @@ async function main() {
     if (transformSuccessList.length) console.log('✅ API 类型生成完成：', out_put_target);
   } catch (error) {
     console.error('❌ 出错了', error)
+    process.exitCode = 1
   }
 
+
+
+
 }
 
 main()

package/src/constant/index.ts

@@ -1,5 +1,5 @@
 export const GEN_TYPE_METADATA_KEY = Symbol('gen:type:metadata');
 /** 标记方法的装饰器名称 */
-export const M_DECO_NAME = 'gen_type_m';
+export const DECO_NAME_M = 'gen_type_m';
 /** 标记类的装饰器名称 */
-export const C_DECO_NAME = 'gen_type_c';
+export const DECO_NAME_C = 'gen_type_c';

package/src/decotators/index.ts

@@ -1,5 +1,9 @@
 // import 'reflect-metadata';
 
+import { DECO_NAME_C, DECO_NAME_M } from "../constant/index.ts";
+import { executeState } from "../state/index.ts";
+import { executeApiMethod } from "../utils/index.ts";
+
 // 定义一个唯一的metadata key
 
 
@@ -7,26 +11,45 @@ export interface GenTypeOptions {
   args?: any[];
   typeName?: string;
 }
-/**
- * 标记方法
- */
-export function gen_type_m({ args = [], typeName }: GenTypeOptions = {}) {
-  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
-    // 只存储元数据，不执行任何逻辑
-    // Reflect.defineMetadata(
-    //   GEN_TYPE_METADATA_KEY,
-    //   { args, typeName },
-    //   target,
-    //   propertyKey
-    // );
-  };
-}
 
 
-/**
- * 标记类
- */
-export function gen_type_c() {
-  return function <T>(target: T) {
-  };
-}
+const EXEC_TIMEOUT = 5_000
+export class GatDecorator {
+  static [DECO_NAME_C]() {
+    return function <T>(target: T) {
+    };
+  }
+  static [DECO_NAME_M]({ args = [], typeName }: GenTypeOptions = {}) {
+    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+
+
+      (async () => {
+        const className = typeof target == 'function' ? target.name : target.constructor.name
+        const fullMethodName = `${className}.${propertyKey}`
+        console.log('fullMethodName', fullMethodName)
+        typeName ??= `Response_${className}_${propertyKey}`
+        let resultInfo = null
+        try {
+          const apiMethod = descriptor.value as Function
+          // console.log(`🔍 Calling ${fullMethodName} with args:`, args);
+
+          const data = await executeApiMethod({
+            timeout: EXEC_TIMEOUT,
+            method: () => apiMethod.apply(target, args)
+          })
+
+          resultInfo = { data, typeName, fullMethodName }
+        } catch (error) {
+          console.error(`❌ ${fullMethodName} execute error:`, error)
+          resultInfo = { error, fullMethodName, typeName }
+        } finally {
+          executeState.emit(executeState.EXECUTE_END, resultInfo)
+        }
+      })();
+
+    };
+  }
+}
+
+export const gen_type_c = GatDecorator[DECO_NAME_C]
+export const gen_type_m = GatDecorator[DECO_NAME_M]

package/src/index.ts

@@ -1,3 +1,4 @@
-export { C_DECO_NAME, M_DECO_NAME } from './constant';
-export * from './decotators';
+export * from './constant/index.ts';
+export * from './decotators/index.ts';
+export * from './plugins/index.ts';
 

package/src/plugins/index.ts

@@ -0,0 +1 @@
+export * from './vite/index.ts';

package/src/plugins/vite/index.ts

@@ -0,0 +1,46 @@
+import type { Plugin } from 'vite';
+import { DECO_NAME_C, DECO_NAME_M } from '../../constant/index.ts';
+
+function escapeRegExp(value: string) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * 去掉装饰器，用于在项目运行/构建时，gen-api-types的装饰器不会有任何副作用，影响到原来项目代码
+ * @param decorators 
+ * @returns 
+ */
+export function removeDecorators(decorators: string[]): Plugin {
+  const names = decorators.map(escapeRegExp).join('|');
+
+  const decoratorRegex = new RegExp(
+    `^[ \\t]*@(?:${names})(?:\\s*\\([\\s\\S]*?\\))?[ \\t]*\\r?\\n?`,
+    'gm'
+  );
+
+  return {
+    name: 'removeDecorators',
+    enforce: 'pre',
+
+    transform(code, id) {
+      if (!/\.(ts|tsx)(\?.*)?$/.test(id)) {
+        return;
+      }
+
+      const transformedCode = code.replace(decoratorRegex, '');
+
+      if (transformedCode === code) {
+        return;
+      }
+
+      return {
+        code: transformedCode,
+        map: null
+      };
+    }
+  };
+}
+
+export function removeGatDecorators() {
+  const decorators = [DECO_NAME_M, DECO_NAME_C]
+  return removeDecorators(decorators)
+}

package/src/state/index.ts

@@ -0,0 +1,45 @@
+import EventEmitter from "events"
+import { promiseWithResolvers } from "../utils/index.ts"
+
+export type ExecuteApiMethodResult = {
+  data?: any, typeName: string, fullMethodName: string, error?: any
+}
+
+
+
+
+
+
+export class ExecuteState extends EventEmitter {
+
+  EXECUTE_END = 'executeEnd'
+  TASKLIST_CLEAR = 'taskClear'
+  ADD_TASK = 'addTask'
+  private resultList: ExecuteApiMethodResult[] = []
+  private taskList: string[] = []
+  promiseWithResolvers = promiseWithResolvers<ExecuteApiMethodResult[]>()
+  constructor() {
+    super()
+    this.init()
+  }
+  init() {
+    this.addListener(this.EXECUTE_END, (result: ExecuteApiMethodResult) => {
+      this.resultList.push(result)
+      if (this.resultList.length === this.taskList.length) {
+        this.emit(this.TASKLIST_CLEAR, this.resultList)
+        this.promiseWithResolvers?.resolve(this.resultList)
+      }
+    })
+
+    this.addListener(this.ADD_TASK, (taskName) => {
+      this.taskList.push(taskName)
+    })
+  }
+
+  get promise() {
+    return this.promiseWithResolvers?.promise
+  }
+
+}
+
+export const executeState = new ExecuteState()

package/src/utils/index.ts

@@ -6,3 +6,42 @@ export function formatResultList<T extends ResultInfoBase>(list: T[]) {
     return acc
   }, { successList: [] as Omit<T, 'error'>[], errorList: [] as T[] })
 }
+
+export function promiseWithResolvers<T>() {
+  let promise!: Promise<T>
+  let resolve!: (value: T | PromiseLike<T>) => void
+  let reject!: (reason?: any) => void
+  promise = new Promise((res, rej) => {
+    resolve = res
+    reject = rej
+  })
+  return {
+    promise, resolve, reject
+  }
+}
+
+export async function executeApiMethod<T>({
+  method,
+  timeout = 10 * 1000
+}: {
+  method: () => T | PromiseLike<T>
+  timeout?: number
+}): Promise<T> {
+  let timer: ReturnType<typeof setTimeout> | undefined
+
+  const timeoutPromise = new Promise<never>((_, reject) => {
+    timer = setTimeout(() => {
+      reject(new Error(`API execution timed out after ${timeout}ms`))
+    }, timeout)
+  })
+
+  try {
+    return await Promise.race([
+      Promise.resolve().then(method),
+      timeoutPromise
+    ])
+  } finally {
+    if (timer) clearTimeout(timer)
+  }
+}
+

package/tsconfig.json

@@ -30,7 +30,7 @@
 		/* Modules */
 		"module": "esnext" /* Specify what module code is generated. */,
 		// "rootDir": "./",                                  /* Specify the root folder within your source files. */
-		"moduleResolution": "node" /* Specify how TypeScript looks up a file from a given module specifier. */,
+		"moduleResolution": "bundler" /* Specify how TypeScript looks up a file from a given module specifier. */,
 		// "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
 		// "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
 		// "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
@@ -38,7 +38,7 @@
 		// "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
 		// "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
 		// "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
-		// "allowImportingTsExtensions": true,               /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */
+		"allowImportingTsExtensions": true /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */,
 		// "rewriteRelativeImportExtensions": true,          /* Rewrite '.ts', '.tsx', '.mts', and '.cts' file extensions in relative import paths to their JavaScript equivalent in output files. */
 		// "resolvePackageJsonExports": true,                /* Use the package.json 'exports' field when resolving package imports. */
 		// "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
@@ -59,7 +59,7 @@
 		// "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
 		// "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
 		// "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
-		// "noEmit": true,                                   /* Disable emitting files from a compilation. */
+		"noEmit": true /* Disable emitting files from a compilation. */,
 		// "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
 		// "outDir": "./",                                   /* Specify an output folder for all emitted files. */
 		// "removeComments": true,                           /* Disable emitting comments. */