icode-hooks 0.3.0

package/lib/useRequest/src/plugins/useCachePlugin.js

@@ -0,0 +1,150 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _tslib = require("tslib");
+var _react = require("react");
+var _useCreation = _interopRequireDefault(require("../../../useCreation"));
+var _useUnmount = _interopRequireDefault(require("../../../useUnmount"));
+var _cache = require("../utils/cache");
+var _cachePromise = require("../utils/cachePromise");
+var _cacheSubscribe = require("../utils/cacheSubscribe");
+var useCachePlugin = function useCachePlugin(fetchInstance, _a) {
+  var cacheKey = _a.cacheKey,
+    _b = _a.cacheTime,
+    cacheTime = _b === void 0 ? 5 * 60 * 1000 : _b,
+    _c = _a.staleTime,
+    staleTime = _c === void 0 ? 0 : _c,
+    customSetCache = _a.setCache,
+    customGetCache = _a.getCache;
+  var unSubscribeRef = (0, _react.useRef)();
+  var currentPromiseRef = (0, _react.useRef)();
+  var _setCache = function _setCache(key, cachedData) {
+    if (customSetCache) {
+      customSetCache(cachedData);
+    } else {
+      (0, _cache.setCache)(key, cacheTime, cachedData);
+    }
+    (0, _cacheSubscribe.trigger)(key, cachedData.data);
+  };
+  var _getCache = function _getCache(key, params) {
+    if (params === void 0) {
+      params = [];
+    }
+    if (customGetCache) {
+      return customGetCache(params);
+    }
+    return (0, _cache.getCache)(key);
+  };
+  (0, _useCreation["default"])(function () {
+    if (!cacheKey) {
+      return;
+    }
+    // get data from cache when init
+    var cacheData = _getCache(cacheKey);
+    if (cacheData && Object.hasOwnProperty.call(cacheData, 'data')) {
+      fetchInstance.state.data = cacheData.data;
+      fetchInstance.state.params = cacheData.params;
+      if (staleTime === -1 || new Date().getTime() - cacheData.time <= staleTime) {
+        fetchInstance.state.loading = false;
+      }
+    }
+    // 订阅相同的cachekey更新，触发更新
+    unSubscribeRef.current = (0, _cacheSubscribe.subscribe)(cacheKey, function (data) {
+      fetchInstance.setState({
+        data: data
+      });
+    });
+  }, []);
+  (0, _useUnmount["default"])(function () {
+    var _a;
+    (_a = unSubscribeRef.current) === null || _a === void 0 ? void 0 : _a.call(unSubscribeRef);
+  });
+  // 有缓存才会走下面逻辑
+  if (!cacheKey) {
+    return {};
+  }
+  return {
+    onBefore: function onBefore(params) {
+      // 缓存场景下，直接返回缓存数据
+      var cacheData = _getCache(cacheKey, params);
+      console.log('cacheData', cacheData, '74');
+      if (!cacheData || !Object.hasOwnProperty.call(cacheData, 'data')) {
+        return {};
+      }
+      // If the data is fresh, stop request
+      if (staleTime === -1 || new Date().getTime() - cacheData.time <= staleTime) {
+        return {
+          loading: false,
+          data: cacheData === null || cacheData === void 0 ? void 0 : cacheData.data,
+          error: undefined,
+          returnNow: true
+        };
+      } else {
+        // If the data is stale, return data, and request continue
+        return {
+          data: cacheData === null || cacheData === void 0 ? void 0 : cacheData.data,
+          error: undefined
+        };
+      }
+    },
+    onRequest: function onRequest(service, args) {
+      var servicePromise = (0, _cachePromise.getCachePromise)(cacheKey);
+      console.log('service', servicePromise, args, 'cachePlugin');
+      // If has servicePromise, and is not trigger by self, then use it
+      if (servicePromise && servicePromise !== currentPromiseRef.current) {
+        return {
+          servicePromise: servicePromise
+        };
+      }
+      servicePromise = service.apply(void 0, (0, _tslib.__spreadArray)([], (0, _tslib.__read)(args), false));
+      currentPromiseRef.current = servicePromise;
+      (0, _cachePromise.setCachePromise)(cacheKey, servicePromise);
+      return {
+        servicePromise: servicePromise
+      };
+    },
+    onSuccess: function onSuccess(data, params) {
+      var _a;
+      console.log('onSuccess', cacheKey, data);
+      if (cacheKey) {
+        // cancel subscribe, avoid trgger self
+        (_a = unSubscribeRef.current) === null || _a === void 0 ? void 0 : _a.call(unSubscribeRef);
+        _setCache(cacheKey, {
+          data: data,
+          params: params,
+          time: new Date().getTime()
+        });
+        // resubscribe
+        unSubscribeRef.current = (0, _cacheSubscribe.subscribe)(cacheKey, function (d) {
+          console.log('subscribe', d);
+          fetchInstance.setState({
+            data: d
+          });
+        });
+      }
+    },
+    onMutate: function onMutate(data) {
+      var _a;
+      if (cacheKey) {
+        // cancel subscribe, avoid trigger self
+        (_a = unSubscribeRef.current) === null || _a === void 0 ? void 0 : _a.call(unSubscribeRef);
+        _setCache(cacheKey, {
+          data: data,
+          params: fetchInstance.state.params,
+          time: new Date().getTime()
+        });
+        // resubscribe
+        unSubscribeRef.current = (0, _cacheSubscribe.subscribe)(cacheKey, function (d) {
+          fetchInstance.setState({
+            data: d
+          });
+        });
+      }
+    }
+  };
+};
+var _default = exports["default"] = useCachePlugin;

