rxtutils 1.1.4-beta.9 → 1.1.6

package/es/request/index.mjs

@@ -1,176 +1,198 @@
-import { __assign, __awaiter, __generator } from 'tslib';
-import axios from 'axios';
-import at from 'lodash-es/at';
-import { _defaultErrorCodeHandler, _defaultHttpErrorCodeHandler, _defaultOtherErrorCodeHandler } from './defaultHandlers.mjs';
-import defaultEquals from '../_utils/defaultEquals.mjs';
-import Cache from '../cache/index.mjs';
-import RequestError from './error.mjs';
-import { deepAssign } from '../_utils/deepAssign.mjs';
-
-/**
- * 创建基础请求实例
- * @param baseOptions 基础配置选项
- * @returns 请求创建函数
- */
+import axios from "axios";
+import at from "lodash-es/at";
+import { _defaultErrorCodeHandler, _defaultHttpErrorCodeHandler, _defaultOtherErrorCodeHandler } from "./defaultHandlers.mjs";
+import defaultEquals from "../_utils/defaultEquals.mjs";
+import Cache from "../cache/index.mjs";
+import RequestError from "./error.mjs";
 function createBaseRequest(baseOptions) {
-    var baseURL = Object(baseOptions).baseURL;
-    // 创建新的 Axios 实例并配置基础URL和跨域凭证
-    var instance = axios.create({
-        baseURL: baseURL,
-        withCredentials: true,
-    });
-    /**
-     * 创建请求函数
-     * @template Param 请求参数类型
-     * @template Data 响应数据类型，必须是对象类型
-     * @param requestOptions 请求配置
-     * @param createOptions 创建选项（覆盖基础配置）
-     * @returns 发送请求的函数
-     */
-    return function createRequest(requestOptions, createOptions) {
-        var _a = __assign({}, requestOptions), method = _a.method, url = _a.url;
-        var _b = __assign(__assign({}, baseOptions), createOptions), baseURL = _b.baseURL, _c = _b.cacheDataKey, cacheDataKey = _c === void 0 ? "".concat(method, ":").concat(baseURL).concat(url) : _c, cacheDataInStorage = _b.cacheDataInStorage, _d = _b.cacheKeyEquals, cacheKeyEquals = _d === void 0 ? defaultEquals : _d, cacheTime = _b.cacheTime, _e = _b.indexDBName, indexDBName = _e === void 0 ? "__apiCacheDatabase__" : _e;
-        var cache = new Cache(cacheDataInStorage, cacheDataKey, cacheTime, indexDBName, cacheKeyEquals);
-        function request(requestParam, options) {
-            return __awaiter(this, void 0, void 0, function () {
-                var _a, _b, requestMiddlewares, _c, finalAxiosOptions, finalRequestOptions, _i, requestMiddlewares_1, middleware, _d, nextAxiosOptions, nextRequestOptions, method, url, _e, data, _f, params, requestDataOrParams, _g, defaultMessageShower, _h, _j, enableCache, _k, cacheData, _l, defaultErrorCodeHandler, _m, defaultHttpErrorCodeHandler, _o, otherErrorHandler, _p, errorCodePath, _q, cacheTime, _r, errorCodeMap, _s, successCodes, _t, httpErrorCodeMap, _u, 
-                // axiosOptions = {},
-                throwError, cacheItem;
-                var _this = this;
-                return __generator(this, function (_v) {
-                    switch (_v.label) {
-                        case 0:
-                            _a = __assign(__assign(__assign({}, baseOptions), createOptions), options), _b = _a.requestMiddlewares, requestMiddlewares = _b === void 0 ? [] : _b, _c = _a.axiosOptions, finalAxiosOptions = _c === void 0 ? {} : _c;
-                            finalRequestOptions = __assign(__assign({}, requestOptions), requestParam);
-                            _i = 0, requestMiddlewares_1 = requestMiddlewares;
-                            _v.label = 1;
-                        case 1:
-                            if (!(_i < requestMiddlewares_1.length)) return [3 /*break*/, 4];
-                            middleware = requestMiddlewares_1[_i];
-                            return [4 /*yield*/, middleware(finalAxiosOptions, finalRequestOptions)];
-                        case 2:
-                            _d = _v.sent(), nextAxiosOptions = _d.axiosOptions, nextRequestOptions = _d.requestOptions;
-                            deepAssign({}, finalAxiosOptions, nextAxiosOptions);
-                            deepAssign({}, finalRequestOptions, nextRequestOptions);
-                            _v.label = 3;
-                        case 3:
-                            _i++;
-                            return [3 /*break*/, 1];
-                        case 4:
-                            method = finalRequestOptions.method, url = finalRequestOptions.url, _e = finalRequestOptions.data, data = _e === void 0 ? {} : _e, _f = finalRequestOptions.params, params = _f === void 0 ? {} : _f;
-                            requestDataOrParams = params;
-                            if (method.toLowerCase() === "post") {
-                                requestDataOrParams = data;
-                            }
-                            _g = __assign(__assign(__assign({}, baseOptions), createOptions), options).defaultMessageShower, defaultMessageShower = _g === void 0 ? console.error : _g;
-                            _h = __assign(__assign(__assign({}, baseOptions), createOptions), options), _j = _h.enableCache, enableCache = _j === void 0 ? false : _j, _k = _h.cacheData, cacheData = _k === void 0 ? false : _k, _l = _h.defaultErrorCodeHandler, defaultErrorCodeHandler = _l === void 0 ? _defaultErrorCodeHandler.bind(null, defaultMessageShower) : _l, _m = _h.defaultHttpErrorCodeHandler, defaultHttpErrorCodeHandler = _m === void 0 ? _defaultHttpErrorCodeHandler.bind(null, defaultMessageShower) : _m, _o = _h.otherErrorHandler, otherErrorHandler = _o === void 0 ? _defaultOtherErrorCodeHandler.bind(null, defaultMessageShower) : _o, _p = _h.errorCodePath, errorCodePath = _p === void 0 ? "code" : _p, _q = _h.cacheTime, cacheTime = _q === void 0 ? 60 : _q, _r = _h.errorCodeMap, errorCodeMap = _r === void 0 ? {} : _r, _s = _h.successCodes, successCodes = _s === void 0 ? ["0", "200"] : _s, _t = _h.httpErrorCodeMap, httpErrorCodeMap = _t === void 0 ? {} : _t, _u = _h.throwError, throwError = _u === void 0 ? true : _u;
-                            if (enableCache) {
-                                cacheItem = cache.getCache(requestDataOrParams);
-                                if (cacheItem) {
-                                    return [2 /*return*/, Promise.resolve(cacheItem)];
-                                }
-                            }
-                            return [2 /*return*/, instance
-                                    .request(__assign({ method: method, url: url, data: data, params: params }, finalAxiosOptions))
-                                    .then(function (res) { return __awaiter(_this, void 0, void 0, function () {
-                                    var errorCode, _a, _b, _c, customHandler, err, _d, _e, replaceResData, _f, handlerThrowError, _g;
-                                    return __generator(this, function (_h) {
-                                        switch (_h.label) {
-                                            case 0:
-                                                errorCode = String(at(res.data, errorCodePath));
-                                                if (successCodes.includes(errorCode)) {
-                                                    if (cacheData) {
-                                                        cache.setCache(requestDataOrParams, res.data, { cacheTime: cacheTime });
-                                                    }
-                                                    return [2 /*return*/, res.data];
-                                                }
-                                                _a = errorCodeMap, _b = errorCode, _c = _a[_b], customHandler = _c === void 0 ? defaultErrorCodeHandler : _c;
-                                                err = new RequestError("服务端错误", "server", res);
-                                                if (!(typeof customHandler === "string")) return [3 /*break*/, 1];
-                                                defaultMessageShower(customHandler);
-                                                return [3 /*break*/, 3];
-                                            case 1:
-                                                _g = Object;
-                                                return [4 /*yield*/, customHandler(errorCode, res.data, res, __assign(__assign({}, requestOptions), requestParam))];
-                                            case 2:
-                                                _d = _g.apply(void 0, [(_h.sent())]), _e = _d.replaceResData, replaceResData = _e === void 0 ? res.data : _e, _f = _d.throwError, handlerThrowError = _f === void 0 ? "default" : _f;
-                                                res.data = replaceResData;
-                                                switch (handlerThrowError) {
-                                                    case true:
-                                                        throw err;
-                                                    case false:
-                                                        return [2 /*return*/, res.data];
-                                                }
-                                                _h.label = 3;
-                                            case 3:
-                                                if (throwError) {
-                                                    throw err;
-                                                }
-                                                return [2 /*return*/, res.data];
-                                        }
-                                    });
-                                }); }, function (error) { return __awaiter(_this, void 0, void 0, function () {
-                                    var resData, _a, _b, _c, customHandler, err, _d, _e, replaceResData, _f, handlerThrowError, _g, resData, err, _h, _j, replaceResData, _k, handlerThrowError, _l;
-                                    return __generator(this, function (_m) {
-                                        switch (_m.label) {
-                                            case 0:
-                                                if (!error.response) return [3 /*break*/, 4];
-                                                resData = error;
-                                                _a = httpErrorCodeMap, _b = error.response.status, _c = _a[_b], customHandler = _c === void 0 ? defaultHttpErrorCodeHandler : _c;
-                                                err = new RequestError("服务端错误", "http", error);
-                                                if (!(typeof customHandler === "string")) return [3 /*break*/, 1];
-                                                defaultMessageShower(customHandler);
-                                                return [3 /*break*/, 3];
-                                            case 1:
-                                                _g = Object;
-                                                return [4 /*yield*/, customHandler(error.response.status, error, __assign(__assign({}, requestOptions), requestParam))];
-                                            case 2:
-                                                _d = _g.apply(void 0, [(_m.sent())]), _e = _d.replaceResData, replaceResData = _e === void 0 ? error : _e, _f = _d.throwError, handlerThrowError = _f === void 0 ? "default" : _f;
-                                                resData = replaceResData;
-                                                switch (handlerThrowError) {
-                                                    case true:
-                                                        throw err;
-                                                    case false:
-                                                        return [2 /*return*/, resData];
-                                                }
-                                                _m.label = 3;
-                                            case 3:
-                                                if (throwError) {
-                                                    throw err;
-                                                }
-                                                return [2 /*return*/, resData];
-                                            case 4:
-                                                resData = error;
-                                                err = new RequestError("服务端错误", "http", error);
-                                                err.type = "http";
-                                                err.data = error;
-                                                _l = Object;
-                                                return [4 /*yield*/, otherErrorHandler(error)];
-                                            case 5:
-                                                _h = (_l.apply(void 0, [(_m.sent())])), _j = _h.replaceResData, replaceResData = _j === void 0 ? error : _j, _k = _h.throwError, handlerThrowError = _k === void 0 ? "default" : _k;
-                                                resData = replaceResData;
-                                                switch (handlerThrowError) {
-                                                    case true:
-                                                        throw err;
-                                                    case false:
-                                                        return [2 /*return*/, resData];
-                                                }
-                                                if (throwError) {
-                                                    throw err;
-                                                }
-                                                return [2 /*return*/, resData];
-                                        }
-                                    });
-                                }); })];
-                    }
-                });
-            });
+  const { baseURL } = Object(baseOptions);
+  const instance = axios.create({
+    baseURL
+  });
+  return function createRequest(requestOptions, createOptions) {
+    const { method, url } = { ...requestOptions };
+    const {
+      baseURL: baseURL2,
+      cacheDataKey = `${method}:${baseURL2}${url}`,
+      cacheDataInStorage,
+      cacheKeyEquals = defaultEquals,
+      cacheTime,
+      indexDBName = "__apiCacheDatabase__"
+    } = {
+      ...baseOptions,
+      ...createOptions
+    };
+    const cache = new Cache(
+      cacheDataInStorage,
+      cacheDataKey,
+      cacheTime,
+      indexDBName,
+      cacheKeyEquals
+    );
+    async function request(requestParam, options) {
+      const mergedOptions = {
+        ...baseOptions,
+        ...createOptions,
+        ...options
+      };
+      let {
+        requestMiddlewares = [],
+        axiosOptions: finalAxiosOptions = {},
+        requestParamsOrDataTransfer,
+        responseTransfer
+      } = mergedOptions;
+      let finalRequestOptions = { ...requestOptions, ...requestParam };
+      for (const middleware of requestMiddlewares) {
+        const {
+          axiosOptions: nextAxiosOptions = finalAxiosOptions,
+          requestOptions: nextRequestOptions = finalRequestOptions
+        } = await middleware(
+          { ...mergedOptions, axiosOptions: finalAxiosOptions },
+          finalRequestOptions
+        );
+        finalAxiosOptions = nextAxiosOptions;
+        finalRequestOptions = nextRequestOptions;
+      }
+      const { method: method2, url: url2, data = {}, params = {} } = finalRequestOptions;
+      let requestDataOrParams = params;
+      if (method2.toLowerCase() === "post") {
+        requestDataOrParams = data;
+      }
+      const { defaultMessageShower = console.error } = {
+        ...baseOptions,
+        ...createOptions,
+        ...options
+      };
+      const {
+        enableCache = false,
+        cacheData = false,
+        defaultErrorCodeHandler = _defaultErrorCodeHandler.bind(null, defaultMessageShower),
+        defaultHttpErrorCodeHandler = _defaultHttpErrorCodeHandler.bind(null, defaultMessageShower),
+        otherErrorHandler = _defaultOtherErrorCodeHandler.bind(null, defaultMessageShower),
+        errorCodePath = "code",
+        cacheTime: cacheTime2 = 60,
+        errorCodeMap = {},
+        successCodes = ["0", "200"],
+        httpErrorCodeMap = {},
+        // axiosOptions = {},
+        throwError = true,
+        retryTimes = 0
+      } = { ...baseOptions, ...createOptions, ...options };
+      if (enableCache) {
+        const cacheItem = cache.getCache(requestDataOrParams);
+        if (cacheItem) {
+          return Promise.resolve(cacheItem);
+        }
+      }
+      function retry() {
+        if (retryTimes > 0) {
+          return request(requestParam, { ...options, retryTimes: retryTimes - 1 });
+        }
+        return null;
+      }
+      return instance.request({
+        method: method2,
+        url: url2,
+        data: requestParamsOrDataTransfer ? requestParamsOrDataTransfer(data) : data,
+        params: requestParamsOrDataTransfer ? requestParamsOrDataTransfer(params) : params,
+        ...finalAxiosOptions
+      }).then(
+        async (res) => {
+          const errorCode = String(at(res.data, errorCodePath));
+          let finalData = responseTransfer ? responseTransfer(res.data) : res.data;
+          if (successCodes.includes(errorCode)) {
+            if (cacheData) {
+              cache.setCache(requestDataOrParams, finalData, { cacheTime: cacheTime2 });
+            }
+            return finalData;
+          }
+          const { [errorCode]: customHandler = defaultErrorCodeHandler } = errorCodeMap;
+          const err = new RequestError("服务端错误", "server", res);
+          if (typeof customHandler === "string") {
+            defaultMessageShower(customHandler);
+            const retryTask = retry();
+            if (retryTask) return retryTask;
+          } else {
+            const { replaceResData = res.data, throwError: handlerThrowError = "default" } = Object(
+              await customHandler(errorCode, res.data, res, {
+                ...requestOptions,
+                ...requestParam
+              })
+            );
+            const retryTask = retry();
+            if (retryTask) return retryTask;
+            res.data = replaceResData;
+            switch (handlerThrowError) {
+              case true:
+                throw err;
+              case false:
+                return res.data;
+            }
+          }
+          if (throwError) {
+            throw err;
+          }
+          return res.data;
+        },
+        async (error) => {
+          if (error.response) {
+            let resData = error;
+            const { [error.response.status]: customHandler = defaultHttpErrorCodeHandler } = httpErrorCodeMap;
+            const err = new RequestError("服务端错误", "http", error);
+            if (typeof customHandler === "string") {
+              defaultMessageShower(customHandler);
+              const retryTask = retry();
+              if (retryTask) return retryTask;
+            } else {
+              const { replaceResData = error, throwError: handlerThrowError = "default" } = Object(
+                await customHandler(error.response.status, error, {
+                  ...requestOptions,
+                  ...requestParam
+                })
+              );
+              const retryTask = retry();
+              if (retryTask) return retryTask;
+              resData = replaceResData;
+              switch (handlerThrowError) {
+                case true:
+                  throw err;
+                case false:
+                  return resData;
+              }
+            }
+            if (throwError) {
+              throw err;
+            }
+            return resData;
+          } else {
+            let resData = error;
+            const err = new RequestError("服务端错误", "http", error);
+            err.type = "http";
+            err.data = error;
+            const { replaceResData = error, throwError: handlerThrowError = "default" } = Object(await otherErrorHandler(error));
+            const retryTask = retry();
+            if (retryTask) return retryTask;
+            resData = replaceResData;
+            switch (handlerThrowError) {
+              case true:
+                throw err;
+              case false:
+                return resData;
+            }
+            if (throwError) {
+              throw err;
+            }
+            return resData;
+          }
         }
-        request.clearCache = function () {
-            cache.clear();
-        };
-        return request;
+      );
+    }
+    request.clearCache = () => {
+      cache.clear();
     };
+    return request;
+  };
 }
-
-export { createBaseRequest as default };
+export {
+  createBaseRequest as default
+};

package/es/store/createGetter/index.d.ts

@@ -1,12 +1,11 @@
-import createStateStore from '../createStateStore/index.js';
-
-type StoreGetter<S = any> = {
+import { default as createStateStore } from '../createStateStore';
+export type StoreGetter<S = any> = {
     [K in string]: (store: S) => any;
 };
-type GetterNameMap<G extends StoreGetter<any>> = {
+export type GetterNameMap<G extends StoreGetter<any>> = {
     [K in keyof G]: string;
 };
-type ReducedData<G extends StoreGetter<any>, M extends GetterNameMap<G>> = {
+export type ReducedData<G extends StoreGetter<any>, M extends GetterNameMap<G>> = {
     [K in keyof M as M[K]]: G[K extends keyof G ? K : never] extends (store: any) => infer R ? R : never;
 };
 /**
@@ -16,7 +15,7 @@ type ReducedData<G extends StoreGetter<any>, M extends GetterNameMap<G>> = {
  * @param getterNameMaps 将 getter 函数和 getter 名称一一映射
  * @returns getter object
  */
-declare const createStoreGetter: <S, G extends StoreGetter<S>, M extends GetterNameMap<G>>(store: ReturnType<typeof createStateStore<S>>, getters: G, getterNameMaps: M) => ReducedData<G, M>;
+export declare const createStoreGetter: <S, G extends StoreGetter<S>, M extends GetterNameMap<G>>(store: ReturnType<typeof createStateStore<S>>, getters: G, getterNameMaps: M) => ReducedData<G, M>;
 /**
  *
  * @param store store实例
@@ -24,7 +23,4 @@ declare const createStoreGetter: <S, G extends StoreGetter<S>, M extends GetterN
  * @param getterNameMaps 将 getter 函数和 getter 名称一一映射
  * @returns getter memo hook
  */
-declare const createStoreGetterMemo: <S, G extends StoreGetter<S>, M extends GetterNameMap<G>>(store: ReturnType<typeof createStateStore<S>>, getters: G, getterNameMaps: M) => () => ReducedData<G, M>;
-
-export { createStoreGetter, createStoreGetterMemo };
-export type { GetterNameMap, ReducedData, StoreGetter };
+export declare const createStoreGetterMemo: <S, G extends StoreGetter<S>, M extends GetterNameMap<G>>(store: ReturnType<typeof createStateStore<S>>, getters: G, getterNameMaps: M) => () => ReducedData<G, M>;

package/es/store/createGetter/index.mjs

@@ -1,42 +1,31 @@
-import { useMemo } from 'react';
-
-/**
- * 创建 store getter
- * @param store store实例
- * @param getters getter函数
- * @param getterNameMaps 将 getter 函数和 getter 名称一一映射
- * @returns getter object
- */
-var createStoreGetter = function (store, getters, getterNameMaps) {
-    var gettersObj = {};
-    Object.keys(getters).forEach(function (key) {
-        Object.defineProperty(gettersObj, getterNameMaps[key], {
-            get: function () { return getters[key](store.get()); }
-        });
+import { useMemo } from "react";
+const createStoreGetter = (store, getters, getterNameMaps) => {
+  const gettersObj = {};
+  Object.keys(getters).forEach((key) => {
+    Object.defineProperty(gettersObj, getterNameMaps[key], {
+      get: () => getters[key](store.get())
     });
-    return gettersObj;
+  });
+  return gettersObj;
 };
-/**
- *
- * @param store store实例
- * @param getters getter函数
- * @param getterNameMaps 将 getter 函数和 getter 名称一一映射
- * @returns getter memo hook
- */
-var createStoreGetterMemo = function (store, getters, getterNameMaps) {
-    // 创建缓存数据 hook
-    return function () {
-        var storeData = store.use()[0];
-        var reducedData = useMemo(function () {
-            return Object.keys(getters).reduce(function (acc, key) {
-                var mappedKey = getterNameMaps[key];
-                var getterValue = getters[key](storeData);
-                acc[mappedKey] = getterValue;
-                return acc;
-            }, {});
-        }, [storeData]);
-        return reducedData;
-    };
+const createStoreGetterMemo = (store, getters, getterNameMaps) => {
+  return () => {
+    const [storeData] = store.use();
+    const reducedData = useMemo(() => {
+      return Object.keys(getters).reduce(
+        (acc, key) => {
+          const mappedKey = getterNameMaps[key];
+          const getterValue = getters[key](storeData);
+          acc[mappedKey] = getterValue;
+          return acc;
+        },
+        {}
+      );
+    }, [storeData]);
+    return reducedData;
+  };
+};
+export {
+  createStoreGetter,
+  createStoreGetterMemo
 };
-
-export { createStoreGetter, createStoreGetterMemo };

package/es/store/createStateStore/index.d.ts

@@ -2,27 +2,30 @@
  * 状态初始化设置器类型
  * 用于延迟初始化状态的函数类型
  */
-type IHookStateInitialSetter<S> = () => S;
+export type IHookStateInitialSetter<S> = () => S;
 /**
  * 状态初始化动作类型
  * 可以是直接的状态值或初始化设置器
  */
-type IHookStateInitAction<S> = S | IHookStateInitialSetter<S>;
+export type IHookStateInitAction<S> = S | IHookStateInitialSetter<S>;
 /**
  * 状态设置器类型
  * 可以是接收前一个状态的函数或无参数的函数
  */
-type IHookStateSetter<S> = ((prevState: S) => S) | (() => S);
+export type IHookStateSetter<S> = ((prevState: S) => S) | (() => S);
 /**
  * 状态设置动作类型
  * 可以是直接的状态值或状态设置器
  */
-type IHookStateSetAction<S> = S | IHookStateSetter<S>;
+export type IHookStateSetAction<S> = S | IHookStateSetter<S>;
 /**
  * 可解析的状态类型
  * 包含所有可能的状态值或状态设置函数
  */
-type IHookStateResolvable<S> = S | IHookStateInitialSetter<S> | IHookStateSetter<S>;
+export type IHookStateResolvable<S> = S | IHookStateInitialSetter<S> | IHookStateSetter<S>;
+export declare function resolveHookState<S>(nextState: IHookStateInitAction<S>): S;
+export declare function resolveHookState<S, C extends S>(nextState: IHookStateSetAction<S>, currentState: C): S;
+export declare function resolveHookState<S, C extends S>(nextState: IHookStateResolvable<S>, currentState: C): S;
 /**
  * 创建状态存储
  * 提供一个简单的状态管理解决方案，支持组件间状态共享
@@ -31,12 +34,9 @@ type IHookStateResolvable<S> = S | IHookStateInitialSetter<S> | IHookStateSetter
  * @param initialState 初始状态值或初始化函数
  * @returns 包含状态操作方法的对象
  */
-declare function createStateStore<S>(initialState?: S): {
+export default function createStateStore<S>(initialState?: S): {
     use: () => [S, (state: IHookStateSetAction<S>) => void];
     get: () => S;
     set: (state: IHookStateSetAction<S>) => void;
     watch: (callback: (state: S) => S | void) => () => void;
 };
-
-export { createStateStore as default };
-export type { IHookStateInitAction, IHookStateInitialSetter, IHookStateResolvable, IHookStateSetAction, IHookStateSetter };