icode-hooks 0.3.0

package/lib/useRequest/src/useRequestImplement.js

@@ -0,0 +1,80 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _tslib = require("tslib");
+var _useCreation = _interopRequireDefault(require("../../useCreation"));
+var _useLatest = _interopRequireDefault(require("../../useLatest"));
+var _useMemoizedFn = _interopRequireDefault(require("../../useMemoizedFn"));
+var _useMount = _interopRequireDefault(require("../../useMount"));
+var _useUnmount = _interopRequireDefault(require("../../useUnmount"));
+var _useUpdate = _interopRequireDefault(require("../../useUpdate"));
+var _isDev = _interopRequireDefault(require("../../utils/isDev"));
+var _Fetch = _interopRequireDefault(require("./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 = (0, _tslib.__rest)(options, ["manual"]);
+  if (_isDev["default"]) {
+    if (options.defaultParams && !Array.isArray(options.defaultParams)) {
+      console.warn("expected defaultParams is array, got ".concat((0, _typeof2["default"])(options.defaultParams)));
+    }
+  }
+  var fetchOptions = (0, _tslib.__assign)({
+    manual: manual
+  }, rest);
+  var serviceRef = (0, _useLatest["default"])(service);
+  var update = (0, _useUpdate["default"])();
+  var fetchInstance = (0, _useCreation["default"])(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["default"](serviceRef, fetchOptions, update, Object.assign.apply(Object, (0, _tslib.__spreadArray)([{}], (0, _tslib.__read)(initState), false)));
+  }, []);
+  fetchInstance.options = fetchOptions;
+  // run all plugins hooks
+  fetchInstance.pluginImpls = plugins.map(function (p) {
+    return p(fetchInstance, fetchOptions);
+  });
+  // 挂载时执行
+  (0, _useMount["default"])(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, (0, _tslib.__spreadArray)([], (0, _tslib.__read)(params), false));
+    }
+  });
+  (0, _useUnmount["default"])(function () {
+    fetchInstance.cancel();
+  });
+  return {
+    loading: fetchInstance.state.loading,
+    data: fetchInstance.state.data,
+    error: fetchInstance.state.error,
+    params: fetchInstance.state.params || [],
+    cancel: (0, _useMemoizedFn["default"])(fetchInstance.cancel.bind(fetchInstance)),
+    refresh: (0, _useMemoizedFn["default"])(fetchInstance.refresh.bind(fetchInstance)),
+    refreshAsync: (0, _useMemoizedFn["default"])(fetchInstance.refreshAsync.bind(fetchInstance)),
+    run: (0, _useMemoizedFn["default"])(fetchInstance.run.bind(fetchInstance)),
+    runAsync: (0, _useMemoizedFn["default"])(fetchInstance.runAsync.bind(fetchInstance)),
+    mutate: (0, _useMemoizedFn["default"])(fetchInstance.mutate.bind(fetchInstance))
+  };
+}
+var _default = exports["default"] = useRequestImplement;

package/lib/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/lib/useRequest/src/utils/cache.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setCache = exports.getCache = exports.clearCache = void 0;
+var _tslib = require("tslib");
+var cache = new Map();
+var setCache = exports.setCache = function setCache(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, (0, _tslib.__assign)((0, _tslib.__assign)({}, cachedData), {
+    timer: timer
+  }));
+};
+var getCache = exports.getCache = function getCache(key) {
+  return cache.get(key);
+};
+var clearCache = exports.clearCache = function clearCache(key) {
+  if (key) {
+    var cacheKeys = Array.isArray(key) ? key : [key];
+    cacheKeys.forEach(function (cacheKey) {
+      return cache["delete"](cacheKey);
+    });
+  } else {
+    cache.clear();
+  }
+};

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

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setCachePromise = exports.getCachePromise = void 0;
+var cachePromise = new Map();
+var getCachePromise = exports.getCachePromise = function getCachePromise(cacheKey) {
+  return cachePromise.get(cacheKey);
+};
+var setCachePromise = exports.setCachePromise = function setCachePromise(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);
+  });
+};

package/lib/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/lib/useRequest/src/utils/cacheSubscribe.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.trigger = exports.subscribe = void 0;
+var listeners = {};
+var trigger = exports.trigger = function trigger(key, data) {
+  if (listeners[key]) {
+    listeners[key].forEach(function (item) {
+      return item(data);
+    });
+  }
+};
+var subscribe = exports.subscribe = function subscribe(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);
+  };
+};

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

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

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

