@snail-js/api 0.1.16 → 0.1.18

package/dist/core/snailApi.d.ts

@@ -9,7 +9,7 @@ export declare class SnailApi {
     constructor(options: ApiInstanceOptions);
     private init;
     private initStrategy;
-    registerStrategies(...strategys: Array<new () => Strategy>): void;
+    registerStrategies: (...strategys: Array<new () => Strategy>) => void;
     private initName;
     private getApiConfig;
     private isNoCache;

package/dist/core/snailMethod.d.ts

@@ -1,12 +1,12 @@
 import { AxiosResponse, AxiosRequestConfig } from "axios";
-import { EventHandler, Strategy, ResponseData, SendRequest, StandardResponseData, ResponseJsonData, SnailMethodEventType } from "../typings";
+import { EventHandler, Strategy, ResponseData, SendRequest, StandardResponseData, SnailMethodEventType } from "../typings";
 import { SnailApi } from "./snailApi";
 /**
  * SnailMethod
  * 泛型参数: RT => response.data类型,默认标准json返回
  *  DK => response.data.data 类型
  */
-export declare class SnailMethod<RT extends ResponseData = StandardResponseData<ResponseJsonData>> {
+export declare class SnailMethod<RT extends ResponseData = StandardResponseData> {
     private Name;
     private apiInstance;
     private target;
@@ -29,14 +29,14 @@ export declare class SnailMethod<RT extends ResponseData = StandardResponseData<
     private initVersion;
     private getExpireSources;
     private createRequest;
-    onSuccess(handler: EventHandler<RT>): void;
-    onError(handler: EventHandler<RT>): void;
-    onHitCache(handler: EventHandler<RT>): void;
-    onFinish(handler: EventHandler<RT>): void;
-    on(eventName: SnailMethodEventType, handler: EventHandler<RT>): void;
-    once(eventName: SnailMethodEventType, handler: EventHandler<RT>): void;
-    emit(eventName: SnailMethodEventType, ...args: any): boolean;
-    off(eventName: SnailMethodEventType, handler: EventHandler<RT>): void;
+    onSuccess: (handler: EventHandler<RT>) => void;
+    onError: (handler: EventHandler<RT>) => void;
+    onHitCache: (handler: EventHandler<RT>) => void;
+    onFinish: (handler: EventHandler<RT>) => void;
+    on: (eventName: SnailMethodEventType, handler: EventHandler<RT>) => void;
+    once: (eventName: SnailMethodEventType, handler: EventHandler<RT>) => void;
+    emit: (eventName: SnailMethodEventType, ...args: any) => boolean;
+    off: (eventName: SnailMethodEventType, handler: EventHandler<RT>) => void;
     private getCacheData;
     private setCacheData;
     get response(): AxiosResponse<RT, any>;
@@ -44,7 +44,7 @@ export declare class SnailMethod<RT extends ResponseData = StandardResponseData<
     get version(): string | undefined;
     get name(): string;
     get error(): any;
-    registerStrategies(...strategys: Array<new () => Strategy>): void;
+    registerStrategies: (...strategys: Array<new () => Strategy>) => void;
     private getStrategies;
     private getMethodOptions;
     private isNoCache;

package/dist/core/snailServer.d.ts

@@ -1,6 +1,6 @@
 import "reflect-metadata";
 import { AxiosInstance } from "axios";
-import { Strategy, ApiInstanceOptions, VersioningOption, CacheStorage, ApiProxy, ResponseData, StandardResponseData, ResponseJsonData, CacheForType } from "../typings";
+import { Strategy, ApiInstanceOptions, VersioningOption, CacheStorage, ApiProxy, ResponseData, StandardResponseData, CacheForType } from "../typings";
 import { SnailApi } from "./snailApi";
 import { SnailSse } from "./snailSse";
 export declare const CacheStorageMap: Map<string, CacheStorage>;
@@ -10,7 +10,7 @@ export declare const ExpireSourceMap: Map<string, Set<string>>;
 export declare const AxiosInstanceMap: Map<string, AxiosInstance>;
 export declare const StrategyMap: Map<string, (new () => Strategy)[]>;
 export declare const VersioningMap: Map<string, VersioningOption>;
-export declare class SnailServer<RT extends ResponseData = StandardResponseData<ResponseJsonData>, DK extends string = "data"> {
+export declare class SnailServer<RT extends ResponseData = StandardResponseData, DK extends string = "data"> {
     private Name;
     private BaseURL;
     private Version;
@@ -20,7 +20,7 @@ export declare class SnailServer<RT extends ResponseData = StandardResponseData<
     private initLog;
     private initStrategy;
     private initVersioning;
-    registerStrategies(...strategys: Array<new () => Strategy>): void;
+    registerStrategies: (...strategys: Array<new () => Strategy>) => void;
     createApi<T extends SnailApi>(constructor: new (options: ApiInstanceOptions) => T): ApiProxy<T, RT, DK>;
     private initCacheManage;
     private initExpireSource;

package/dist/snail-api.js

@@ -3880,8 +3880,9 @@ const buildRequestArgs = (target, propertyKey, args) => {
   return requestArgs;
 };
 function isSpecialResponse(response) {
-  const contentType = response.headers["content-type"];
-  return contentType && contentType.includes("application/json");
+  const contentType = response.headers["Content-Type"];
+  if (!contentType) return false;
+  return !contentType.includes("application/json");
 }
 const METHOD_KEY = Symbol("SNAIL_METHOD_KEY");
 const API_CONFIG_KEY = Symbol("SNAIL_API_CONFIG_KEY");
@@ -4084,7 +4085,9 @@ class SnailMethod {
         this.applyHitSource(serverName);
         this.emit("success", response.data);
         this.emit("finish", response.data);
+        isSpecial && console.log("isSpecial:", isSpecial);
         if (isSpecial) return response;
+        !isSpecial && console.log("isSpecial:", isSpecial);
         return response.data;
       } catch (error) {
         this.emit("error", error);
@@ -4094,6 +4097,61 @@ class SnailMethod {
         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, "onFinish", (handler) => {
+      this.on("finish", handler);
+    });
+    __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, "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, "registerStrategies", (...strategys) => {
+      this.strategies.push(...strategys);
+    });
     this.apiInstance = apiInstance;
     this.target = target;
     this.propertyKey = propertyKey.toString();
@@ -4180,58 +4238,6 @@ class SnailMethod {
     this.Request = request;
     return request;
   }
-  onSuccess(handler) {
-    this.on("success", handler);
-  }
-  onError(handler) {
-    this.on("error", handler);
-  }
-  onHitCache(handler) {
-    this.on("hitCache", handler);
-  }
-  onFinish(handler) {
-    this.on("finish", handler);
-  }
-  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);
-  }
-  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);
-  }
-  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;
-  }
-  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);
-    }
-  }
   async getCacheData(serverName) {
     const methodKey = await generateCacheKey(
       this.name,
@@ -4281,9 +4287,6 @@ class SnailMethod {
     if (this.Error) return this.Error;
     return null;
   }
-  registerStrategies(...strategys) {
-    this.strategies.push(...strategys);
-  }
   getStrategies() {
     const [serverName, apiName] = this.apiInstance.name.split(".");
     const serverStrategies = StrategyMap.get(serverName) ?? [];
@@ -4386,6 +4389,11 @@ class SnailServer {
     __publicField(this, "BaseURL");
     __publicField(this, "Version");
     __publicField(this, "EnableLog", false);
+    __publicField(this, "registerStrategies", (...strategys) => {
+      const serverStrategies = StrategyMap.get(this.Name) ?? [];
+      serverStrategies.push(...strategys);
+      StrategyMap.set(this.Name, serverStrategies);
+    });
     const options = this.getServerOptions();
     this.Name = options.name ?? this.constructor.name;
     this.init();
@@ -4428,11 +4436,6 @@ class SnailServer {
       VersioningMap.set(this.Name, versioning);
     }
   }
-  registerStrategies(...strategys) {
-    const serverStrategies = StrategyMap.get(this.Name) ?? [];
-    serverStrategies.push(...strategys);
-    StrategyMap.set(this.Name, serverStrategies);
-  }
   createApi(constructor) {
     const serverVersioning = Reflect.getMetadata(
       VERSIONING_KEY,
@@ -4562,6 +4565,11 @@ class SnailApi {
     __publicField(this, "Url");
     __publicField(this, "Timeout");
     __publicField(this, "EnableLog");
+    __publicField(this, "registerStrategies", (...strategys) => {
+      const serverStrategies = StrategyMap.get(this.Name) ?? [];
+      serverStrategies.push(...strategys);
+      StrategyMap.set(this.Name, serverStrategies);
+    });
     const apiConfig = this.getApiConfig();
     if (!apiConfig) {
       throw new Error("Create SnailApi must be used for @Api() decoration");
@@ -4583,11 +4591,6 @@ class SnailApi {
     const serverStrategies = Reflect.getMetadata(STRATEGY_KEY, this.constructor) || [];
     StrategyMap.set(this.Name, serverStrategies);
   }
-  registerStrategies(...strategys) {
-    const serverStrategies = StrategyMap.get(this.Name) ?? [];
-    serverStrategies.push(...strategys);
-    StrategyMap.set(this.Name, serverStrategies);
-  }
   initName() {
     const { name } = this.getApiConfig();
     const apiName = name ?? this.constructor.name;

package/dist/snail-api.umd.cjs

@@ -3884,8 +3884,9 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     return requestArgs;
   };
   function isSpecialResponse(response) {
-    const contentType = response.headers["content-type"];
-    return contentType && contentType.includes("application/json");
+    const contentType = response.headers["Content-Type"];
+    if (!contentType) return false;
+    return !contentType.includes("application/json");
   }
   const METHOD_KEY = Symbol("SNAIL_METHOD_KEY");
   const API_CONFIG_KEY = Symbol("SNAIL_API_CONFIG_KEY");
@@ -4088,7 +4089,9 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
           this.applyHitSource(serverName);
           this.emit("success", response.data);
           this.emit("finish", response.data);
+          isSpecial && console.log("isSpecial:", isSpecial);
           if (isSpecial) return response;
+          !isSpecial && console.log("isSpecial:", isSpecial);
           return response.data;
         } catch (error) {
           this.emit("error", error);
@@ -4098,6 +4101,61 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
           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, "onFinish", (handler) => {
+        this.on("finish", handler);
+      });
+      __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, "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, "registerStrategies", (...strategys) => {
+        this.strategies.push(...strategys);
+      });
       this.apiInstance = apiInstance;
       this.target = target;
       this.propertyKey = propertyKey.toString();
@@ -4184,58 +4242,6 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       this.Request = request;
       return request;
     }
-    onSuccess(handler) {
-      this.on("success", handler);
-    }
-    onError(handler) {
-      this.on("error", handler);
-    }
-    onHitCache(handler) {
-      this.on("hitCache", handler);
-    }
-    onFinish(handler) {
-      this.on("finish", handler);
-    }
-    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);
-    }
-    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);
-    }
-    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;
-    }
-    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);
-      }
-    }
     async getCacheData(serverName) {
       const methodKey = await generateCacheKey(
         this.name,
@@ -4285,9 +4291,6 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       if (this.Error) return this.Error;
       return null;
     }
-    registerStrategies(...strategys) {
-      this.strategies.push(...strategys);
-    }
     getStrategies() {
       const [serverName, apiName] = this.apiInstance.name.split(".");
       const serverStrategies = StrategyMap.get(serverName) ?? [];
@@ -4390,6 +4393,11 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       __publicField(this, "BaseURL");
       __publicField(this, "Version");
       __publicField(this, "EnableLog", false);
+      __publicField(this, "registerStrategies", (...strategys) => {
+        const serverStrategies = StrategyMap.get(this.Name) ?? [];
+        serverStrategies.push(...strategys);
+        StrategyMap.set(this.Name, serverStrategies);
+      });
       const options = this.getServerOptions();
       this.Name = options.name ?? this.constructor.name;
       this.init();
@@ -4432,11 +4440,6 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         VersioningMap.set(this.Name, versioning);
       }
     }