package/lib/useRequest/src/plugins/useDebouncePlugin.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '../types';
+declare const useDebouncePlugin: Plugin<any, any[]>;
+export default useDebouncePlugin;

package/lib/useRequest/src/plugins/useDebouncePlugin.js

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _tslib = require("tslib");
+var _lodashEs = require("lodash-es");
+var _react = require("react");
+var useDebouncePlugin = function useDebouncePlugin(fetchInstance, _a) {
+  var debounceWait = _a.debounceWait,
+    debounceLeading = _a.debounceLeading,
+    debounceTrailing = _a.debounceTrailing,
+    debounceMaxWait = _a.debounceMaxWait;
+  var debouncedRef = (0, _react.useRef)();
+  // 防抖配置 契合 lodash.debounce 的配置
+  var options = (0, _react.useMemo)(function () {
+    var ret = {};
+    if (debounceLeading !== undefined) {
+      ret.leading = debounceLeading;
+    }
+    if (debounceTrailing !== undefined) {
+      ret.trailing = debounceTrailing;
+    }
+    if (debounceMaxWait !== undefined) {
+      ret.maxWait = debounceMaxWait;
+    }
+    return ret;
+  }, [debounceLeading, debounceTrailing, debounceMaxWait]);
+  (0, _react.useEffect)(function () {
+    if (debounceWait) {
+      var _originRunAsync_1 = fetchInstance.runAsync.bind(fetchInstance);
+      debouncedRef.current = (0, _lodashEs.debounce)(function (callback) {
+        callback();
+      }, debounceWait, options);
+      // debounce runAsync should be promise
+      // https://github.com/lodash/lodash/issues/4400#issuecomment-834800398
+      fetchInstance.runAsync = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        return new Promise(function (resolve, reject) {
+          var _a;
+          (_a = debouncedRef.current) === null || _a === void 0 ? void 0 : _a.call(debouncedRef, function () {
+            _originRunAsync_1.apply(void 0, (0, _tslib.__spreadArray)([], (0, _tslib.__read)(args), false)).then(resolve)["catch"](reject);
+          });
+        });
+      };
+      return function () {
+        var _a;
+        (_a = debouncedRef.current) === null || _a === void 0 ? void 0 : _a.cancel();
+        fetchInstance.runAsync = _originRunAsync_1; // 取消防抖后，恢复原来的 runAsync
+      };
+    }
+  }, [debounceWait, options]);
+  if (!debounceWait) {
+    return {};
+  }
+  return {
+    onCancel: function onCancel() {
+      var _a;
+      (_a = debouncedRef.current) === null || _a === void 0 ? void 0 : _a.cancel();
+    }
+  };
+};
+var _default = exports["default"] = useDebouncePlugin;