@@ -0,0 +1,14 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = isDocumentVisible;
+var _isBrowser = _interopRequireDefault(require("../../../utils/isBrowser"));
+function isDocumentVisible() {
+  if (_isBrowser["default"]) {
+    return document.visibilityState !== 'hidden'; // 如果浏览器可见，元素是可见的
+  }
+  return true;
+}

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

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

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

@@ -0,0 +1,14 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = isOnline;
+var _isBrowser = _interopRequireDefault(require("../../../utils/isBrowser"));
+function isOnline() {
+  if (_isBrowser["default"] && typeof navigator.onLine !== 'undefined') {
+    return navigator.onLine;
+  }
+  return true;
+}

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

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

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

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = limit;
+var _tslib = require("tslib");
+// 限制函数执行频率
+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, (0, _tslib.__spreadArray)([], (0, _tslib.__read)(args), false));
+    setTimeout(function () {
+      pending = false;
+    }, timespan);
+  };
+}

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

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

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

@@ -0,0 +1,35 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _isBrowser = _interopRequireDefault(require("../../../utils/isBrowser"));
+var _isDocumentVisible = _interopRequireDefault(require("./isDocumentVisible"));
+var _isOnline = _interopRequireDefault(require("./isOnline"));
+// from swr
+
+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["default"]) {
+  var revalidate = function revalidate() {
+    if (!(0, _isDocumentVisible["default"])() || !(0, _isOnline["default"])()) return;
+    for (var i = 0; i < listeners.length; i++) {
+      var listener = listeners[i];
+      listener();
+    }
+  };
+  window.addEventListener('visibilitychange', revalidate, false);
+  window.addEventListener('focus', revalidate, false);
+}
+var _default = exports["default"] = subscribe;

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

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

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

@@ -0,0 +1,28 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _isBrowser = _interopRequireDefault(require("../../../utils/isBrowser"));
+var _isDocumentVisible = _interopRequireDefault(require("./isDocumentVisible"));
+var listeners = [];
+function subscribe(listener) {
+  listeners.push(listener);
+  return function unsubscribe() {
+    var index = listeners.indexOf(listener);
+    listeners.splice(index, 1);
+  };
+}
+if (_isBrowser["default"]) {
+  var revalidate = function revalidate() {
+    if (!(0, _isDocumentVisible["default"])()) return; // 如果页面隐藏，则停止轮询，并订阅可见事件
+    for (var i = 0; i < listeners.length; i++) {
+      var listener = listeners[i];
+      listener();
+    }
+  };
+  window.addEventListener('visibilitychange', revalidate, false);
+}
+var _default = exports["default"] = subscribe;

package/lib/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/lib/useToggle/index.js

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

package/lib/useUnmount/index.d.ts

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

package/lib/useUnmount/index.js

@@ -0,0 +1,25 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _react = require("react");
+var _utils = require("../utils");
+var _isDev = _interopRequireDefault(require("../utils/isDev"));
+// 为了在开发阶段做参数校验、打印警告，帮你早点发现错误；生产环境不做这些检查，避免性能和包体积成本。
+var useUnmount = function useUnmount(fn) {
+  if (_isDev["default"]) {
+    if (!(0, _utils.isFunction)(fn)) {
+      console.error("useMount:parameter `fn` expected to be a function,but got \"".concat((0, _typeof2["default"])(fn), "\"."));
+    }
+  }
+  (0, _react.useEffect)(function () {
+    return function () {
+      fn === null || fn === void 0 ? void 0 : fn();
+    };
+  }, []);
+};
+var _default = exports["default"] = useUnmount;

package/lib/useUpdate/index.d.ts

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

package/lib/useUpdate/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _tslib = require("tslib");
+var _react = require("react");
+var useUpdate = function useUpdate() {
+  var _a = (0, _tslib.__read)((0, _react.useState)({}), 2),
+    setState = _a[1];
+  return (0, _react.useCallback)(function () {
+    return setState({});
+  }, []);
+};
+var _default = exports["default"] = useUpdate;

package/lib/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/lib/useUpdateEffect/index.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _react = require("react");
+var _createUpdateEffect = require("../createUpdateEffect");
+var _default = exports["default"] = (0, _createUpdateEffect.createUpdateEffect)(_react.useEffect);

package/lib/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/lib/utils/createEffectWithTarget.js

