cosey 0.2.15 → 0.2.17

package/components/table/table-column/table-column.js

@@ -3,7 +3,7 @@ import elTableColumnProps from 'element-plus/es/components/table/src/table-colum
 const tableColumnProps = {
   ...elTableColumnProps,
   slots: {
-    type: [String, Object]
+    type: [String, Object, Function]
   },
   renderer: {
     type: [String, Object],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cosey",
-  "version": "0.2.15",
+  "version": "0.2.17",
   "description": "基于 Vue3 + vite 的后台管理系统框架",
   "type": "module",
   "main": "index.js",

package/request/Http.d.ts

@@ -1,18 +1,19 @@
-import { AxiosInstance, AxiosRequestConfig } from 'axios';
+import { AxiosInstance, type AxiosRequestConfig } from 'axios';
+import { type HttpConfig } from '../config/http';
 export declare class Http {
-    axiosFactory: () => AxiosInstance;
+    axiosFactory: (httpConfig?: HttpConfig) => AxiosInstance;
     axiosIns: AxiosInstance | null;
     controller: AbortController;
     config: AxiosRequestConfig | null;
-    constructor(axiosFactory: () => AxiosInstance);
+    constructor(axiosFactory: (httpConfig?: HttpConfig) => AxiosInstance);
     abort(): void;
-    _request<T = any, D = any>(config: AxiosRequestConfig<D>): Promise<T>;
-    request<T = any, D = any>(config: AxiosRequestConfig<D>): Promise<T>;
-    get<T = any, D = any>(url: string, config?: AxiosRequestConfig<D>): Promise<T>;
-    delete<T = any, D = any>(url: string, config?: AxiosRequestConfig<D>): Promise<T>;
-    head<T = any, D = any>(url: string, config?: AxiosRequestConfig<D>): Promise<T>;
-    options<T = any, D = any>(url: string, config?: AxiosRequestConfig<D>): Promise<T>;
-    post<T = any, D = any>(url: string, data?: D, config?: AxiosRequestConfig<D>): Promise<T>;
-    put<T = any, D = any>(url: string, data?: D, config?: AxiosRequestConfig<D>): Promise<T>;
-    patch<T = any, D = any>(url: string, data?: D, config?: AxiosRequestConfig<D>): Promise<T>;
+    _request<T = any, D = any>(config: AxiosRequestConfig<D>, httpConfig?: HttpConfig): Promise<T>;
+    request<T = any, D = any>(config: AxiosRequestConfig<D>, httpConfig?: HttpConfig): Promise<T>;
+    get<T = any, D = any>(url: string, config?: AxiosRequestConfig<D>, httpConfig?: HttpConfig): Promise<T>;
+    delete<T = any, D = any>(url: string, config?: AxiosRequestConfig<D>, httpConfig?: HttpConfig): Promise<T>;
+    head<T = any, D = any>(url: string, config?: AxiosRequestConfig<D>, httpConfig?: HttpConfig): Promise<T>;
+    options<T = any, D = any>(url: string, config?: AxiosRequestConfig<D>, httpConfig?: HttpConfig): Promise<T>;
+    post<T = any, D = any>(url: string, data?: D, config?: AxiosRequestConfig<D>, httpConfig?: HttpConfig): Promise<T>;
+    put<T = any, D = any>(url: string, data?: D, config?: AxiosRequestConfig<D>, httpConfig?: HttpConfig): Promise<T>;
+    patch<T = any, D = any>(url: string, data?: D, config?: AxiosRequestConfig<D>, httpConfig?: HttpConfig): Promise<T>;
 }

package/request/Http.js

@@ -12,69 +12,90 @@ class Http {
       this.controller.abort();
     }
   }
-  _request(config) {
+  _request(config, httpConfig) {
     if (!config.signal) {
       config.signal = this.controller.signal;
     }
     if (!this.axiosIns) {
-      this.axiosIns = this.axiosFactory();
+      this.axiosIns = this.axiosFactory(httpConfig);
     }
     return this.axiosIns.request(config);
   }
-  request(config) {
-    return this._request(config);
+  request(config, httpConfig) {
+    return this._request(config, httpConfig);
   }
-  get(url, config) {
-    return this._request({
-      ...config,
-      url,
-      method: "get"
-    });
+  get(url, config, httpConfig) {
+    return this._request(
+      {
+        ...config,
+        url,
+        method: "get"
+      },
+      httpConfig
+    );
   }
-  delete(url, config) {
-    return this._request({
-      ...config,
-      url,
-      method: "delete"
-    });
+  delete(url, config, httpConfig) {
+    return this._request(
+      {
+        ...config,
+        url,
+        method: "delete"
+      },
+      httpConfig
+    );
   }
-  head(url, config) {
-    return this._request({
-      ...config,
-      url,
-      method: "head"
-    });
+  head(url, config, httpConfig) {
+    return this._request(
+      {
+        ...config,
+        url,
+        method: "head"
+      },
+      httpConfig
+    );
   }
-  options(url, config) {
-    return this._request({
-      ...config,
-      url,
-      method: "options"
-    });
+  options(url, config, httpConfig) {
+    return this._request(
+      {
+        ...config,
+        url,
+        method: "options"
+      },
+      httpConfig
+    );
   }
-  post(url, data, config) {
-    return this._request({
-      ...config,
-      url,
-      data,
-      method: "post"
-    });
+  post(url, data, config, httpConfig) {
+    return this._request(
+      {
+        ...config,
+        url,
+        data,
+        method: "post"
+      },
+      httpConfig
+    );
   }
-  put(url, data, config) {
-    return this._request({
-      ...config,
-      url,
-      data,
-      method: "put"
-    });
+  put(url, data, config, httpConfig) {
+    return this._request(
+      {
+        ...config,
+        url,
+        data,
+        method: "put"
+      },
+      httpConfig
+    );
   }
-  patch(url, data, config) {
-    return this._request({
-      ...config,
-      url,
-      data,
-      method: "patch"
-    });
+  patch(url, data, config, httpConfig) {
+    return this._request(
+      {
+        ...config,
+        url,
+        data,
+        method: "patch"
+      },
+      httpConfig
+    );
   }
 }
 

package/request/useRequest.d.ts

@@ -1,6 +1,7 @@
 import { type CreateAxiosDefaults } from 'axios';
 import { Http } from './Http';
-export declare function useRequest(config?: CreateAxiosDefaults): {
+import { type HttpConfig } from '../config/http';
+export declare function useRequest(config?: CreateAxiosDefaults, useHttpConfig?: HttpConfig): {
     fn: <T extends (http: Http) => (...args: any[]) => any, R = {
         (...args: Parameters<ReturnType<T>>): ReturnType<ReturnType<T>>;
         abort: () => void;

package/request/useRequest.js

@@ -1,7 +1,7 @@
 import { useRouter, useRoute } from 'vue-router';
 import axios, { AxiosError } from 'axios';
 import { ElMessage } from 'element-plus';
-import { defaults, pick, get } from 'lodash-es';
+import { merge, defaults, pick, get } from 'lodash-es';
 import { useUserStore } from '../store/user.js';
 import { TOKEN_NAME, ROUTER_TO } from '../constant.js';
 import { Http } from './Http.js';
@@ -9,25 +9,25 @@ import { useGlobalConfig } from '../config/index.js';
 import { usePersist } from '../hooks/usePersist.js';
 import { isObject } from '../utils/is.js';
 
-function useRequest(config = {}) {
+function useRequest(config = {}, useHttpConfig) {
   const persist = usePersist();
   const userStore = useUserStore();
   const router = useRouter();
   const route = useRoute();
   const { http: httpConfig, router: routerConfig } = useGlobalConfig();
-  const handleError = (resData) => {
-    const httpPath = httpConfig.path;
+  const handleError = (resData, mergedHttpConfig) => {
+    const httpPath = mergedHttpConfig.path;
     const code = get(resData, httpPath.code);
     const message = get(resData, httpPath.message) || "Error";
-    const data = get(resData, httpPath.data);
-    if (code !== httpConfig.code.success) {
+    const data = httpPath.data ? get(resData, httpPath.data) : resData;
+    if (code !== mergedHttpConfig.code.success) {
       ElMessage.error({
         message,
-        duration: httpConfig.errorDuration
+        duration: mergedHttpConfig.errorDuration
       });
-      if (code === httpConfig.code.forbidden) {
+      if (code === mergedHttpConfig.code.forbidden) {
         router.push(routerConfig.homePath);
-      } else if (code === httpConfig.code.unauthorized) {
+      } else if (code === mergedHttpConfig.code.unauthorized) {
         if (persist.get(TOKEN_NAME)) {
           userStore.logout(persist.get(ROUTER_TO) || route.fullPath);
         }
@@ -36,23 +36,24 @@ function useRequest(config = {}) {
     }
     return data;
   };
-  const createAxios = () => {
+  const createAxios = (createHttpConfig) => {
+    const mergedHttpConfig = merge({}, httpConfig, useHttpConfig, createHttpConfig);
     const axiosIns = axios.create(
-      defaults(config, pick(httpConfig, ["baseURL", "timeout", "headers"]))
+      defaults(config, pick(mergedHttpConfig, ["baseURL", "timeout", "headers"]))
     );
     axiosIns.interceptors.request.use(
       (config2) => {
-        Object.assign(config2, httpConfig.headers);
+        Object.assign(config2, mergedHttpConfig.headers);
         const token = persist.get(TOKEN_NAME);
         if (token) {
-          config2.headers[httpConfig.authHeaderKey] = httpConfig.authScheme ? `${httpConfig.authScheme} ${token}` : token;
+          config2.headers[mergedHttpConfig.authHeaderKey] = mergedHttpConfig.authScheme ? `${mergedHttpConfig.authScheme} ${token}` : token;
         }
         return config2;
       },
       (error) => {
         ElMessage.error({
           message: error,
-          duration: httpConfig.errorDuration
+          duration: mergedHttpConfig.errorDuration
         });
         return Promise.reject(error);
       }
@@ -60,15 +61,15 @@ function useRequest(config = {}) {
     axiosIns.interceptors.response.use(
       (response) => {
         const { data: resData } = response;
-        return handleError(resData);
+        return handleError(resData, mergedHttpConfig);
       },
       (error) => {
-        if (error instanceof AxiosError && error.response && isObject(error.response.data) && get(error.response.data, httpConfig.path.code)) {
-          return handleError(error.response.data);
+        if (error instanceof AxiosError && error.response && isObject(error.response.data) && get(error.response.data, mergedHttpConfig.path.code)) {
+          return handleError(error.response.data, mergedHttpConfig);
         } else {
           ElMessage.error({
             message: error.message,
-            duration: httpConfig.errorDuration
+            duration: mergedHttpConfig.errorDuration
           });
           return Promise.reject(error);
         }