package/lib/useRequest/src/plugins/useLoadingDelayPlugin.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '../types';
+declare const useLoadingDelayPlugin: Plugin<any, any[]>;
+export default useLoadingDelayPlugin;

package/lib/useRequest/src/plugins/useLoadingDelayPlugin.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _react = require("react");
+var useLoadingDelayPlugin = function useLoadingDelayPlugin(fetchInstance, _a) {
+  var loadingDelay = _a.loadingDelay,
+    ready = _a.ready;
+  var timerRef = (0, _react.useRef)();
+  if (!loadingDelay) {
+    return {};
+  }
+  var cancelTimeout = function cancelTimeout() {
+    if (timerRef.current) {
+      clearTimeout(timerRef.current);
+    }
+  };
+  return {
+    onBefore: function onBefore() {
+      cancelTimeout();
+      // Two cases:
+      // 1. ready === undefined
+      // 2. ready === true
+      console.log('ready', ready);
+      if (ready !== false) {
+        timerRef.current = setTimeout(function () {
+          fetchInstance.setState({
+            loading: true
+          });
+        }, loadingDelay);
+      }
+      return {
+        loading: false
+      };
+    },
+    onFinally: function onFinally() {
+      cancelTimeout();
+    },
+    onCancel: function onCancel() {
+      cancelTimeout();
+    }
+  };
+};
+var _default = exports["default"] = useLoadingDelayPlugin;

package/lib/useRequest/src/plugins/usePollingPlugin.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '../types';
+declare const usePollingPlugin: Plugin<any, any[]>;
+export default usePollingPlugin;

package/lib/useRequest/src/plugins/usePollingPlugin.js

@@ -0,0 +1,72 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _react = require("react");
+var _useUpdateEffect = _interopRequireDefault(require("../../../useUpdateEffect"));
+var _isDocumentVisible = _interopRequireDefault(require("../utils/isDocumentVisible"));
+var _subscribeReVisible = _interopRequireDefault(require("../utils/subscribeReVisible"));
+// 轮询插件
+var usePollingPlugin = function usePollingPlugin(fetchInstance, _a) {
+  var pollingInterval = _a.pollingInterval,
+    _b = _a.pollingWhenHidden,
+    pollingWhenHidden = _b === void 0 ? true : _b,
+    _c = _a.pollingErrorRetryCount,
+    pollingErrorRetryCount = _c === void 0 ? -1 : _c;
+  var timerRef = (0, _react.useRef)();
+  var unsubscribeRef = (0, _react.useRef)();
+  var countRef = (0, _react.useRef)(0);
+  var stopPolling = function stopPolling() {
+    var _a;
+    if (timerRef.current) {
+      clearTimeout(timerRef.current);
+    }
+    (_a = unsubscribeRef.current) === null || _a === void 0 ? void 0 : _a.call(unsubscribeRef);
+  };
+  (0, _useUpdateEffect["default"])(function () {
+    if (!pollingInterval) {
+      stopPolling();
+    }
+  }, [pollingInterval]);
+  if (!pollingInterval) {
+    return {};
+  }
+  return {
+    onBefore: function onBefore() {
+      stopPolling();
+    },
+    onError: function onError() {
+      countRef.current += 1;
+    },
+    onSuccess: function onSuccess() {
+      countRef.current = 0;
+    },
+    onFinally: function onFinally() {
+      if (pollingErrorRetryCount === -1 ||
+      // When an error occurs, the request is not repeated after pollingErrorRetryCount retries
+      pollingErrorRetryCount !== -1 && countRef.current <= pollingErrorRetryCount) {
+        timerRef.current = setTimeout(function () {
+          // if pollingWhenHidden = false && document is hidden, then stop polling and subscribe revisible
+          if (!pollingWhenHidden && !(0, _isDocumentVisible["default"])()) {
+            // 在页面隐藏时会暂时停止轮询，页面重新显示时继续上次轮询。
+            unsubscribeRef.current = (0, _subscribeReVisible["default"])(function () {
+              fetchInstance.refresh();
+            });
+          } else {
+            // 如果页面可见，则刷新请求
+            fetchInstance.refresh();
+          }
+        }, pollingInterval);
+      } else {
+        countRef.current = 0;
+      }
+    },
+    onCancel: function onCancel() {
+      stopPolling();
+    }
+  };
+};
+var _default = exports["default"] = usePollingPlugin;

