@snail-js/api 0.1.21 → 0.1.23

package/dist/snail-api.umd.cjs

@@ -3721,16 +3721,6 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       });
     }
   }
-  var RequestMethodEnum = /* @__PURE__ */ ((RequestMethodEnum2) => {
-    RequestMethodEnum2["GET"] = "Get";
-    RequestMethodEnum2["HEAD"] = "Head";
-    RequestMethodEnum2["POST"] = "Post";
-    RequestMethodEnum2["PUT"] = "Put";
-    RequestMethodEnum2["DELETE"] = "delete";
-    RequestMethodEnum2["PATCH"] = "Patch";
-    RequestMethodEnum2["OPTIONS"] = "Options";
-    return RequestMethodEnum2;
-  })(RequestMethodEnum || {});
   class SnailServerStatusCodeRuleOptions {
     constructor() {
       __publicField(this, "key");
@@ -3768,13 +3758,6 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       __publicField(this, "version");
     }
   }
-  var EventType = /* @__PURE__ */ ((EventType2) => {
-    EventType2["Success"] = "success";
-    EventType2["Error"] = "error";
-    EventType2["hitCache"] = "hitCache";
-    EventType2["Finish"] = "finish";
-    return EventType2;
-  })(EventType || {});
   function createCache(optios) {
     const { type } = optios;
     if (type === CacheType.Custom) {
@@ -3895,14 +3878,8 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     return !contentType.includes("application/json");
   }
   const METHOD_KEY = Symbol("SNAIL_METHOD_KEY");
-  const API_CONFIG_KEY = Symbol("SNAIL_API_CONFIG_KEY");
-  const Api = (url = "", config) => {
-    return (target) => {
-      Reflect.defineMetadata(API_CONFIG_KEY, { url, ...config }, target);
-    };
-  };
   const createMethodDecorator = (method) => {
-    return (path = "", name) => {
+    return (path = "", options) => {
       return (target, propertyKey) => {
         const methodOptions = Reflect.getMetadata(
           METHOD_KEY,
@@ -3911,25 +3888,29 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         );
         if (methodOptions) {
           console.error("only one method decorator for a request function!");
-          console.error(`you must chose only one method decorator[@${method} or @${methodOptions.method}]`);
-          throw new TypeError(`Multiple decorators are used for the same request function`);
+          console.error(
+            `you must chose only one method decorator[@${method} or @${methodOptions.method}]`
+          );
+          throw new TypeError(
+            `Multiple decorators are used for the same request function`
+          );
         }
         Reflect.defineMetadata(
           METHOD_KEY,
-          { method, path, name },
+          { method, path, ...options },
           target,
           propertyKey
         );
       };
     };
   };
-  const Get = createMethodDecorator(RequestMethodEnum.GET);
-  const Post = createMethodDecorator(RequestMethodEnum.POST);
-  const Put = createMethodDecorator(RequestMethodEnum.PUT);
-  const Delete = createMethodDecorator(RequestMethodEnum.DELETE);
-  const Patch = createMethodDecorator(RequestMethodEnum.PATCH);
-  const Options = createMethodDecorator(RequestMethodEnum.OPTIONS);
-  const Head = createMethodDecorator(RequestMethodEnum.HEAD);
+  const Get = createMethodDecorator("GET");
+  const Post = createMethodDecorator("POST");
+  const Put = createMethodDecorator("PUT");
+  const Delete = createMethodDecorator("DELETE");
+  const Patch = createMethodDecorator("PATCH");
+  const Options = createMethodDecorator("OPTIONS");
+  const Head = createMethodDecorator("HEAD");
   const SERVER_CONFIG_KEY = Symbol("SANIL_SERVER_CONFIG_KEY");
   const Server = (config) => {
     return (target) => {
@@ -3980,6 +3961,54 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       Reflect.defineMetadata(CACHE_EXPIRE_SOURCE_KEY, sources, target);
     };
   };
+  class SnailEvent {
+    constructor() {
+      __publicField(this, "eventMap");
+      __publicField(this, "onceWrapperMap");
+      __publicField(this, "on", (eventName, listener) => {
+        if (typeof listener !== "function") {
+          throw new TypeError("Handler must be a function");
+        }
+        const listeners = this.eventMap.get(eventName) || /* @__PURE__ */ new Set();
+        listeners.add(listener);
+        this.eventMap.set(eventName, listeners);
+      });
+      __publicField(this, "off", (eventName, listener) => {
+        const listeners = this.eventMap.get(eventName);
+        if (!listeners) return;
+        if (this.onceWrapperMap.has(listener)) {
+          this.onceWrapperMap.delete(listener);
+        }
+        if (listeners.size === 0) {
+          this.eventMap.delete(eventName);
+        }
+      });
+      __publicField(this, "once", (eventName, listener) => {
+        const onceHandler = (data) => {
+          try {
+            listener.apply(this, [data]);
+          } finally {
+            this.off(eventName, onceHandler);
+            this.onceWrapperMap.delete(listener);
+          }
+        };
+        this.onceWrapperMap.set(listener, onceHandler);
+        this.on(eventName, onceHandler);
+      });
+      __publicField(this, "emit", (eventName, ...args) => {
+        const listeners = this.eventMap.get(eventName);
+        if (!listeners || listeners.size === 0) return false;
+        listeners.forEach((listener) => {
+          Promise.resolve().then(() => {
+            listener.apply(this, args);
+          });
+        });
+        return true;
+      });
+      this.eventMap = /* @__PURE__ */ new Map();
+      this.onceWrapperMap = /* @__PURE__ */ new Map();
+    }
+  }
   const versionHandlers = {
     [VersioningType.Uri]: (version, versioning) => {
       const prefix = versioning.prefix || "v";
@@ -4023,7 +4052,8 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
   const UPLOAD_PROGRESS_KEY = Symbol("SNAIL_UPLOAD_PROGRESS_KEY");
   const DOWNLOAD_PROGRESS_KEY = Symbol("SNAIL_DOWNLOAD_PROGRESS_KEY");
   class SnailMethod {
-    constructor(apiInstance, target, propertyKey, args) {
+    // private Args: any[] = [];
+    constructor(apiInstance, target, propertyKey) {
       // 私有属性
       // private serverInstance: SnailServer;
       __publicField(this, "Name");
@@ -4033,144 +4063,111 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       __publicField(this, "Request");
       __publicField(this, "Response");
       __publicField(this, "Error");
-      __publicField(this, "eventMap");
-      __publicField(this, "onceWrapperMap");
+      __publicField(this, "EventEmit");
+      // private eventMap: Map<string, Set<EventHandler>>;
+      // private onceWrapperMap: Map<EventHandler, EventHandler>;
       __publicField(this, "propertyKey");
       __publicField(this, "Url", "");
       __publicField(this, "Path", "");
-      __publicField(this, "Method", RequestMethodEnum.GET);
+      __publicField(this, "Method", "GET");
+      __publicField(this, "Adapter");
       __publicField(this, "Version");
-      __publicField(this, "Args", []);
-      __publicField(this, "send", async () => {
+      __publicField(this, "send", (...args) => {
         this.enableLog() && console.log("send:", this.name);
         const [serverName] = this.apiInstance.name.split(".");
         const axios2 = AxiosInstanceMap.get(serverName);
         if (!axios2) throw new Error("AxiosInstance not created");
-        const serverStatusCodeRule = ServerStatusCodeRuleMap.get(serverName);
-        const strategies = this.getStrategies();
-        this.Request = await applyStrategies(this.Request, strategies, "request");
-        this.Request = this.applyProgress(this.Request);
-        const { data, querys, params } = buildRequestArgs(
-          this.target,
-          this.propertyKey,
-          this.Args
-        );
-        this.enableLog() && console.log("methodUrl:", this.Request.baseURL, this.Request.url);
-        const newUrl = replacePlaceholders(this.Url, params);
-        this.Request = {
-          ...this.Request,
-          url: newUrl,
-          params: {
-            ...this.Request.params,
-            ...querys
-          },
-          data
-        };
-        this.enableLog() && console.log("request:", this.Request);
-        const isNoCache = this.isNoCache();
-        this.enableLog() && console.log("method is noCache:", isNoCache);
-        if (!isNoCache) {
-          const { data: data2 } = await this.getCacheData(serverName);
-          this.enableLog() && console.log("getCacheData:", data2);
-          if (data2) {
-            this.emit("hitCache", data2);
-            this.emit("success", data2);
-            this.emit("finish", data2);
-            return data2;
-          }
-        }
-        const requester = AxiosInstanceMap.get(serverName);
-        if (!requester) throw new Error("AxiosInstance not created");
-        try {
-          const rawResponse = await requester.request(this.Request);
-          const isSpecial = isSpecialResponse(rawResponse);
-          const response = await applyStrategies(
-            rawResponse,
-            strategies,
-            "response"
+        return new Promise(async (resolve, reject) => {
+          const serverStatusCodeRule = ServerStatusCodeRuleMap.get(serverName);
+          const strategies = this.getStrategies();
+          this.Request = await applyStrategies(this.Request, strategies, "request");
+          this.Request = this.applyProgress(this.Request);
+          const { data, querys, params } = buildRequestArgs(
+            this.target,
+            this.propertyKey,
+            // this.Args
+            args
           );
+          this.enableLog() && console.log("methodUrl:", this.Request.baseURL, this.Request.url);
+          const newUrl = replacePlaceholders(this.Url, params);
+          this.Request = {
+            ...this.Request,
+            url: newUrl,
+            params: {
+              ...this.Request.params,
+              ...querys
+            },
+            data
+          };
+          this.enableLog() && console.log("request:", this.Request);
+          const isNoCache = this.isNoCache();
+          this.enableLog() && console.log("method is noCache:", isNoCache);
           if (!isNoCache) {
-            !isSpecial && await this.setCacheData(serverName, response);
-          }
-          this.Response = response;
-          this.applyHitSource(serverName);
-          isSpecial && console.log("isSpecial:", isSpecial);
-          if (isSpecial) {
-            this.emit("success", response.data);
-            this.emit("finish", response.data);
-            return response;
+            const { data: data2 } = await this.getCacheData(serverName);
+            this.enableLog() && console.log("getCacheData:", data2);
+            if (data2) {
+              this.EventEmit.emit("hitCache", data2);
+              this.EventEmit.emit("success", data2);
+              this.EventEmit.emit("finish", data2);
+              resolve(data2);
+              return;
+            }
           }
-          !isSpecial && console.log("isSpecial:", isSpecial);
-          if (serverStatusCodeRule) {
-            const { key, rule } = serverStatusCodeRule;
-            const statuCodeKey = key ?? "code";
-            const data2 = response.data;
-            if (rule(data2[statuCodeKey])) {
-              this.emit("success", response.data);
-            } else {
-              this.emit("error", response.data);
+          const requester = AxiosInstanceMap.get(serverName);
+          if (!requester) throw new Error("AxiosInstance not created");
+          try {
+            const rawResponse = await requester.request(this.Request);
+            const isSpecial = isSpecialResponse(rawResponse);
+            const response = await applyStrategies(
+              rawResponse,
+              strategies,
+              "response"
+            );
+            if (!isNoCache) {
+              !isSpecial && await this.setCacheData(serverName, response);
+            }
+            this.Response = response;
+            this.applyHitSource(serverName);
+            isSpecial && console.log("isSpecial:", isSpecial);
+            if (isSpecial) {
+              this.EventEmit.emit("success", response.data);
+              this.EventEmit.emit("finish", response.data);
+              resolve(response);
+              return;
             }
+            !isSpecial && console.log("isSpecial:", isSpecial);
+            if (serverStatusCodeRule) {
+              const { key, rule } = serverStatusCodeRule;
+              const statuCodeKey = key ?? "code";
+              const data2 = response.data;
+              if (rule(data2[statuCodeKey])) {
+                this.EventEmit.emit("success", response.data);
+              } else {
+                this.EventEmit.emit("error", response.data);
+              }
+            }
+            resolve(response.data);
+          } catch (error) {
+            this.EventEmit.emit("error", error);
+            this.EventEmit.emit("finish", error);
+            console.error(error);
+            this.Error = error;
+            reject(error);
+            return;
           }
-          return response.data;
-        } catch (error) {
-          this.emit("error", error);
-          this.emit("finish", error);
-          console.error(error);
-          this.Error = error;
-          return error;
-        }
-      });
-      __publicField(this, "onSuccess", (handler) => {
-        this.on("success", handler);
-      });
-      __publicField(this, "onError", (handler) => {
-        this.on("error", handler);
+        });
       });
-      __publicField(this, "onHitCache", (handler) => {
-        this.on("hitCache", handler);
+      __publicField(this, "onSuccess", (listener) => {
+        this.EventEmit.on("success", listener);
       });
-      __publicField(this, "onFinish", (handler) => {
-        this.on("finish", handler);
+      __publicField(this, "onError", (listener) => {
+        this.EventEmit.on("error", listener);
       });
-      __publicField(this, "on", (eventName, handler) => {
-        if (typeof handler !== "function") {
-          throw new TypeError("Handler must be a function");
-        }
-        const handlers = this.eventMap.get(eventName) || /* @__PURE__ */ new Set();
-        handlers.add(handler);
-        this.eventMap.set(eventName, handlers);
+      __publicField(this, "onHitCache", (listener) => {
+        this.EventEmit.on("hitCache", listener);
       });
-      __publicField(this, "once", (eventName, handler) => {
-        const onceHandler = (data) => {
-          try {
-            handler.apply(this, [data]);
-          } finally {
-            this.off(eventName, onceHandler);
-            this.onceWrapperMap.delete(handler);
-          }
-        };
-        this.onceWrapperMap.set(handler, onceHandler);
-        this.on(eventName, onceHandler);
-      });
-      __publicField(this, "emit", (eventName, ...args) => {
-        const handlers = this.eventMap.get(eventName);
-        if (!handlers || handlers.size === 0) return false;
-        handlers.forEach((handler) => {
-          Promise.resolve().then(() => {
-            handler.apply(this, args);
-          });
-        });
-        return true;
-      });
-      __publicField(this, "off", (eventName, handler) => {
-        const handlers = this.eventMap.get(eventName);
-        if (!handlers) return;
-        if (handlers.has(handler)) {
-          handlers.delete(handler);
-        }
-        if (handlers.size === 0) {
-          this.eventMap.delete(eventName);
-        }
+      __publicField(this, "onFinish", (listener) => {
+        this.EventEmit.on("finish", listener);
       });
       __publicField(this, "registerStrategies", (...strategys) => {
         this.strategies.push(...strategys);
@@ -4178,25 +4175,20 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       this.apiInstance = apiInstance;
       this.target = target;
       this.propertyKey = propertyKey.toString();
-      this.Args = args ?? [];
       this.init();
       this.enableLog() && console.log("url:", this.Url);
-      this.eventMap = /* @__PURE__ */ new Map();
-      this.onceWrapperMap = /* @__PURE__ */ new Map();
-      this.eventMap.set("success", /* @__PURE__ */ new Set());
-      this.eventMap.set("hitCache", /* @__PURE__ */ new Set());
-      this.eventMap.set("error", /* @__PURE__ */ new Set());
-      this.eventMap.set("finish", /* @__PURE__ */ new Set());
+      this.EventEmit = new SnailEvent();
     }
     init() {
       const methodOptions = this.getMethodOptions();
       if (!methodOptions) {
         throw new Error("Create SnailMethod must be used for decoration");
       }
-      const { path, method, name } = methodOptions;
+      const { path, method, name, adapter } = methodOptions;
       this.Name = name ?? this.propertyKey;
       this.Path = path;
       this.Method = method;
+      this.Adapter = adapter;
       this.createRequest();
       this.initUrl();
       this.initVersion();
@@ -4256,6 +4248,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       const request = {
         url: this.Url,
         method: this.Method,
+        adapter: this.Adapter,
         timeout: this.apiInstance.timeout,
         data: {},
         params: {},
@@ -4340,12 +4333,11 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       const [serverName] = this.apiInstance.name.split(".");
       const cacheForMap = CacheForMap.get(serverName);
       let flag = false;
-      if (typeof cacheForMap === "string" && (cacheForMap.toLowerCase() === "all" || cacheForMap === this.Method)) {
-        flag = true;
-      }
-      if (Array.isArray(cacheForMap)) {
-        flag = cacheForMap.includes(this.Method);
+      if (cacheForMap) {
+        flag = cacheForMap.includes(this.Method.toLowerCase());
       }
+      this.enableLog() && console.log("cacheForMap:", cacheForMap);
+      this.enableLog() && console.log("cacheMethodFlag:", flag);
       const isMethodNoCache = Reflect.getMetadata(
         NO_CACHE_KEY,
         this.target,
@@ -4503,10 +4495,8 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
             propertyKey
           );
           if (!methodConfig) return target[propertyKey];
-          return (...args) => {
-            const method = new SnailMethod(apiInstance, target, propertyKey, [
-              ...args
-            ]);
+          return () => {
+            const method = new SnailMethod(apiInstance, target, propertyKey);
             this.initExpireSource(method, propertyKey);
             return method;
           };
@@ -4529,7 +4519,14 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         CacheTtlMap.set(this.Name, options.ttl || 500);
       }
       if (cacheFor) {
-        CacheForMap.set(this.Name, cacheFor);
+        if (Array.isArray(cacheFor)) {
+          CacheForMap.set(
+            this.Name,
+            cacheFor.map((method) => method.toLowerCase())
+          );
+          return;
+        }
+        CacheForMap.set(this.Name, [cacheFor.toLowerCase()]);
       }
     }
     initExpireSource(target, propertyKey) {
@@ -4600,6 +4597,12 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       return this.BaseURL;
     }
   }
+  const API_CONFIG_KEY = Symbol("SNAIL_API_CONFIG_KEY");
+  const Api = (url = "", config) => {
+    return (target) => {
+      Reflect.defineMetadata(API_CONFIG_KEY, { url, ...config }, target);
+    };
+  };
   class SnailApi {
     constructor(options) {
       __publicField(this, "Name");
@@ -4823,7 +4826,6 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
   exports2.CacheType = CacheType;
   exports2.Data = Data;
   exports2.Delete = Delete;
-  exports2.EventType = EventType;
   exports2.Get = Get;
   exports2.Head = Head;
   exports2.HitSource = HitSource;
@@ -4836,7 +4838,6 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
   exports2.Post = Post;
   exports2.Put = Put;
   exports2.Query = Query;
-  exports2.RequestMethodEnum = RequestMethodEnum;
   exports2.Server = Server;
   exports2.SnailApi = SnailApi;
   exports2.SnailMethod = SnailMethod;

package/dist/typings/api.option.d.ts

@@ -1,15 +1,9 @@
-import { RequestMethod } from "./request.method";
 import { SnailServer } from "../core";
 export interface ApiOptions {
     name?: string;
     timeout?: number;
     version?: string;
 }
-export interface MethodOption {
-    name?: string;
-    method: RequestMethod;
-    path: string;
-}
 export interface ApiInstanceOptions {
     serverInstance: SnailServer;
     enableLog?: boolean;

package/dist/typings/apiProxy.d.ts

@@ -1,12 +1,8 @@
-import { ResponseData, SpecialResponseData, StandardResponseData } from "./response.data";
-import { SnailMethod } from "../core/snailMethod";
-export type ApiResponse<T> = Promise<{
-    data: T | null;
-    error: Error | null;
-    hitCache?: boolean;
-}>;
-export type ApiProxy<T extends object, RT extends ResponseData = Omit<StandardResponseData, "data">, DK extends string = "data"> = {
-    [K in keyof T]: T[K] extends (...args: infer A) => any ? RT extends SpecialResponseData ? <RD>(...args: A) => SnailMethod<RD extends SpecialResponseData ? RD : never> : <RD>(...args: A) => RD extends SpecialResponseData ? SnailMethod<RD> : SnailMethod<RT & {
+import { SpecialResponseData, StandardResponseData, ResponseJsonData } from "./response.data";
+import { MethodProxy } from "./snail.method";
+export type StandardResponseWithoutData = Omit<StandardResponseData, "data">;
+export type ApiProxy<T extends object, RT extends StandardResponseWithoutData | ResponseJsonData, DK extends string = "data"> = {
+    [K in keyof T]: T[K] extends (...args: infer A) => any ? <RD = unknown>() => MethodProxy<RD extends SpecialResponseData ? RD : RT & {
         [KK in DK]: RD;
-    }> : T[K];
+    }, A extends any[] ? A : []> : T[K];
 };

package/dist/typings/index.d.ts

@@ -1,5 +1,4 @@
 export * from "./request.body";
-export * from "./request.method";
 export * from "./snail.option";
 export * from "./api.option";
 export * from "./versioning.option";
@@ -10,3 +9,4 @@ export * from "./strategy";
 export * from "./apiProxy";
 export * from "./sse";
 export * from "./snail.method";
+export * from "./snail.event";

package/dist/typings/response.data.d.ts

@@ -1,8 +1,7 @@
 export interface PaginationData<T> {
     total: number;
     page: number;
-    size: number;
-    record: T[];
+    records: T[];
 }
 export type ResponseJsonData = Record<string, any> | object;
 export type SpecialResponseData = string | ArrayBuffer | Blob | FormData;

package/dist/typings/snail.event.d.ts

@@ -0,0 +1,6 @@
+import { AxiosResponse } from "axios";
+export type SnailSuccessListener<T = any> = (data?: T) => void;
+export type SnailErrorListener<T = any, ErrorData = any> = (response?: AxiosResponse<T> | Error | ErrorData) => void;
+export type SnailHitCacheListener<T = any> = (cacheData?: T) => void;
+export type SnailFinishListener<T = any> = (data?: T) => void;
+export type SnailEventListener<T = any, ErrorData = any> = SnailSuccessListener<T> | SnailErrorListener<T, ErrorData> | SnailHitCacheListener<T> | SnailFinishListener<T>;

package/dist/typings/snail.method.d.ts

@@ -1,11 +1,14 @@
-import { AxiosResponse } from "axios";
-import { ResponseData, ResponseJsonData, StandardResponseData, SpecialResponseData } from "./response.data";
-export type EventHandler<T = any> = (data?: T) => void;
-export declare enum EventType {
-    Success = "success",
-    Error = "error",
-    hitCache = "hitCache",
-    Finish = "finish"
+import { AxiosRequestConfig, Method, AxiosResponse } from "axios";
+import { ResponseData, ResponseJsonData, SpecialResponseData } from "./response.data";
+import { SnailMethod } from "../core";
+export interface MethodSendOptions {
+    name?: string;
+    adapter?: AxiosRequestConfig["adapter"];
+}
+export interface MethodOption extends MethodSendOptions {
+    method: Method;
+    path: string;
+}
+export interface MethodProxy<RD extends ResponseData = ResponseJsonData, ArgsType extends any[] = []> extends SnailMethod<RD> {
+    send: (...args: ArgsType) => Promise<RD extends SpecialResponseData ? AxiosResponse<RD> : RD>;
 }
-export type SnailMethodEventType = `${EventType}` | EventType | string;
-export type SendRequest<RD extends ResponseData = StandardResponseData<ResponseJsonData>> = () => Promise<RD extends SpecialResponseData ? AxiosResponse<RD> : RD>;

package/dist/typings/snail.option.d.ts

@@ -1,6 +1,6 @@
 import { CacheManagementOption } from "./cache.management.option";
-import { RequestMethod } from "./request.method";
-export type CacheForType = "All" | "all" | RequestMethod | RequestMethod[];
+import { Method } from "axios";
+export type CacheForType = "All" | "all" | Method | Method[];
 export declare class SnailServerStatusCodeRuleOptions {
     key?: string;
     rule: (status: number) => boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snail-js/api",
-  "version": "0.1.21",
+  "version": "0.1.23",
   "description": "Http Request with Decorators Api, build on axios",
   "type": "module",
   "main": "./src/index.ts",

package/dist/typings/request.method.d.ts

@@ -1,10 +0,0 @@
-export declare enum RequestMethodEnum {
-    GET = "Get",
-    HEAD = "Head",
-    POST = "Post",
-    PUT = "Put",
-    DELETE = "delete",
-    PATCH = "Patch",
-    OPTIONS = "Options"
-}
-export type RequestMethod = Uppercase<`${RequestMethodEnum}`> | Lowercase<`${RequestMethodEnum}`> | `${RequestMethodEnum}` | RequestMethodEnum;