sun-biz 0.0.1-beta.1

package/dist/hooks/use-request/types.d.ts

@@ -0,0 +1,267 @@
+import { Ref, watch } from 'vue';
+import { CachedData } from './utils/cache';
+import UseRequestFetch from './Fetch';
+export interface Result {
+    errorCode: string;
+    errorDetail: string;
+    errorMessage: string;
+    success: boolean;
+    traceId: string;
+    warningFlag: number;
+}
+export interface ResPage<T> extends Result {
+    data: T[];
+    total: number;
+    pageNum: number;
+    pageSize: number;
+    count: string;
+}
+export interface ResultData<T> extends Result {
+    data: T;
+}
+export type UseRequestService<TData, TParams extends unknown[]> = (...args: TParams) => Promise<[
+    Error | undefined,
+    TParams[0] extends {
+        pageSize: number;
+        pageNumber: number;
+    } ? ResPage<TData> : ResultData<TData> | undefined
+]>;
+export type UseRequestSubscribe = () => void;
+export interface UseRequestFetchState<TData, TParams extends unknown[]> {
+    loading: boolean;
+    total: any;
+    params?: TParams;
+    data?: TData;
+    restData?: any;
+    error?: Error | unknown;
+}
+export interface UseRequestPluginReturn<TData, TParams extends unknown[]> {
+    name?: string;
+    onBefore?: (params: TParams) => ({
+        stopNow?: boolean;
+        returnNow?: boolean;
+    } & Partial<UseRequestFetchState<TData, TParams>>) | void;
+    onRequest?: (service: UseRequestService<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 type RequestHook<TData = any, TParams extends any[] = any[]> = (service: UseRequestService<TData, TParams>, options: UseRequestOptions<TData, TParams, any>, plugins: UseRequestPlugin<TData, TParams>[]) => useRequestResult<TData, TParams>;
+export type UseRequestMiddleware<TData, TParams extends any[]> = (useRequestNext: RequestHook<TData, TParams>) => RequestHook<TData, TParams>;
+export type UseRequestBasicOptions<TData, TParams extends unknown[]> = {
+    /**
+     * Init data.
+     */
+    /**
+     * - The default is `false.` That is, the service is automatically executed during initialization.
+     * - f set to `true`, you need to manually call `run` or r`unAsync` to trigger execution.
+     */
+    manual?: boolean;
+    /**
+     * 	The parameters passed to the service at the first default execution
+     */
+    defaultParams?: TParams;
+    /**
+     * Triggered before service execution
+     * @param params TParams
+     * @returns void
+     */
+    onBefore?: (params: TParams) => void;
+    /**
+     * Triggered when service resolve.
+     * @param data TData
+     * @param params TParams
+     * @returns void
+     */
+    onSuccess?: (data: TData, params: TParams) => void;
+    /**
+     * Triggered when service reject.
+     * @param e Error
+     * @param params TParams
+     * @returns void
+     */
+    onError?: (e: Error, params: TParams) => void;
+    /**
+     * Triggered when service execution is complete.
+     * @param params TParams
+     * @param data TData
+     * @param e Error
+     * @returns void
+     */
+    onFinally?: (params: TParams, data?: TData, e?: Error) => void;
+    /**
+     * Is the current request ready
+     */
+    ready?: Ref<boolean> | boolean;
+    /**
+     * Dependent on responsive objects, and the `watch` incoming listener object usage for `vue`.
+     */
+    refreshDeps?: Parameters<typeof watch>[0][] | boolean;
+    refreshDepsAction?: () => void;
+    /**
+     * Set the delay time for `loading` to become `true`.
+     *
+     */
+    loadingDelay?: number | Ref<number>;
+    /**
+     * open vue devtools,debugKey must existence and uniqueness.
+     */
+    debugKey?: string;
+    /**
+     * Format the request results, which recommend to use `useFormatResult`.
+     * @param data TData
+     * @returns unknown need cover TData
+     */
+    /**
+     * Polling interval, in milliseconds. If the value is greater than 0, the polling mode is activated.
+     */
+    pollingInterval?: Ref<number> | number;
+    /**
+     * Whether to continue polling when the page is hidden. If set to false, polling will be temporarily paused when the page is hidden, and resume when the page is visible again.
+     */
+    pollingWhenHidden?: boolean;
+    /**
+     * Number of polling error retries. If set to -1, `an infinite number of times`.
+     */
+    pollingErrorRetryCount?: number;
+    /**
+     * Whether to re-initiate the request when the screen refocus or revisible.
+     */
+    refreshOnWindowFocus?: Ref<boolean> | boolean;
+    /**
+     * Re-request interval, in milliseconds.
+     */
+    focusTimespan?: Ref<number> | number;
+    /**
+     * Debounce delay time, in milliseconds. After setting, enter the debounce mode.
+     */
+    debounceWait?: Ref<number> | number;
+    /**
+     * Execute the request before the delay starts.
+     */
+    debounceLeading?: Ref<boolean> | boolean;
+    /**
+     * Execute the request after the delay ends.
+     */
+    debounceTrailing?: Ref<boolean> | boolean;
+    /**
+     * The maximum time request is allowed to be delayed before it’s executed.
+     */
+    debounceMaxWait?: Ref<number> | number;
+    /**
+     * Throttle wait time, in milliseconds. After setting, enter the throttle mode.
+     */
+    throttleWait?: Ref<number> | number;
+    /**
+     * Execute the request before throttling starts.
+     */
+    throttleLeading?: Ref<boolean> | boolean;
+    /**
+     * Execute the request after throttling ends.
+     */
+    throttleTrailing?: Ref<boolean> | boolean;
+    /**
+     * A unique ID of the request. If `cacheKey` is set, we will enable the caching mechanism. The data of the same `cacheKey` is globally synchronized.
+     */
+    cacheKey?: string;
+    /**
+     * - Set the cache time. By default, the cached data will be cleared after 5 minutes.
+     * - If set to `-1`, the cached data will never expire.
+     */
+    cacheTime?: number;
+    /**
+     * - Time to consider the cached data is fresh. Within this time interval, the request will not be re-initiated.
+     * - If set to `-1`, it means that the data is always fresh
+     */
+    staleTime?: number;
+    /**
+     * - Custom set cache.
+     * - `setCache` and `getCache` need to be used together.
+     * - In the custom cache mode, `cacheTime` and `clearCache` are useless, please implement it yourself according to the actual situation.
+     * @param data CachedData
+     * @returns void
+     */
+    setCache?: (data: CachedData<TData, TParams>) => void;
+    /**
+     *  Custom get cache
+     * @param params TParams
+     * @returns CachedData
+     */
+    getCache?: (params: TParams) => CachedData<TData, TParams> | undefined;
+    /**
+     * The number of retries. If set to `-1`, it will try again indefinitely.
+     */
+    retryCount?: number;
+    /**
+     * - Retry interval in milliseconds.
+     * If not set, the simple exponential backoff algorithm will be used by default, taking `1000 * 2 ** retryCount`, that is, waiting for 2s for the first retry, and 4s for the second retry. By analogy, if it is greater than 30s, take 30s.
+     */
+    retryInterval?: number;
+    /**
+     * Middleware
+     */
+    use?: UseRequestMiddleware<TData, TParams>[];
+    rollbackOnError?: boolean | ((params: TParams) => boolean);
+};
+export type UseRequestOptions<TData, TParams extends any[] = any[], TPlugin = any> = UseRequestBasicOptions<TData, TParams> & {
+    pluginOptions?: TPlugin;
+};
+export type UseRequestOptionsWithFormatResult<TData, TParams extends any[] = any[], TPlugin = any, SR = any> = UseRequestOptions<TData, TParams, TPlugin> & {
+    formatResult: (res: SR) => TData;
+};
+export type UseRequestOptionsWithInitialData<TData, TParams extends any[] = any[], TPlugin = any> = UseRequestOptions<TData, TParams, TPlugin> & {
+    initialData: TData extends infer R ? R : TData;
+};
+export interface UseRequestPlugin<TData, TParams extends unknown[] = unknown[], TPlugin = any> {
+    (fetchInstance: UseRequestFetch<TData, TParams>, options: UseRequestOptions<TData, TParams, TPlugin>): UseRequestPluginReturn<TData, TParams>;
+    onInit?: (options: UseRequestOptions<TData, TParams, TPlugin>) => Partial<UseRequestFetchState<TData, TParams>>;
+}
+export interface useRequestResult<TData, TParams extends unknown[]> {
+    /**
+     * Is the service being executed.
+     */
+    loading: Readonly<Ref<boolean>>;
+    /**
+     * Data returned by service.
+     */
+    data: Readonly<Ref<TData | undefined>>;
+    /**
+     * 	Exception thrown by service.
+     */
+    error: Readonly<Ref<Error | undefined>>;
+    /**
+     * params	An array of parameters for the service being executed. For example, you triggered `run(1, 2, 3)`, then params is equal to `[1, 2, 3]`.
+     */
+    params: Readonly<Ref<TParams | []>>;
+    total: Readonly<Ref<number>>;
+    /**
+     * Ignore the current promise response.
+     */
+    cancel: UseRequestFetch<TData, TParams>['cancel'];
+    /**
+     * Use the last params, call `run` again.
+     */
+    refresh: UseRequestFetch<TData, TParams>['refresh'];
+    /**
+     * Use the last params, call `runAsync` again.
+     */
+    refreshAsync: UseRequestFetch<TData, TParams>['refreshAsync'];
+    /**
+     * Manually trigger the execution of the service, and the parameters will be passed to the service.
+     */
+    run: UseRequestFetch<TData, TParams>['run'];
+    /**
+     * Automatic handling of exceptions, feedback through `onError`
+     */
+    runAsync: UseRequestFetch<TData, TParams>['runAsync'];
+    /**
+     * Mutate `data` directly
+     */
+    mutate: UseRequestFetch<TData, TParams>['mutate'];
+}
+export type Timeout = ReturnType<typeof setTimeout>;
+export type Interval = ReturnType<typeof setInterval>;

package/dist/hooks/use-request/types.js

@@ -0,0 +1,2 @@
+ // CONCATENATED MODULE: ./src/hooks/use-request/types.ts
+ /* eslint-disable @typescript-eslint/no-explicit-any */ 

package/dist/hooks/use-request/useRequest.d.ts

@@ -0,0 +1,7 @@
+import { UseRequestOptions, UseRequestOptionsWithFormatResult, UseRequestOptionsWithInitialData, UseRequestPlugin, useRequestResult, UseRequestService } from './types';
+export type PluginsMiddleOptionsType<PluginsOptions, TData, TParams extends unknown[] = unknown[]> = PluginsOptions extends (infer P)[] ? P extends UseRequestPlugin<TData, TParams, infer R> ? R : never : never;
+export declare function useRequest<TData, TParams extends unknown[] = unknown[], PluginsOptions extends UseRequestPlugin<TData, TParams>[] = UseRequestPlugin<TData, TParams>[], SR = any>(service: UseRequestService<SR, TParams>, options: UseRequestOptionsWithFormatResult<TData, TParams, PluginsMiddleOptionsType<PluginsOptions, TData, TParams>, SR> & UseRequestOptionsWithInitialData<SR, TParams, PluginsOptions>, plugins?: PluginsOptions): useRequestResult<TData, TParams>;
+export declare function useRequest<TData, TParams extends unknown[] = unknown[], PluginsOptions extends UseRequestPlugin<TData, TParams>[] = UseRequestPlugin<TData, TParams>[], SR = any>(service: UseRequestService<SR, TParams>, options: UseRequestOptionsWithFormatResult<TData, TParams, PluginsMiddleOptionsType<PluginsOptions, TData, TParams>, SR>, plugins?: PluginsOptions): useRequestResult<TData, TParams>;
+export declare function useRequest<TData, TParams extends unknown[] = unknown[], PluginsOptions extends UseRequestPlugin<TData, TParams>[] = UseRequestPlugin<TData, TParams>[]>(service: UseRequestService<TData, TParams>, options: UseRequestOptionsWithInitialData<TData, TParams, PluginsMiddleOptionsType<PluginsOptions, TData, TParams>>, plugins?: PluginsOptions): useRequestResult<TData, TParams>;
+export declare function useRequest<TData, TParams extends unknown[] = unknown[], PluginsOptions extends UseRequestPlugin<TData, TParams>[] = UseRequestPlugin<TData, TParams>[]>(service: UseRequestService<TData, TParams>, options?: UseRequestOptions<TData, TParams, PluginsMiddleOptionsType<PluginsOptions, TData, TParams>>, plugins?: PluginsOptions): useRequestResult<TData, TParams>;
+export default useRequest;

package/dist/hooks/use-request/useRequest.js

@@ -0,0 +1,28 @@
+import * as __WEBPACK_EXTERNAL_MODULE__plugins_useAutoRunPlugin_js__ from "./plugins/useAutoRunPlugin.js";
+import * as __WEBPACK_EXTERNAL_MODULE__useRequestImplement_js__ from "./useRequestImplement.js";
+import * as __WEBPACK_EXTERNAL_MODULE__utils_resolve_args_js__ from "./utils/resolve-args.js";
+/* eslint-disable @typescript-eslint/no-explicit-any */ // import useCachePlugin from './plugins/useCachePlugin';
+// import useDebouncePlugin from './plugins/useDebouncePlugin';
+// import useDevtoolsPlugin from './plugins/useDevtoolsPlugin';
+// import useLoadingDelayPlugin from './plugins/useLoadingDelayPlugin';
+// import usePollingPlugin from './plugins/usePollingPlugin';
+// import useRefreshOnWindowFocusPlugin from './plugins/useRefreshOnWindowFocusPlugin';
+// import useRetryPlugin from './plugins/useRetryPlugin';
+// import useThrottlePlugin from './plugins/useThrottlePlugin';
+function useRequest_useRequest(service, options, plugins) {
+    const BuiltInPlugins = [
+        // process?.env?.NODE_ENV === 'development' ? useDevtoolsPlugin : null,
+        // useDebouncePlugin,
+        // useLoadingDelayPlugin,
+        // usePollingPlugin,
+        // useRefreshOnWindowFocusPlugin,
+        // useThrottlePlugin,
+        __WEBPACK_EXTERNAL_MODULE__plugins_useAutoRunPlugin_js__["default"]
+    ].filter(Boolean);
+    return (0, __WEBPACK_EXTERNAL_MODULE__utils_resolve_args_js__.withArgs)(__WEBPACK_EXTERNAL_MODULE__useRequestImplement_js__["default"], options?.use)(service, options, [
+        ...plugins || [],
+        ...BuiltInPlugins
+    ]);
+}
+/* ESM default export */ const useRequest = useRequest_useRequest;
+export { useRequest as default, useRequest_useRequest as useRequest };

package/dist/hooks/use-request/useRequestImplement.d.ts

@@ -0,0 +1,3 @@
+import { UseRequestOptions, UseRequestPlugin, useRequestResult, UseRequestService } from './types';
+declare function useRequestImplement<TData, TParams extends any[]>(service: UseRequestService<TData, TParams>, options?: UseRequestOptions<TData, TParams>, plugins?: UseRequestPlugin<TData, TParams>[]): useRequestResult<TData, TParams>;
+export default useRequestImplement;

package/dist/hooks/use-request/useRequestImplement.js

@@ -0,0 +1,83 @@
+import * as __WEBPACK_EXTERNAL_MODULE_vue__ from "vue";
+import * as __WEBPACK_EXTERNAL_MODULE__Fetch_js__ from "./Fetch.js";
+import * as __WEBPACK_EXTERNAL_MODULE__config_js__ from "./config.js";
+/* eslint-disable @typescript-eslint/no-explicit-any */ function isUseRequestFetchState(state) {
+    const keys = Object.keys(state);
+    return 4 === keys.filter((i)=>[
+            'data',
+            'loading',
+            'params',
+            'error'
+        ].includes(i)).length;
+}
+function useRequestImplement(service, options = {}, plugins = []) {
+    // global option
+    const USEREQUEST_GLOBAL_OPTIONS = (0, __WEBPACK_EXTERNAL_MODULE_vue__.inject)(__WEBPACK_EXTERNAL_MODULE__config_js__.USEREQUEST_GLOBAL_OPTIONS_PROVIDE_KEY, {});
+    // read option
+    const { initialData, manual = false, ready = true, ...rest } = {
+        ...USEREQUEST_GLOBAL_OPTIONS ?? {},
+        ...options ?? {}
+    };
+    const fetchOptions = {
+        manual,
+        ready,
+        initialData,
+        ...rest
+    };
+    // serviceRef store service
+    const serviceRef = (0, __WEBPACK_EXTERNAL_MODULE_vue__.ref)(service);
+    // reactive
+    const state = (0, __WEBPACK_EXTERNAL_MODULE_vue__.reactive)({
+        data: initialData,
+        loading: false,
+        total: 0,
+        restData: void 0,
+        params: void 0,
+        error: void 0
+    });
+    const setState = (currentState, field)=>{
+        if (field) state[field] = currentState;
+        else if (isUseRequestFetchState(currentState)) {
+            state.data = currentState.data;
+            state.loading = currentState.loading;
+            state.error = currentState.error;
+            state.params = currentState.params;
+            if (currentState.total) state.total = currentState.total;
+            if (currentState.restData) state.restData = currentState.restData;
+        }
+    };
+    const initState = plugins.map((p)=>p?.onInit?.(fetchOptions)).filter(Boolean);
+    // Fetch Instance
+    const fetchInstance = new __WEBPACK_EXTERNAL_MODULE__Fetch_js__["default"](serviceRef, fetchOptions, setState, Object.assign({}, ...initState, state));
+    fetchInstance.options = fetchOptions;
+    // run plugins
+    fetchInstance.pluginImpls = plugins.map((p)=>p(fetchInstance, fetchOptions));
+    const readyComputed = (0, __WEBPACK_EXTERNAL_MODULE_vue__.computed)(()=>(0, __WEBPACK_EXTERNAL_MODULE_vue__.isRef)(ready) ? ready.value : ready);
+    (0, __WEBPACK_EXTERNAL_MODULE_vue__.watchEffect)(()=>{
+        if (!manual) {
+            const params = fetchInstance.state.params || options.defaultParams || [];
+            // auto collect
+            if (readyComputed.value && true === fetchInstance.options.refreshDeps && !!serviceRef.value) fetchInstance.run(...params);
+        }
+    });
+    // manual
+    if (!manual && true !== fetchInstance.options.refreshDeps) {
+        const params = fetchInstance.state.params || options.defaultParams || [];
+        if ((0, __WEBPACK_EXTERNAL_MODULE_vue__.unref)(ready)) fetchInstance.run(...params);
+    }
+    // onUnmounted cancel request
+    (0, __WEBPACK_EXTERNAL_MODULE_vue__.onScopeDispose)(()=>{
+        fetchInstance.cancel();
+    });
+    return {
+        ...(0, __WEBPACK_EXTERNAL_MODULE_vue__.toRefs)(state),
+        cancel: fetchInstance.cancel.bind(fetchInstance),
+        refresh: fetchInstance.refresh.bind(fetchInstance),
+        refreshAsync: fetchInstance.refreshAsync.bind(fetchInstance),
+        run: fetchInstance.run.bind(fetchInstance),
+        runAsync: fetchInstance.runAsync.bind(fetchInstance),
+        mutate: fetchInstance.mutate.bind(fetchInstance)
+    };
+}
+/* ESM default export */ const use_request_useRequestImplement = useRequestImplement;
+export { use_request_useRequestImplement as default };

package/dist/hooks/use-request/useRequestProvider.d.ts

@@ -0,0 +1,2 @@
+import type { UseRequestOptions } from './types';
+export default function useRequestProvider(config: UseRequestOptions<unknown, any, any>): void;

package/dist/hooks/use-request/useRequestProvider.js

@@ -0,0 +1,6 @@
+import * as __WEBPACK_EXTERNAL_MODULE_vue__ from "vue";
+import * as __WEBPACK_EXTERNAL_MODULE__config_js__ from "./config.js";
+/* eslint-disable @typescript-eslint/no-explicit-any */ function useRequestProvider(config) {
+    (0, __WEBPACK_EXTERNAL_MODULE_vue__.provide)(__WEBPACK_EXTERNAL_MODULE__config_js__.USEREQUEST_GLOBAL_OPTIONS_PROVIDE_KEY, config);
+}
+export { useRequestProvider as default };

package/dist/hooks/use-request/utils/cache.d.ts

@@ -0,0 +1,17 @@
+type Timer = ReturnType<typeof setTimeout>;
+type CachedKey = string | number;
+export interface CachedData<TData = any, TParams = any> {
+    data: TData;
+    params: TParams;
+    time: number;
+}
+interface RecordData extends CachedData {
+    timer: Timer | undefined;
+}
+declare const setCache: (key: CachedKey, cacheTime: number, cachedData: CachedData) => void;
+declare const getCache: (key: CachedKey) => RecordData | undefined;
+declare const getCacheAll: () => {
+    [k: string]: RecordData;
+};
+declare const clearCache: (key?: string | string[]) => void;
+export { getCache, setCache, clearCache, getCacheAll };

package/dist/hooks/use-request/utils/cache.js

@@ -0,0 +1,24 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */ const cache = new Map();
+const setCache = (key, cacheTime, cachedData)=>{
+    const currentCache = cache.get(key);
+    if (currentCache?.timer) clearTimeout(currentCache.timer);
+    let timer;
+    if (cacheTime > -1) timer = setTimeout(()=>{
+        cache.delete(key);
+    }, cacheTime);
+    cache.set(key, {
+        ...cachedData,
+        timer
+    });
+};
+const getCache = (key)=>cache.get(key);
+const getCacheAll = ()=>Object.fromEntries(cache.entries());
+const clearCache = (key)=>{
+    if (key) {
+        const cacheKeys = Array.isArray(key) ? key : [
+            key
+        ];
+        cacheKeys.forEach((cacheKey)=>cache.delete(cacheKey));
+    } else cache.clear();
+};
+export { clearCache, getCache, getCacheAll, setCache };

package/dist/hooks/use-request/utils/cachePromise.d.ts

@@ -0,0 +1,4 @@
+type CachedKey = string | number;
+declare const getCachePromise: (cacheKey: CachedKey) => Promise<any> | undefined;
+declare const setCachePromise: (cacheKey: CachedKey, promise: Promise<any>) => void;
+export { getCachePromise, setCachePromise };

package/dist/hooks/use-request/utils/cachePromise.js

@@ -0,0 +1,15 @@
+const cachePromise = new Map();
+const getCachePromise = (cacheKey)=>cachePromise.get(cacheKey);
+const setCachePromise = (cacheKey, promise)=>{
+    // 应该缓存同样的请求
+    cachePromise.set(cacheKey, promise);
+    // 兼容-不使用promise.finally
+    promise.then((res)=>{
+        cachePromise.delete(cacheKey);
+        return res;
+    }).catch((err)=>{
+        cachePromise.delete(cacheKey);
+        throw err;
+    });
+};
+export { getCachePromise, setCachePromise };

package/dist/hooks/use-request/utils/cacheSubscribe.d.ts

@@ -0,0 +1,5 @@
+type Listener = (data: any) => void;
+declare const trigger: (key: string, data: any) => void;
+declare const subscribe: (key: string, listener: Listener) => () => void;
+declare const otherSubscribe: (listener: Listener) => void;
+export { trigger, subscribe, otherSubscribe };

package/dist/hooks/use-request/utils/cacheSubscribe.js

@@ -0,0 +1,23 @@
+const listeners = {};
+const otherListeners = [];
+const trigger = (key, data)=>{
+    if (listeners[key]) {
+        listeners[key].forEach((item)=>item(data));
+        otherListeners.forEach((item)=>item({
+                type: key,
+                data
+            }));
+    }
+};
+const subscribe = (key, listener)=>{
+    if (!listeners[key]) listeners[key] = [];
+    listeners[key].push(listener);
+    return function() {
+        const index = listeners[key].indexOf(listener);
+        listeners[key].splice(index, 1);
+    };
+};
+const otherSubscribe = (listener)=>{
+    otherListeners.push(listener);
+};
+export { otherSubscribe, subscribe, trigger };

package/dist/hooks/use-request/utils/index.d.ts

@@ -0,0 +1,6 @@
+export declare const isObject: (value: unknown) => value is Record<any, any>;
+export declare const isFunction: (value: unknown) => value is Function;
+export declare const isString: (value: unknown) => value is string;
+export declare const isBoolean: (value: unknown) => value is boolean;
+export declare const isNumber: (value: unknown) => value is number;
+export declare const isUndef: (value: unknown) => value is undefined;

package/dist/hooks/use-request/utils/index.js

@@ -0,0 +1,8 @@
+const isObject = (value)=>null !== value && 'object' == typeof value;
+// eslint-disable-next-line @typescript-eslint/ban-types
+const isFunction = (value)=>'function' == typeof value;
+const isString = (value)=>'string' == typeof value;
+const isBoolean = (value)=>'boolean' == typeof value;
+const isNumber = (value)=>'number' == typeof value;
+const isUndef = (value)=>void 0 === value;
+export { isBoolean, isFunction, isNumber, isObject, isString, isUndef };

package/dist/hooks/use-request/utils/isDocumentVisible.d.ts

@@ -0,0 +1 @@
+export default function isDocumentVisible(): boolean;

package/dist/hooks/use-request/utils/isDocumentVisible.js

@@ -0,0 +1,6 @@
+import * as __WEBPACK_EXTERNAL_MODULE__utils_js__ from "./utils.js";
+function isDocumentVisible() {
+    if ((0, __WEBPACK_EXTERNAL_MODULE__utils_js__.canUseDom)()) return 'hidden' !== document.visibilityState;
+    return true;
+}
+export { isDocumentVisible as default };

package/dist/hooks/use-request/utils/isOnline.d.ts

@@ -0,0 +1 @@
+export default function isOnline(): boolean;

package/dist/hooks/use-request/utils/isOnline.js

@@ -0,0 +1,6 @@
+import * as __WEBPACK_EXTERNAL_MODULE__utils_js__ from "./utils.js";
+function isOnline() {
+    if ((0, __WEBPACK_EXTERNAL_MODULE__utils_js__.canUseDom)() && void 0 !== navigator.onLine) return navigator.onLine;
+    return true;
+}
+export { isOnline as default };

package/dist/hooks/use-request/utils/limit.d.ts

@@ -0,0 +1 @@
+export default function limit(fn: any, timespan: number): (...args: any[]) => void;

package/dist/hooks/use-request/utils/limit.js

@@ -0,0 +1,12 @@
+function limit(fn, timespan) {
+    let pending = false;
+    return (...args)=>{
+        if (pending) return;
+        pending = true;
+        fn(...args);
+        setTimeout(()=>{
+            pending = false;
+        }, timespan);
+    };
+}
+export { limit as default };

package/dist/hooks/use-request/utils/resolve-args.d.ts

@@ -0,0 +1,2 @@
+import { RequestHook, UseRequestMiddleware, UseRequestOptions, UseRequestPlugin, UseRequestService, useRequestResult } from '../types';
+export declare const withArgs: <TData, TParams extends any[]>(hook: RequestHook<TData, TParams>, use?: UseRequestMiddleware<TData, TParams>[]) => (service: UseRequestService<TData, TParams>, options?: UseRequestOptions<TData, TParams, any>, plugins?: UseRequestPlugin<TData, TParams>[]) => useRequestResult<TData, TParams>;

package/dist/hooks/use-request/utils/resolve-args.js

@@ -0,0 +1,7 @@
+const withArgs = (hook, use)=>function(service, options = {}, plugins = []) {
+        let next = hook;
+        const middleware = use || [];
+        for(let i = middleware.length; i--;)next = middleware[i](next);
+        return next(service, options, plugins);
+    };
+export { withArgs };

package/dist/hooks/use-request/utils/subscribeFocus.d.ts

@@ -0,0 +1,3 @@
+type Listener = () => void;
+declare function subscribe(listener: Listener): () => void;
+export default subscribe;

package/dist/hooks/use-request/utils/subscribeFocus.js

@@ -0,0 +1,25 @@
+import * as __WEBPACK_EXTERNAL_MODULE__utils_js__ from "./utils.js";
+import * as __WEBPACK_EXTERNAL_MODULE__isDocumentVisible_js__ from "./isDocumentVisible.js";
+import * as __WEBPACK_EXTERNAL_MODULE__isOnline_js__ from "./isOnline.js";
+// from swr
+const listeners = [];
+function subscribe(listener) {
+    listeners.push(listener);
+    return function() {
+        const index = listeners.indexOf(listener);
+        if (index > -1) listeners.splice(index, 1);
+    };
+}
+if (__WEBPACK_EXTERNAL_MODULE__utils_js__["default"]) {
+    const revalidate = ()=>{
+        if (!(0, __WEBPACK_EXTERNAL_MODULE__isDocumentVisible_js__["default"])() || !(0, __WEBPACK_EXTERNAL_MODULE__isOnline_js__["default"])()) return;
+        for(let i = 0; i < listeners.length; i++){
+            const listener = listeners[i];
+            listener();
+        }
+    };
+    window.addEventListener('visibilitychange', revalidate, false);
+    window.addEventListener('focus', revalidate, false);
+}
+/* ESM default export */ const subscribeFocus = subscribe;
+export { subscribeFocus as default };

package/dist/hooks/use-request/utils/subscribeReVisible.d.ts

@@ -0,0 +1,2 @@
+declare function subscribe(listener: () => void): () => void;
+export default subscribe;

package/dist/hooks/use-request/utils/subscribeReVisible.js

@@ -0,0 +1,22 @@
+import * as __WEBPACK_EXTERNAL_MODULE__isDocumentVisible_js__ from "./isDocumentVisible.js";
+import * as __WEBPACK_EXTERNAL_MODULE__utils_js__ from "./utils.js";
+const listeners = [];
+function subscribe(listener) {
+    listeners.push(listener);
+    return function() {
+        const index = listeners.indexOf(listener);
+        listeners.splice(index, 1);
+    };
+}
+if ((0, __WEBPACK_EXTERNAL_MODULE__utils_js__.canUseDom)()) {
+    const revalidate = ()=>{
+        if (!(0, __WEBPACK_EXTERNAL_MODULE__isDocumentVisible_js__["default"])()) return;
+        for(let i = 0; i < listeners.length; i++){
+            const listener = listeners[i];
+            listener();
+        }
+    };
+    window.addEventListener("visibilitychange", revalidate, false);
+}
+/* ESM default export */ const subscribeReVisible = subscribe;
+export { subscribeReVisible as default };

package/dist/hooks/use-request/utils/utils.d.ts

@@ -0,0 +1,3 @@
+export declare function canUseDom(): boolean;
+declare const isBrowser: boolean;
+export default isBrowser;

package/dist/hooks/use-request/utils/utils.js

@@ -0,0 +1,6 @@
+function canUseDom() {
+    return !!('undefined' != typeof window && window.document && window.document.createElement);
+}
+const isBrowser = !!('undefined' != typeof window && window.document && window.document.createElement);
+/* ESM default export */ const utils = isBrowser;
+export { canUseDom, utils as default };

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './components/index';
+export * from './hooks/index';