package/lib/useRequest/src/plugins/useRefreshOnWindowFocusPlugin.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '../types';
+declare const useRefreshOnWindowFocusPlugin: Plugin<any, any[]>;
+export default useRefreshOnWindowFocusPlugin;

package/lib/useRequest/src/plugins/useRefreshOnWindowFocusPlugin.js

@@ -0,0 +1,37 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _react = require("react");
+var _useUnmount = _interopRequireDefault(require("../../../useUnmount"));
+var _limit = _interopRequireDefault(require("../utils/limit"));
+var _subscribeFocus = _interopRequireDefault(require("../utils/subscribeFocus"));
+var useRefreshOnWindowFocusPlugin = function useRefreshOnWindowFocusPlugin(fetchInstance, _a) {
+  var refreshOnWindowFocus = _a.refreshOnWindowFocus,
+    _b = _a.focusTimespan,
+    focusTimespan = _b === void 0 ? 5000 : _b;
+  var unsubscribeRef = (0, _react.useRef)();
+  var stopSubscribe = function stopSubscribe() {
+    var _a;
+    (_a = unsubscribeRef.current) === null || _a === void 0 ? void 0 : _a.call(unsubscribeRef);
+  };
+  (0, _react.useEffect)(function () {
+    if (refreshOnWindowFocus) {
+      var limitRefresh_1 = (0, _limit["default"])(fetchInstance.refresh.bind(fetchInstance), focusTimespan);
+      unsubscribeRef.current = (0, _subscribeFocus["default"])(function () {
+        limitRefresh_1();
+      });
+    }
+    return function () {
+      stopSubscribe();
+    };
+  }, [refreshOnWindowFocus, focusTimespan]);
+  (0, _useUnmount["default"])(function () {
+    stopSubscribe();
+  });
+  return {};
+};
+var _default = exports["default"] = useRefreshOnWindowFocusPlugin;

package/lib/useRequest/src/plugins/useRetryPlugin.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '../types';
+declare const useRetryPlugin: Plugin<any, any[]>;
+export default useRetryPlugin;

package/lib/useRequest/src/plugins/useRetryPlugin.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _react = require("react");
+var useRetryPlugin = function useRetryPlugin(fetchInstance, _a) {
+  var retryInterval = _a.retryInterval,
+    retryCount = _a.retryCount;
+  var timerRef = (0, _react.useRef)();
+  var countRef = (0, _react.useRef)(0);
+  var triggerByRetry = (0, _react.useRef)(false);
+  if (!retryCount) {
+    return {};
+  }
+  return {
+    onBefore: function onBefore() {
+      if (!triggerByRetry.current) {
+        countRef.current = 0;
+      }
+      triggerByRetry.current = false;
+      if (timerRef.current) {
+        clearTimeout(timerRef.current);
+      }
+    },
+    onSuccess: function onSuccess() {
+      countRef.current = 0;
+    },
+    onError: function onError() {
+      countRef.current += 1;
+      if (retryCount === -1 || countRef.current <= retryCount) {
+        // Exponential backoff
+        var timeout = retryInterval !== null && retryInterval !== void 0 ? retryInterval : Math.min(1000 * Math.pow(2, countRef.current), 30000);
+        timerRef.current = setTimeout(function () {
+          triggerByRetry.current = true;
+          fetchInstance.refresh();
+        }, timeout);
+      } else {
+        countRef.current = 0;
+      }
+    },
+    onCancel: function onCancel() {
+      countRef.current = 0;
+      if (timerRef.current) {
+        clearTimeout(timerRef.current);
+      }
+    }
+  };
+};
+var _default = exports["default"] = useRetryPlugin;

