icode-hooks 0.3.0

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

@@ -0,0 +1,53 @@
+import { __read, __spreadArray } from "tslib";
+import { throttle } from 'lodash-es';
+import { useEffect, useRef } from 'react';
+var useThrottlePlugin = function (fetchInstance, _a) {
+  var throttleWait = _a.throttleWait,
+    throttleLeading = _a.throttleLeading,
+    throttleTrailing = _a.throttleTrailing;
+  var throttledRef = useRef();
+  var options = {};
+  if (throttleLeading !== undefined) {
+    options.leading = throttleLeading;
+  }
+  if (throttleTrailing !== undefined) {
+    options.trailing = throttleTrailing;
+  }
+  useEffect(function () {
+    if (throttleWait) {
+      var _originRunAsync_1 = fetchInstance.runAsync.bind(fetchInstance);
+      throttledRef.current = 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, __spreadArray([], __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 () {
+      var _a;
+      (_a = throttledRef.current) === null || _a === void 0 ? void 0 : _a.cancel();
+    }
+  };
+};
+export default useThrottlePlugin;

package/es/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/es/useRequest/src/types.js

@@ -0,0 +1 @@
+export {};

package/es/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/es/useRequest/src/useRequest.js

@@ -0,0 +1,14 @@
+import { __read, __spreadArray } from "tslib";
+import useAutoRunPlugin from './plugins/useAutoRunPlugin';
+import useCachePlugin from './plugins/useCachePlugin';
+import useDebouncePlugin from './plugins/useDebouncePlugin';
+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';
+import useRequestImplement from './useRequestImplement';
+function useRequest(service, options, plugins) {
+  return useRequestImplement(service, options, __spreadArray(__spreadArray([], __read(plugins || []), false), [useDebouncePlugin, useLoadingDelayPlugin, usePollingPlugin, useRefreshOnWindowFocusPlugin, useThrottlePlugin, useAutoRunPlugin, useCachePlugin, useRetryPlugin], false));
+}
+export default useRequest;

package/es/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;

package/es/useRequest/src/useRequestImplement.js

@@ -0,0 +1,72 @@
+import { __assign, __read, __rest, __spreadArray } from "tslib";
+import useCreation from '../../useCreation';
+import useLatest from '../../useLatest';
+import useMemoizedFn from '../../useMemoizedFn';
+import useMount from '../../useMount';
+import useUnmount from '../../useUnmount';
+import useUpdate from '../../useUpdate';
+import isDev from '../../utils/isDev';
+import Fetch from './Fetch';
+function useRequestImplement(service,
+// 请求函数
+options,
+// 请求配置
+plugins) {
+  if (options === void 0) {
+    options = {};
+  }
+  if (plugins === void 0) {
+    plugins = [];
+  }
+  var _a = options.manual,
+    manual = _a === void 0 ? false : _a,
+    rest = __rest(options, ["manual"]);
+  if (isDev) {
+    if (options.defaultParams && !Array.isArray(options.defaultParams)) {
+      console.warn("expected defaultParams is array, got ".concat(typeof options.defaultParams));
+    }
+  }
+  var fetchOptions = __assign({
+    manual: manual
+  }, rest);
+  var serviceRef = useLatest(service);
+  var update = useUpdate();
+  var fetchInstance = useCreation(function () {
+    // 筛选出所有插件的 onInit 把没有返回值的插件过滤掉
+    var initState = plugins.map(function (p) {
+      var _a;
+      return (_a = p === null || p === void 0 ? void 0 : p.onInit) === null || _a === void 0 ? void 0 : _a.call(p, fetchOptions);
+    }).filter(Boolean);
+    return new Fetch(serviceRef, fetchOptions, update, Object.assign.apply(Object, __spreadArray([{}], __read(initState), false)));
+  }, []);
+  fetchInstance.options = fetchOptions;
+  // run all plugins hooks
+  fetchInstance.pluginImpls = plugins.map(function (p) {
+    return p(fetchInstance, fetchOptions);
+  });
+  // 挂载时执行
+  useMount(function () {
+    if (!manual) {
+      // useCachePlugin can set fetchInstance.state.params from cache when init
+      var params = fetchInstance.state.params || options.defaultParams || [];
+      // @ts-ignore
+      fetchInstance.run.apply(fetchInstance, __spreadArray([], __read(params), false));
+    }
+  });
+  useUnmount(function () {
+    fetchInstance.cancel();
+  });
+  return {
+    loading: fetchInstance.state.loading,
+    data: fetchInstance.state.data,
+    error: fetchInstance.state.error,
+    params: fetchInstance.state.params || [],
+    cancel: useMemoizedFn(fetchInstance.cancel.bind(fetchInstance)),
+    refresh: useMemoizedFn(fetchInstance.refresh.bind(fetchInstance)),
+    refreshAsync: useMemoizedFn(fetchInstance.refreshAsync.bind(fetchInstance)),
+    run: useMemoizedFn(fetchInstance.run.bind(fetchInstance)),
+    runAsync: useMemoizedFn(fetchInstance.runAsync.bind(fetchInstance)),
+    mutate: useMemoizedFn(fetchInstance.mutate.bind(fetchInstance))
+  };
+}
+export default useRequestImplement;

package/es/useRequest/src/utils/cache.d.ts

@@ -0,0 +1,14 @@
+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 clearCache: (key?: string | string[]) => void;
+export { getCache, setCache, clearCache };

package/es/useRequest/src/utils/cache.js

@@ -0,0 +1,32 @@
+import { __assign } from "tslib";
+var cache = new Map();
+var setCache = function (key, cacheTime, cachedData) {
+  var currentCache = cache.get(key);
+  if (currentCache === null || currentCache === void 0 ? void 0 : currentCache.timer) {
+    clearTimeout(currentCache.timer);
+  }
+  var timer = undefined;
+  if (cacheTime > -1) {
+    // if cache out, clear it
+    timer = setTimeout(function () {
+      cache.delete(key);
+    }, cacheTime);
+  }
+  cache.set(key, __assign(__assign({}, cachedData), {
+    timer: timer
+  }));
+};
+var getCache = function (key) {
+  return cache.get(key);
+};
+var clearCache = function (key) {
+  if (key) {
+    var cacheKeys = Array.isArray(key) ? key : [key];
+    cacheKeys.forEach(function (cacheKey) {
+      return cache.delete(cacheKey);
+    });
+  } else {
+    cache.clear();
+  }
+};
+export { getCache, setCache, clearCache };

package/es/useRequest/src/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/es/useRequest/src/utils/cachePromise.js

@@ -0,0 +1,17 @@
+var cachePromise = new Map();
+var getCachePromise = function (cacheKey) {
+  return cachePromise.get(cacheKey);
+};
+var setCachePromise = function (cacheKey, promise) {
+  // Should cache the same promise, cannot be promise.finally
+  // Because the promise.finally will change the reference of the promise
+  cachePromise.set(cacheKey, promise);
+  // no use promise.finally for compatibility
+  promise.then(function (res) {
+    cachePromise.delete(cacheKey);
+    return res;
+  }).catch(function () {
+    cachePromise.delete(cacheKey);
+  });
+};
+export { getCachePromise, setCachePromise };

package/es/useRequest/src/utils/cacheSubscribe.d.ts

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

package/es/useRequest/src/utils/cacheSubscribe.js

@@ -0,0 +1,19 @@
+var listeners = {};
+var trigger = function (key, data) {
+  if (listeners[key]) {
+    listeners[key].forEach(function (item) {
+      return item(data);
+    });
+  }
+};
+var subscribe = function (key, listener) {
+  if (!listeners[key]) {
+    listeners[key] = [];
+  }
+  listeners[key].push(listener);
+  return function unsubscribe() {
+    var index = listeners[key].indexOf(listener);
+    listeners[key].splice(index, 1);
+  };
+};
+export { trigger, subscribe };

package/es/useRequest/src/utils/isDocumentVisible.d.ts

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

package/es/useRequest/src/utils/isDocumentVisible.js

@@ -0,0 +1,7 @@
+import isBrowser from '../../../utils/isBrowser';
+export default function isDocumentVisible() {
+  if (isBrowser) {
+    return document.visibilityState !== 'hidden'; // 如果浏览器可见，元素是可见的
+  }
+  return true;
+}

package/es/useRequest/src/utils/isOnline.d.ts

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

package/es/useRequest/src/utils/isOnline.js

@@ -0,0 +1,7 @@
+import isBrowser from '../../../utils/isBrowser';
+export default function isOnline() {
+  if (isBrowser && typeof navigator.onLine !== 'undefined') {
+    return navigator.onLine;
+  }
+  return true;
+}

package/es/useRequest/src/utils/limit.d.ts

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

package/es/useRequest/src/utils/limit.js

@@ -0,0 +1,17 @@
+import { __read, __spreadArray } from "tslib";
+// 限制函数执行频率
+export default function limit(fn, timespan) {
+  var pending = false;
+  return function () {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      args[_i] = arguments[_i];
+    }
+    if (pending) return;
+    pending = true;
+    fn.apply(void 0, __spreadArray([], __read(args), false));
+    setTimeout(function () {
+      pending = false;
+    }, timespan);
+  };
+}

package/es/useRequest/src/utils/subscribeFocus.d.ts

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

package/es/useRequest/src/utils/subscribeFocus.js

@@ -0,0 +1,27 @@
+// from swr
+import isBrowser from '../../../utils/isBrowser';
+import isDocumentVisible from './isDocumentVisible';
+import isOnline from './isOnline';
+var listeners = [];
+function subscribe(listener) {
+  listeners.push(listener);
+  return function unsubscribe() {
+    var index = listeners.indexOf(listener);
+    if (index > -1) {
+      listeners.splice(index, 1);
+    }
+  };
+}
+// 订阅窗口聚焦事件
+if (isBrowser) {
+  var revalidate = function () {
+    if (!isDocumentVisible() || !isOnline()) return;
+    for (var i = 0; i < listeners.length; i++) {
+      var listener = listeners[i];
+      listener();
+    }
+  };
+  window.addEventListener('visibilitychange', revalidate, false);
+  window.addEventListener('focus', revalidate, false);
+}
+export default subscribe;

package/es/useRequest/src/utils/subscribeReVisible.d.ts

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

package/es/useRequest/src/utils/subscribeReVisible.js

@@ -0,0 +1,21 @@
+import isBrowser from '../../../utils/isBrowser';
+import isDocumentVisible from './isDocumentVisible';
+var listeners = [];
+function subscribe(listener) {
+  listeners.push(listener);
+  return function unsubscribe() {
+    var index = listeners.indexOf(listener);
+    listeners.splice(index, 1);
+  };
+}
+if (isBrowser) {
+  var revalidate = function () {
+    if (!isDocumentVisible()) return; // 如果页面隐藏，则停止轮询，并订阅可见事件
+    for (var i = 0; i < listeners.length; i++) {
+      var listener = listeners[i];
+      listener();
+    }
+  };
+  window.addEventListener('visibilitychange', revalidate, false);
+}
+export default subscribe;

package/es/useToggle/index.d.ts

@@ -0,0 +1,10 @@
+export interface Actions<T> {
+    setLeft: () => void;
+    setRight: () => void;
+    toggle: () => void;
+    set: (value: T) => void;
+}
+declare function useToggle<T = boolean>(): [boolean, Actions<T>];
+declare function useToggle<T>(defaultValue: T): [T, Actions<T>];
+declare function useToggle<T, U>(defaultValue: T, reverseValue: U): [T | U, Actions<T | U>];
+export default useToggle;

package/es/useToggle/index.js

@@ -0,0 +1,41 @@
+import { __read } from "tslib";
+import { useMemo, useState } from 'react';
+// 这是唯一真正执行的实现函数（前面三个仅用于类型提示）。
+// D/R 是实现签名的泛型占位符，用于覆盖上面所有重载情况。
+function useToggle(defaultValue, reverseValue) {
+  if (defaultValue === void 0) {
+    defaultValue = false;
+  }
+  var _a = __read(useState(defaultValue), 2),
+    state = _a[0],
+    setState = _a[1];
+  var actions = useMemo(function () {
+    // 如果没传 reverseValue，就用 !defaultValue 作为“另一侧值”（常见于 boolean 场景）。
+    var reverseValueOrigin = reverseValue === undefined ? !defaultValue : reverseValue;
+    // toggle：在 defaultValue 与 reverseValueOrigin 之间切换。
+    var toggle = function () {
+      return setState(function (v) {
+        return v === defaultValue ? reverseValueOrigin : defaultValue;
+      });
+    };
+    // set：直接设置为传入值，值类型受泛型约束（D | R）。
+    var set = function (value) {
+      return setState(value);
+    };
+    // setLeft/setRight：这里语义是“切回左值/右值”。
+    var setLeft = function () {
+      return setState(defaultValue);
+    };
+    var setRight = function () {
+      return setState(reverseValueOrigin);
+    };
+    return {
+      toggle: toggle,
+      set: set,
+      setLeft: setLeft,
+      setRight: setRight
+    };
+  }, []);
+  return [state, actions];
+}
+export default useToggle;

package/es/useUnmount/index.d.ts

@@ -0,0 +1,2 @@
+declare const useUnmount: (fn: any) => void;
+export default useUnmount;

package/es/useUnmount/index.js

@@ -0,0 +1,17 @@
+import { useEffect } from 'react';
+import { isFunction } from '../utils';
+import isDev from '../utils/isDev';
+// 为了在开发阶段做参数校验、打印警告，帮你早点发现错误；生产环境不做这些检查，避免性能和包体积成本。
+var useUnmount = function (fn) {
+  if (isDev) {
+    if (!isFunction(fn)) {
+      console.error("useMount:parameter `fn` expected to be a function,but got \"".concat(typeof fn, "\"."));
+    }
+  }
+  useEffect(function () {
+    return function () {
+      fn === null || fn === void 0 ? void 0 : fn();
+    };
+  }, []);
+};
+export default useUnmount;

package/es/useUpdate/index.d.ts

@@ -0,0 +1,2 @@
+declare const useUpdate: () => () => void;
+export default useUpdate;

package/es/useUpdate/index.js

@@ -0,0 +1,10 @@
+import { __read } from "tslib";
+import { useCallback, useState } from 'react';
+var useUpdate = function () {
+  var _a = __read(useState({}), 2),
+    setState = _a[1];
+  return useCallback(function () {
+    return setState({});
+  }, []);
+};
+export default useUpdate;

package/es/useUpdateEffect/index.d.ts

@@ -0,0 +1,3 @@
+import { useEffect } from 'react';
+declare const _default: typeof useEffect | typeof import("react").useLayoutEffect;
+export default _default;

package/es/useUpdateEffect/index.js

@@ -0,0 +1,3 @@
+import { useEffect } from 'react';
+import { createUpdateEffect } from '../createUpdateEffect';
+export default createUpdateEffect(useEffect);

package/es/utils/createEffectWithTarget.d.ts

@@ -0,0 +1,4 @@
+import type { DependencyList, EffectCallback, useEffect, useLayoutEffect } from 'react';
+import type { BasicTarget } from './domTarget';
+declare const createEffectWithTarget: (useEffectType: typeof useEffect | typeof useLayoutEffect) => (effect: EffectCallback, deps: DependencyList, target: BasicTarget<any> | BasicTarget<any>[]) => void;
+export default createEffectWithTarget;

package/es/utils/createEffectWithTarget.js

@@ -0,0 +1,48 @@
+import { useRef } from 'react';
+import useUnmount from '../useUnmount';
+import depsAreSame from './depsAreSame';
+import { getTargetElement } from './domTarget';
+// 创建一个 effect 函数，用于在组件渲染时执行副作用，并且可以指定依赖项和目标元素
+var createEffectWithTarget = function (useEffectType) {
+  /**
+   *
+   * @param effect
+   * @param deps
+   * @param target target should compare ref.current vs ref.current, dom vs dom, ()=>dom vs ()=>dom
+   */
+  var useEffectWithTarget = function (effect, deps, target) {
+    var hasInitRef = useRef(false);
+    var lastElementRef = useRef([]);
+    var lastDepsRef = useRef([]);
+    var unLoadRef = useRef();
+    useEffectType(function () {
+      var _a;
+      var targets = Array.isArray(target) ? target : [target];
+      var els = targets.map(function (item) {
+        return getTargetElement(item);
+      });
+      // init run
+      if (!hasInitRef.current) {
+        hasInitRef.current = true;
+        lastElementRef.current = els;
+        lastDepsRef.current = deps;
+        unLoadRef.current = effect();
+        return;
+      }
+      if (els.length !== lastElementRef.current.length || !depsAreSame(els, lastElementRef.current) || !depsAreSame(deps, lastDepsRef.current)) {
+        (_a = unLoadRef.current) === null || _a === void 0 ? void 0 : _a.call(unLoadRef);
+        lastElementRef.current = els;
+        lastDepsRef.current = deps;
+        unLoadRef.current = effect();
+      }
+    });
+    useUnmount(function () {
+      var _a;
+      (_a = unLoadRef.current) === null || _a === void 0 ? void 0 : _a.call(unLoadRef);
+      // for react-refresh
+      hasInitRef.current = false;
+    });
+  };
+  return useEffectWithTarget;
+};
+export default createEffectWithTarget;

package/es/utils/depsAreSame.d.ts

@@ -0,0 +1,2 @@
+import type { DependencyList } from 'react';
+export default function depsAreSame(oldDeps: DependencyList, deps: DependencyList): boolean;

package/es/utils/depsAreSame.js

@@ -0,0 +1,8 @@
+// 判断两个依赖项是否相同
+export default function depsAreSame(oldDeps, deps) {
+  if (oldDeps === deps) return true;
+  for (var i = 0; i < oldDeps.length; i++) {
+    if (!Object.is(oldDeps[i], deps[i])) return false;
+  }
+  return true;
+}

package/es/utils/depsEqual.d.ts

@@ -0,0 +1,2 @@
+import type { DependencyList } from 'react';
+export declare const depsEqual: (aDeps?: DependencyList, bDeps?: DependencyList) => any;

package/es/utils/depsEqual.js

@@ -0,0 +1,11 @@
+import { isEqual } from 'lodash-es';
+// 判断两个依赖项是否相等
+export var depsEqual = function (aDeps, bDeps) {
+  if (aDeps === void 0) {
+    aDeps = [];
+  }
+  if (bDeps === void 0) {
+    bDeps = [];
+  }
+  return isEqual(aDeps, bDeps);
+};

package/es/utils/domTarget.d.ts

@@ -0,0 +1,6 @@
+import type { MutableRefObject } from 'react';
+type TargetValue<T> = T | undefined | null;
+type TargetType = HTMLElement | Element | Window | Document;
+export type BasicTarget<T extends TargetType = Element> = (() => TargetValue<T>) | TargetValue<T> | MutableRefObject<TargetValue<T>>;
+export declare function getTargetElement<T extends TargetType>(target: BasicTarget<T>, defaultElement?: T): TargetValue<T>;
+export {};

package/es/utils/domTarget.js

@@ -0,0 +1,20 @@
+import { isFunction } from './index';
+import isBrowser from './isBrowser';
+// 获取目标元素
+export function getTargetElement(target, defaultElement) {
+  if (!isBrowser) {
+    return undefined;
+  }
+  if (!target) {
+    return defaultElement;
+  }
+  var targetElement;
+  if (isFunction(target)) {
+    targetElement = target();
+  } else if ('current' in target) {
+    targetElement = target.current;
+  } else {
+    targetElement = target;
+  }
+  return targetElement;
+}