@@ -0,0 +1,55 @@
+"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 _depsAreSame = _interopRequireDefault(require("./depsAreSame"));
+var _domTarget = require("./domTarget");
+// 创建一个 effect 函数，用于在组件渲染时执行副作用，并且可以指定依赖项和目标元素
+var createEffectWithTarget = function createEffectWithTarget(useEffectType) {
+  /**
+   *
+   * @param effect
+   * @param deps
+   * @param target target should compare ref.current vs ref.current, dom vs dom, ()=>dom vs ()=>dom
+   */
+  var useEffectWithTarget = function useEffectWithTarget(effect, deps, target) {
+    var hasInitRef = (0, _react.useRef)(false);
+    var lastElementRef = (0, _react.useRef)([]);
+    var lastDepsRef = (0, _react.useRef)([]);
+    var unLoadRef = (0, _react.useRef)();
+    useEffectType(function () {
+      var _a;
+      var targets = Array.isArray(target) ? target : [target];
+      var els = targets.map(function (item) {
+        return (0, _domTarget.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 || !(0, _depsAreSame["default"])(els, lastElementRef.current) || !(0, _depsAreSame["default"])(deps, lastDepsRef.current)) {
+        (_a = unLoadRef.current) === null || _a === void 0 ? void 0 : _a.call(unLoadRef);
+        lastElementRef.current = els;
+        lastDepsRef.current = deps;
+        unLoadRef.current = effect();
+      }
+    });
+    (0, _useUnmount["default"])(function () {
+      var _a;
+      (_a = unLoadRef.current) === null || _a === void 0 ? void 0 : _a.call(unLoadRef);
+      // for react-refresh
+      hasInitRef.current = false;
+    });
+  };
+  return useEffectWithTarget;
+};
+var _default = exports["default"] = createEffectWithTarget;

package/lib/utils/depsAreSame.d.ts

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

package/lib/utils/depsAreSame.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = depsAreSame;
+// 判断两个依赖项是否相同
+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/lib/utils/depsEqual.d.ts

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

package/lib/utils/depsEqual.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.depsEqual = void 0;
+var _lodashEs = require("lodash-es");
+// 判断两个依赖项是否相等
+var depsEqual = exports.depsEqual = function depsEqual(aDeps, bDeps) {
+  if (aDeps === void 0) {
+    aDeps = [];
+  }
+  if (bDeps === void 0) {
+    bDeps = [];
+  }
+  return (0, _lodashEs.isEqual)(aDeps, bDeps);
+};

package/lib/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/lib/utils/domTarget.js

@@ -0,0 +1,27 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getTargetElement = getTargetElement;
+var _index = require("./index");
+var _isBrowser = _interopRequireDefault(require("./isBrowser"));
+// 获取目标元素
+function getTargetElement(target, defaultElement) {
+  if (!_isBrowser["default"]) {
+    return undefined;
+  }
+  if (!target) {
+    return defaultElement;
+  }
+  var targetElement;
+  if ((0, _index.isFunction)(target)) {
+    targetElement = target();
+  } else if ('current' in target) {
+    targetElement = target.current;
+  } else {
+    targetElement = target;
+  }
+  return targetElement;
+}

package/lib/utils/getDocumentOrShadow.d.ts

@@ -0,0 +1,3 @@
+import type { BasicTarget } from '../utils/domTarget';
+declare const getDocumentOrShadow: (target: BasicTarget | BasicTarget[]) => Document | Node;
+export default getDocumentOrShadow;

package/lib/utils/getDocumentOrShadow.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _domTarget = require("../utils/domTarget");
+// 检查所有目标元素是否都在 Shadow DOM 中
+var checkIfAllInShadow = function checkIfAllInShadow(targets) {
+  return targets.every(function (item) {
+    var targetElement = (0, _domTarget.getTargetElement)(item);
+    if (!targetElement) return false;
+    // @ts-ignore
+    if (targetElement.getRootNode() instanceof ShadowRoot) return true;
+  });
+};
+var getShadow = function getShadow(node) {
+  if (!node) {
+    return document;
+  }
+  return node.getRootNode();
+};
+// 获取文档或 Shadow DOM
+var getDocumentOrShadow = function getDocumentOrShadow(target) {
+  if (!target || !document.getRootNode) {
+    return document;
+  }
+  var targets = Array.isArray(target) ? target : [target];
+  if (checkIfAllInShadow(targets)) {
+    return getShadow((0, _domTarget.getTargetElement)(targets[0]));
+  }
+  return document;
+};
+var _default = exports["default"] = getDocumentOrShadow;

package/lib/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 (...args: any) => any;
+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;