package/lib/useRequest/src/plugins/useThrottlePlugin.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '../types';
+declare const useThrottlePlugin: Plugin<any, any[]>;
+export default useThrottlePlugin;

package/lib/useRequest/src/plugins/useThrottlePlugin.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _tslib = require("tslib");
+var _lodashEs = require("lodash-es");
+var _react = require("react");
+var useThrottlePlugin = function useThrottlePlugin(fetchInstance, _a) {
+  var throttleWait = _a.throttleWait,
+    throttleLeading = _a.throttleLeading,
+    throttleTrailing = _a.throttleTrailing;
+  var throttledRef = (0, _react.useRef)();
+  var options = {};
+  if (throttleLeading !== undefined) {
+    options.leading = throttleLeading;
+  }
+  if (throttleTrailing !== undefined) {
+    options.trailing = throttleTrailing;
+  }
+  (0, _react.useEffect)(function () {
+    if (throttleWait) {
+      var _originRunAsync_1 = fetchInstance.runAsync.bind(fetchInstance);
+      throttledRef.current = (0, _lodashEs.throttle)(function (callback) {
+        callback();
+      }, throttleWait, options);
+      // throttle runAsync should be promise
+      // https://github.com/lodash/lodash/issues/4400#issuecomment-834800398
+      fetchInstance.runAsync = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        return new Promise(function (resolve, reject) {
+          var _a;
+          (_a = throttledRef.current) === null || _a === void 0 ? void 0 : _a.call(throttledRef, function () {
+            _originRunAsync_1.apply(void 0, (0, _tslib.__spreadArray)([], (0, _tslib.__read)(args), false)).then(resolve)["catch"](reject);
+          });
+        });
+      };
+      return function () {
+        var _a;
+        fetchInstance.runAsync = _originRunAsync_1;
+        (_a = throttledRef.current) === null || _a === void 0 ? void 0 : _a.cancel();
+      };
+    }
+  }, [throttleWait, throttleLeading, throttleTrailing]);
+  if (!throttleWait) {
+    return {};
+  }
+  return {
+    onCancel: function onCancel() {
+      var _a;
+      (_a = throttledRef.current) === null || _a === void 0 ? void 0 : _a.cancel();
+    }
+  };
+};
+var _default = exports["default"] = useThrottlePlugin;

package/lib/useRequest/src/types.d.ts

@@ -0,0 +1,73 @@
+import type { DependencyList } from 'react';
+import type Fetch from './Fetch';
+import type { CachedData } from './utils/cache';
+export type Service<TData, TParams extends any[]> = (...args: TParams) => Promise<TData>;
+export type Subscribe = () => void;
+export interface FetchState<TData, TParams extends any[]> {
+    loading: boolean;
+    params?: TParams;
+    data?: TData;
+    error?: Error;
+}
+export interface PluginReturn<TData, TParams extends any[]> {
+    onBefore?: (params: TParams) => ({
+        stopNow?: boolean;
+        returnNow?: boolean;
+    } & Partial<FetchState<TData, TParams>>) | void;
+    onRequest?: (service: Service<TData, TParams>, params: TParams) => {
+        servicePromise?: Promise<TData>;
+    };
+    onSuccess?: (data: TData, params: TParams) => void;
+    onError?: (e: Error, params: TParams) => void;
+    onFinally?: (params: TParams, data?: TData, e?: Error) => void;
+    onCancel?: () => void;
+    onMutate?: (data: TData) => void;
+}
+export interface Options<TData, TParams extends any[]> {
+    manual?: boolean;
+    onBefore?: (params: TParams) => void;
+    onSuccess?: (data: TData, params: TParams) => void;
+    onError?: (e: Error, params: TParams) => void;
+    onFinally?: (params: TParams, data?: TData, e?: Error) => void;
+    defaultParams?: TParams;
+    refreshDeps?: DependencyList;
+    refreshDepsAction?: () => void;
+    loadingDelay?: number;
+    pollingInterval?: number;
+    pollingWhenHidden?: boolean;
+    pollingErrorRetryCount?: number;
+    refreshOnWindowFocus?: boolean;
+    focusTimespan?: number;
+    debounceWait?: number;
+    debounceLeading?: boolean;
+    debounceTrailing?: boolean;
+    debounceMaxWait?: number;
+    throttleWait?: number;
+    throttleLeading?: boolean;
+    throttleTrailing?: boolean;
+    cacheKey?: string;
+    cacheTime?: number;
+    staleTime?: number;
+    setCache?: (data: CachedData<TData, TParams>) => void;
+    getCache?: (params: TParams) => CachedData<TData, TParams> | undefined;
+    retryCount?: number;
+    retryInterval?: number;
+    ready?: boolean;
+}
+export type Plugin<TData, TParams extends any[]> = {
+    (fetchInstance: Fetch<TData, TParams>, options: Options<TData, TParams>): PluginReturn<TData, TParams>;
+    onInit?: (options: Options<TData, TParams>) => Partial<FetchState<TData, TParams>>;
+};
+export interface Result<TData, TParams extends any[]> {
+    loading: boolean;
+    data?: TData;
+    error?: Error;
+    params: TParams | [];
+    cancel: Fetch<TData, TParams>['cancel'];
+    refresh: Fetch<TData, TParams>['refresh'];
+    refreshAsync: Fetch<TData, TParams>['refreshAsync'];
+    run: Fetch<TData, TParams>['run'];
+    runAsync: Fetch<TData, TParams>['runAsync'];
+    mutate: Fetch<TData, TParams>['mutate'];
+}
+export type Timeout = ReturnType<typeof setTimeout>;

