@andbridge/glowpod 1.0.0

package/glowpod.ts

@@ -0,0 +1,3 @@
+import GlowPod from "./src/core/core";
+export * from "./src/interceptors/interceptors";
+export default GlowPod;

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@andbridge/glowpod",
+  "version": "1.0.0",
+  "description": "",
+  "main": "glowpod.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "packageManager": "pnpm@10.15.0",
+  "devDependencies": {
+    "typescript": "~5.9.3"
+  },
+  "dependencies": {
+    "axios": "^1.13.2",
+    "element-plus": "^2.11.7"
+  }
+}

package/src/config/config.ts

@@ -0,0 +1,2 @@
+
+

package/src/core/core.ts

@@ -0,0 +1,45 @@
+import type { Options, Response } from "../model/model";
+import axios, { AxiosInstance, CreateAxiosDefaults } from "axios";
+export default class Core {
+  protected instance: AxiosInstance;
+
+  constructor(options: CreateAxiosDefaults) {
+    this.instance = axios.create(options);
+  }
+
+  public getInstance = () => {
+    return this.instance;
+  };
+  public Get = <T>(options: Options): T =>
+    this.instance({
+      method: "GET",
+      url: options.url,
+      params: options.params,
+      headers: { ...options.headers },
+      ...options.others,
+    }) as unknown as T;
+  public Put = <T>(options: Options): T =>
+    this.instance({
+      method: "PUT",
+      url: options.url,
+      params: options.params,
+      headers: { ...options.headers },
+      ...options.others,
+    }) as unknown as T;
+  public Delete = <T>(options: Options): T =>
+    this.instance({
+      method: "DELETE",
+      url: options.url,
+      params: options.params,
+      headers: { ...options.headers },
+      ...options.others,
+    }) as unknown as T;
+  public Post = <T>(options: Options): T =>
+    this.instance({
+      method: "POST",
+      url: options.url,
+      data: options.params,
+      headers: { ...options.headers },
+      ...options.others,
+    }) as unknown as T;
+}

package/src/interceptors/interceptors.tsx

@@ -0,0 +1,105 @@
+import {
+  AxiosInstance,
+  AxiosResponse,
+  AxiosError,
+  InternalAxiosRequestConfig,
+} from "axios";
+import { InterceptorsOptions, Response } from "../model/model";
+
+/**
+ * 设置拦截器
+ * @param instance axios实例
+ * @param @InterceptorsOptions
+ * @returns void
+ */
+
+const _authFailedCaller = () => {};
+
+const _networkFailedCaller = () => {};
+
+const _serverKillCaller = () => {};
+
+enum NetworkStatus {
+  success = 200,
+}
+
+export const setupInterceptors = ({
+  instance,
+  authTokenStorageName = "token",
+  authFailedCaller = _authFailedCaller,
+  networkSuccessCode = 200,
+  authFailedCode = 401,
+  networkFailedCaller = _networkFailedCaller,
+  serverKillCaller = _serverKillCaller,
+  responseStruct = {
+    codeName: "code",
+    messageName: "message",
+    dataName: "data",
+  },
+}: InterceptorsOptions & {
+  instance: AxiosInstance;
+}) => {
+  let timer: NodeJS.Timeout | null = null;
+  let isDefaultOpenErrorHandle = true;
+  const defaultErrorHandler = (response: any) => {
+    const hiddenDefaultErrorHandler = () => (isDefaultOpenErrorHandle = false);
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      if (!isDefaultOpenErrorHandle) return;
+      if (response.status != NetworkStatus.success) {
+        serverKillCaller();
+        return;
+      }
+      if (response.data?.[responseStruct.codeName] == authFailedCode) {
+        authFailedCaller();
+      }
+      if (response.data?.[responseStruct.codeName] != networkSuccessCode) {
+        networkFailedCaller();
+      }
+    }, 0);
+    return hiddenDefaultErrorHandler;
+  };
+
+  // 请求拦截器
+  instance.interceptors.request.use(
+    async (config) => {
+      // 从存储中获取token
+      const token = localStorage.getItem(authTokenStorageName as string);
+      if (token && config.headers) {
+        config.headers.set(authTokenStorageName, token);
+      }
+      return config;
+    },
+    (error: AxiosError) => {
+      console.log("请求错误拦截器:", error);
+      defaultErrorHandler(error);
+      return Promise.reject(error);
+    }
+  );
+
+  // 响应拦截器
+
+  instance.interceptors.response.use(
+    (response) => {
+      if (response.config.responseType === "blob") {
+        return response;
+      } else {
+        switch (response.data?.[responseStruct.codeName]) {
+          case networkSuccessCode:
+            return response.data?.[responseStruct.dataName];
+          default:
+            const hiddenDefaultErrorHandler = defaultErrorHandler(response);
+            throw {
+              ...response,
+              hiddenDefaultErrorHandler,
+              uri: instance.getUri(),
+            };
+        }
+      }
+    },
+    (error: AxiosError) => {
+      const hiddenDefaultErrorHandler = defaultErrorHandler(error);
+      throw { ...error, hiddenDefaultErrorHandler, uri: instance.getUri() };
+    }
+  );
+};

package/src/model/model.ts

@@ -0,0 +1,31 @@
+import { AxiosError, AxiosResponse } from "axios";
+
+export interface Options {
+  url: string;
+  headers?: {};
+  params?: {} | null;
+  [key: string]: any;
+}
+
+export interface Response<T> {
+  code: number;
+  message: string;
+  data: T;
+}
+
+export interface ResponseError<T = unknown, D = any> extends AxiosError<T, D> {
+  hiddenDefaultErrorHandler(): void;
+}
+export type InterceptorsOptions = {
+  authTokenStorageName?: string;
+  networkSuccessCode?: number;
+  authFailedCode?: number;
+  authFailedCaller?: Function;
+  networkFailedCaller?: Function;
+  serverKillCaller?: Function;
+  responseStruct?: {
+    codeName?: string;
+    messageName?: string;
+    dataName?: string;
+  };
+};

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"]
+    },
+    "jsx": "react-jsx"
+  }
+}