-    registerStrategies(...strategys) {
-      const serverStrategies = StrategyMap.get(this.Name) ?? [];
-      serverStrategies.push(...strategys);
-      StrategyMap.set(this.Name, serverStrategies);
-    }
     createApi(constructor) {
       const serverVersioning = Reflect.getMetadata(
         VERSIONING_KEY,
@@ -4566,6 +4569,11 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       __publicField(this, "Url");
       __publicField(this, "Timeout");
       __publicField(this, "EnableLog");
+      __publicField(this, "registerStrategies", (...strategys) => {
+        const serverStrategies = StrategyMap.get(this.Name) ?? [];
+        serverStrategies.push(...strategys);
+        StrategyMap.set(this.Name, serverStrategies);
+      });
       const apiConfig = this.getApiConfig();
       if (!apiConfig) {
         throw new Error("Create SnailApi must be used for @Api() decoration");
@@ -4587,11 +4595,6 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       const serverStrategies = Reflect.getMetadata(STRATEGY_KEY, this.constructor) || [];
       StrategyMap.set(this.Name, serverStrategies);
     }
-    registerStrategies(...strategys) {
-      const serverStrategies = StrategyMap.get(this.Name) ?? [];
-      serverStrategies.push(...strategys);
-      StrategyMap.set(this.Name, serverStrategies);
-    }
     initName() {
       const { name } = this.getApiConfig();
       const apiName = name ?? this.constructor.name;

package/dist/typings/apiProxy.d.ts

@@ -1,11 +1,11 @@
-import { ResponseData, ResponseJsonData, SpecialResponseData, StandardResponseData } from "./response.data";
+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 = StandardResponseData<ResponseJsonData>, DK extends string = "data"> = {
+export type ApiProxy<T extends object, RT extends ResponseData = StandardResponseData, 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 & {
         [KK in DK]: RD;
     }> : T[K];

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

@@ -6,7 +6,7 @@ export interface PaginationData<T> {
 }
 export type ResponseJsonData = Record<string, any> | object;
 export type SpecialResponseData = string | ArrayBuffer | Blob | FormData;
-export type StandardResponseData<T extends ResponseJsonData = Record<string, any>> = {
+export type StandardResponseData<T = any> = {
     code: number;
     message: string;
     data: T;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snail-js/api",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "description": "Http Request with Decorators Api, build on axios",
   "type": "module",
   "main": "./src/index.ts",
@@ -26,7 +26,7 @@
   "author": "",
   "license": "MIT",
   "peerDependencies": {
-    "axios": "^1.7.9"
+    "axios": "^1.8.3"
   },
   "files": [
     "README.md",