package/lib/useRequest/src/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/useRequest/src/useRequest.d.ts

@@ -0,0 +1,3 @@
+import type { Options, Plugin, Service } from './types';
+declare function useRequest<TData, TParams extends any[]>(service: Service<TData, TParams>, options?: Options<TData, TParams>, plugins?: Plugin<TData, TParams>[]): import("./types").Result<TData, TParams>;
+export default useRequest;

package/lib/useRequest/src/useRequest.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _tslib = require("tslib");
+var _useAutoRunPlugin = _interopRequireDefault(require("./plugins/useAutoRunPlugin"));
+var _useCachePlugin = _interopRequireDefault(require("./plugins/useCachePlugin"));
+var _useDebouncePlugin = _interopRequireDefault(require("./plugins/useDebouncePlugin"));
+var _useLoadingDelayPlugin = _interopRequireDefault(require("./plugins/useLoadingDelayPlugin"));
+var _usePollingPlugin = _interopRequireDefault(require("./plugins/usePollingPlugin"));
+var _useRefreshOnWindowFocusPlugin = _interopRequireDefault(require("./plugins/useRefreshOnWindowFocusPlugin"));
+var _useRetryPlugin = _interopRequireDefault(require("./plugins/useRetryPlugin"));
+var _useThrottlePlugin = _interopRequireDefault(require("./plugins/useThrottlePlugin"));
+var _useRequestImplement = _interopRequireDefault(require("./useRequestImplement"));
+function useRequest(service, options, plugins) {
+  return (0, _useRequestImplement["default"])(service, options, (0, _tslib.__spreadArray)((0, _tslib.__spreadArray)([], (0, _tslib.__read)(plugins || []), false), [_useDebouncePlugin["default"], _useLoadingDelayPlugin["default"], _usePollingPlugin["default"], _useRefreshOnWindowFocusPlugin["default"], _useThrottlePlugin["default"], _useAutoRunPlugin["default"], _useCachePlugin["default"], _useRetryPlugin["default"]], false));
+}
+var _default = exports["default"] = useRequest;

package/lib/useRequest/src/useRequestImplement.d.ts

@@ -0,0 +1,5 @@
+import type { Options, Plugin, Result, Service } from './types';
+declare function useRequestImplement<TData, TParams extends any[]>(service: Service<TData, TParams>, // 请求函数
+options?: Options<TData, TParams>, // 请求配置
+plugins?: Plugin<TData, TParams>[]): Result<TData, TParams>;
+export default useRequestImplement;