@bifrostui/utils 0.0.5

package/dist/toArray.js

@@ -0,0 +1,52 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/toArray.ts
+var toArray_exports = {};
+__export(toArray_exports, {
+  default: () => toArray
+});
+module.exports = __toCommonJS(toArray_exports);
+var import_react = __toESM(require("react"));
+var import_react_is = require("react-is");
+function toArray(children, option = {}) {
+  let ret = [];
+  import_react.default.Children.forEach(children, (child) => {
+    if ((child === void 0 || child === null) && !option.keepEmpty) {
+      return;
+    }
+    if (Array.isArray(child)) {
+      ret = ret.concat(toArray(child));
+    } else if ((0, import_react_is.isFragment)(child) && child.props) {
+      ret = ret.concat(toArray(child.props.children, option));
+    } else {
+      ret.push(child);
+    }
+  });
+  return ret;
+}

package/dist/touchBlocker.d.ts

@@ -0,0 +1,11 @@
+/**
+ * author: 辉宇
+ * 为一个DOM元素添加滑动穿透防护
+ * 返回一个函数，调用可解除滑动穿透防护
+ *
+ * **这里滑动穿透防护的定义为不允许root外部的元素被touch类事件滑动（overflow）**
+ *
+ * @param root: HTMLElement
+ * @returns {(function(): void)|*}
+ */
+export default function blockTouch(root: any): () => void;

package/dist/touchBlocker.js

@@ -0,0 +1,108 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/touchBlocker.ts
+var touchBlocker_exports = {};
+__export(touchBlocker_exports, {
+  default: () => blockTouch
+});
+module.exports = __toCommonJS(touchBlocker_exports);
+function blockTouch(root) {
+  let lastTouch;
+  let moveDirection;
+  let moveAxis;
+  const onTouchStart = (e) => {
+    [lastTouch] = e.touches;
+  };
+  const shouldPrevent = (targetElement, axis, delta) => {
+    let el = targetElement;
+    let needPrevent = true;
+    while (el) {
+      const { overflowY, overflowX } = window.getComputedStyle(el);
+      if (axis === "y" && (overflowY === "scroll" || overflowY === "auto")) {
+        const dir = moveDirection || delta;
+        if (moveDirection === void 0)
+          moveDirection = dir;
+        if (el.scrollTop !== 0 && dir < 0) {
+          needPrevent = false;
+          break;
+        }
+        if (el.scrollTop + el.offsetHeight + 1 < el.scrollHeight && dir > 0) {
+          needPrevent = false;
+          break;
+        }
+      }
+      if (axis === "x" && (overflowX === "scroll" || overflowX === "auto")) {
+        const dir = moveDirection || delta;
+        if (moveDirection === void 0)
+          moveDirection = dir;
+        if (el.scrollLeft !== 0 && dir < 0) {
+          needPrevent = false;
+          break;
+        }
+        if (el.scrollLeft + el.offsetWidth < el.scrollWidth && dir > 0) {
+          needPrevent = false;
+          break;
+        }
+      }
+      if (el === root)
+        break;
+      el = el.parentNode;
+    }
+    return needPrevent;
+  };
+  const onTouchMove = (e) => {
+    const currentTouch = e.touches[0];
+    if (!moveAxis) {
+      if (Math.abs(lastTouch.screenY - currentTouch.screenY) > Math.abs(lastTouch.screenX - currentTouch.screenX))
+        moveAxis = "y";
+      if (Math.abs(lastTouch.screenY - currentTouch.screenY) < Math.abs(lastTouch.screenX - currentTouch.screenX))
+        moveAxis = "x";
+    }
+    if (shouldPrevent(
+      e.target,
+      moveAxis,
+      moveAxis === "x" ? lastTouch.screenX - currentTouch.screenX : lastTouch.screenY - currentTouch.screenY
+    ) && !e.cancelable === false)
+      e.preventDefault();
+  };
+  const onTouchEnd = () => {
+    lastTouch = void 0;
+    moveDirection = void 0;
+    moveAxis = void 0;
+  };
+  const onScroll = (e) => {
+    if (shouldPrevent(
+      e.target,
+      Math.abs(e.deltaX) > Math.abs(e.deltaY) ? "x" : "y",
+      Math.abs(e.deltaX) > Math.abs(e.deltaY) ? e.deltaX : e.deltaY
+    ) && !e.cancelable === false)
+      e.preventDefault();
+    moveDirection = void 0;
+  };
+  root.addEventListener("touchstart", onTouchStart);
+  root.addEventListener("touchmove", onTouchMove);
+  root.addEventListener("touchend", onTouchEnd);
+  root.addEventListener("wheel", onScroll);
+  return () => {
+    root.removeEventListener("touchstart", onTouchStart);
+    root.removeEventListener("touchmove", onTouchMove);
+    root.removeEventListener("touchend", onTouchEnd);
+    root.removeEventListener("wheel", onScroll);
+  };
+}

package/dist/transitions.d.ts

@@ -0,0 +1,72 @@
+import React from 'react';
+interface IEasing {
+    easeInOut: string;
+    easeIn: string;
+    easeOut: string;
+    sharp: string;
+}
+interface IDuration {
+    shortest: number;
+    shorter: number;
+    short: number;
+    standard: number;
+    complex: number;
+    enteringScreen: number;
+    leavingScreen: number;
+}
+export declare const easing: IEasing;
+export declare const duration: IDuration;
+interface ComponentProps {
+    easing: string | {
+        enter?: string;
+        exit?: string;
+    } | undefined;
+    style: React.CSSProperties | undefined;
+    timeout: number | {
+        enter?: number;
+        exit?: number;
+    };
+    delay: number | {
+        enter?: number;
+        exit?: number;
+    };
+}
+interface Options {
+    mode: 'enter' | 'exit' | 'unmounted' | 'exited' | 'entering' | 'entered' | 'exiting';
+}
+interface TransitionOptions {
+    duration: string | number;
+    easing: string | undefined;
+    delay: string | number;
+}
+export declare function getTransitionProps(props: ComponentProps, options: Options): TransitionOptions;
+interface IInputTransition {
+    easing: IEasing;
+    duration: IDuration;
+    delay: number;
+}
+type ITransitionProps = string | string[];
+export declare function createTransitions(inputTransitions?: Partial<IInputTransition>): {
+    easing: {
+        easeInOut: string;
+        easeIn: string;
+        easeOut: string;
+        sharp: string;
+    };
+    duration: {
+        shortest: number;
+        shorter: number;
+        short: number;
+        standard: number;
+        complex: number;
+        enteringScreen: number;
+        leavingScreen: number;
+    };
+    delay?: number;
+    create: (props?: ITransitionProps, options?: Partial<{
+        duration: number | string;
+        easing: string;
+        delay: number | string;
+    }>) => string;
+};
+export {};

package/dist/transitions.js

@@ -0,0 +1,91 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/transitions.ts
+var transitions_exports = {};
+__export(transitions_exports, {
+  createTransitions: () => createTransitions,
+  duration: () => duration,
+  easing: () => easing,
+  getTransitionProps: () => getTransitionProps
+});
+module.exports = __toCommonJS(transitions_exports);
+var easing = {
+  easeInOut: "cubic-bezier(0.4, 0, 0.2, 1)",
+  easeOut: "cubic-bezier(0.0, 0, 0.2, 1)",
+  easeIn: "cubic-bezier(0.4, 0, 1, 1)",
+  sharp: "cubic-bezier(0.4, 0, 0.6, 1)"
+};
+var duration = {
+  shortest: 150,
+  shorter: 200,
+  short: 250,
+  /** 标准 */
+  standard: 300,
+  /** 用在复杂动画场景 */
+  complex: 375,
+  enteringScreen: 225,
+  leavingScreen: 195
+};
+function getTransitionProps(props, options) {
+  const { timeout, easing: easingProps, style = {}, delay } = props;
+  let { mode } = options;
+  if (mode !== "enter" && mode !== "exit")
+    mode = mode === "entering" || mode === "entered" ? "enter" : "exit";
+  return {
+    duration: style.transitionDuration ?? (typeof timeout === "number" ? timeout : timeout[mode] || 0),
+    easing: style.transitionTimingFunction ?? (typeof easingProps === "object" ? easingProps[mode] : easingProps),
+    delay: style.transitionDelay ?? (typeof delay === "number" ? delay : delay[mode] || 0)
+  };
+}
+function formatMs(milliseconds) {
+  return `${Math.round(milliseconds)}ms`;
+}
+function createTransitions(inputTransitions = {}) {
+  const mergedEasing = {
+    ...easing,
+    ...inputTransitions.easing
+  };
+  const mergedDuration = {
+    ...duration,
+    ...inputTransitions.duration
+  };
+  const create = (props = ["all"], options) => {
+    const {
+      duration: durationOption = mergedDuration.standard,
+      easing: easingOption = mergedEasing.easeInOut,
+      delay = 0
+    } = options;
+    return (Array.isArray(props) ? props : [props]).map(
+      (animatedProp) => `${animatedProp} ${typeof durationOption === "string" ? durationOption : formatMs(durationOption)} ${easingOption} ${typeof delay === "string" ? delay : formatMs(delay)}`
+    ).join(",");
+  };
+  return {
+    create,
+    ...inputTransitions,
+    easing: mergedEasing,
+    duration: mergedDuration
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createTransitions,
+  duration,
+  easing,
+  getTransitionProps
+});

package/es/debounce.d.ts

@@ -0,0 +1 @@
+export default function debounce(func: any, wait: number, immediate?: boolean): (...args: any[]) => void;

package/es/debounce.js

@@ -0,0 +1,15 @@
+export default function debounce(func, wait, immediate) {
+  var timeout;
+  return function () {
+    var _this = this;
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    if (immediate && !timeout) func.apply(this, args);
+    clearTimeout(timeout);
+    timeout = setTimeout(function () {
+      timeout = null;
+      if (!immediate) func.apply(_this, args);
+    }, wait);
+  };
+}

package/es/domTarget.d.ts

@@ -0,0 +1,7 @@
+import type { MutableRefObject } from 'react';
+import type { TaroElement } from '@tarojs/runtime';
+type TargetValue<T> = T | undefined | null;
+type TargetType = HTMLElement | Element | TaroElement | 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): T;
+export {};

package/es/domTarget.js

@@ -0,0 +1,14 @@
+export function getTargetElement(target, defaultElement) {
+  if (!target) {
+    return defaultElement;
+  }
+  var targetElement;
+  if (typeof target === 'function') {
+    targetElement = target();
+  } else if ('current' in target) {
+    targetElement = target.current;
+  } else {
+    targetElement = target;
+  }
+  return targetElement;
+}

package/es/getBoundingClientRect/index.d.ts

@@ -0,0 +1 @@
+export default function getBoundingClientRect(ele: Element): Promise<DOMRect>;

package/es/getBoundingClientRect/index.js

@@ -0,0 +1,3 @@
+export default function getBoundingClientRect(ele) {
+  return Promise.resolve(ele.getBoundingClientRect());
+}

package/es/getBoundingClientRect/index.miniapp.d.ts

@@ -0,0 +1,2 @@
+import type { TaroElement } from '@tarojs/runtime';
+export default function getBoundingClientRect(ele: TaroElement): Promise<DOMRect>;

package/es/getBoundingClientRect/index.miniapp.js

@@ -0,0 +1,17 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import Taro from '@tarojs/taro';
+export default function getBoundingClientRect(ele) {
+  return new Promise(function (resolve) {
+    var query = Taro.createSelectorQuery();
+    query.select("#".concat(ele.uid)).boundingClientRect().exec(function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 1),
+        res = _ref2[0];
+      resolve(res);
+    });
+  });
+}

package/es/hex2rgba.d.ts

@@ -0,0 +1,2 @@
+declare const convertHexToRGBA: (hexCode: string, opacity?: number) => string;
+export default convertHexToRGBA;

package/es/hex2rgba.js

@@ -0,0 +1,25 @@
+/*
+ * @Author: @跃知
+ * @Date: 2021-12-30 20:30:48
+ * @LastEditors: @跃知
+ * @LastEditTime: 2021-12-30 20:35:26
+ * @Description: 颜色处理
+ */
+var convertHexToRGBA = function convertHexToRGBA(hexCode) {
+  var opacity = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+  var hex = hexCode.replace('#', '');
+  if (hex.length === 3) {
+    hex = "".concat(hex[0]).concat(hex[0]).concat(hex[1]).concat(hex[1]).concat(hex[2]).concat(hex[2]);
+  }
+  var r = parseInt(hex.substring(0, 2), 16);
+  var g = parseInt(hex.substring(2, 4), 16);
+  var b = parseInt(hex.substring(4, 6), 16);
+  var a = opacity;
+
+  /* Backward compatibility for whole number based opacity values. */
+  if (opacity > 1 && opacity <= 100) {
+    a = opacity / 100;
+  }
+  return "rgba(".concat(r, ",").concat(g, ",").concat(b, ",").concat(a, ")");
+};
+export default convertHexToRGBA;

package/es/hooks/index.d.ts

@@ -0,0 +1,9 @@
+import useDidMountEffect from './useDidMountEffect';
+import useEventCallback from './useEventCallback';
+import useForkRef from './useForkRef';
+import useTouchEmulator from './useTouchEmulator';
+import useValue from './useValue';
+import useDomReady from './useDomReady';
+import useSize from './useSize';
+import useDomCss from './useDomCss';
+export { useValue, useForkRef, useEventCallback, useDidMountEffect, useTouchEmulator, useDomReady, useSize, useDomCss, };

package/es/hooks/index.js

@@ -0,0 +1,9 @@
+import useDidMountEffect from "./useDidMountEffect";
+import useEventCallback from "./useEventCallback";
+import useForkRef from "./useForkRef";
+import useTouchEmulator from "./useTouchEmulator";
+import useValue from "./useValue";
+import useDomReady from "./useDomReady";
+import useSize from "./useSize";
+import useDomCss from "./useDomCss";
+export { useValue, useForkRef, useEventCallback, useDidMountEffect, useTouchEmulator, useDomReady, useSize, useDomCss };

package/es/hooks/useDidMountEffect.d.ts

@@ -0,0 +1,5 @@
+/**
+ * skip inital run useEffect
+ */
+declare const useDidMountEffect: (func: any, deps: any) => void;
+export default useDidMountEffect;

package/es/hooks/useDidMountEffect.js

@@ -0,0 +1,11 @@
+import { useEffect, useRef } from 'react';
+/**
+ * skip inital run useEffect
+ */
+var useDidMountEffect = function useDidMountEffect(func, deps) {
+  var didMount = useRef(false);
+  useEffect(function () {
+    if (didMount.current) func();else didMount.current = true;
+  }, deps);
+};
+export default useDidMountEffect;

package/es/hooks/useDomCss/index.d.ts

@@ -0,0 +1,3 @@
+import type { BasicTarget } from '../../domTarget';
+declare function useDomCss(target: BasicTarget, computedStyle: string[], cb: (res: Record<string, any>) => void): void;
+export default useDomCss;

package/es/hooks/useDomCss/index.js

@@ -0,0 +1,14 @@
+import useDomReady from "../useDomReady";
+import { getTargetElement } from "../../domTarget";
+function useDomCss(target, computedStyle, cb) {
+  useDomReady(function () {
+    var ele = getTargetElement(target);
+    var style = window.getComputedStyle(ele, null);
+    var res = {};
+    computedStyle.forEach(function (key) {
+      res[key] = style === null || style === void 0 ? void 0 : style[key];
+    });
+    cb === null || cb === void 0 || cb(res);
+  });
+}
+export default useDomCss;

package/es/hooks/useDomCss/index.miniapp.d.ts

@@ -0,0 +1,3 @@
+import type { TaroElement } from '@tarojs/runtime';
+declare function useDomCss(target: TaroElement, computedStyle: string[], cb: (res: Record<string, any>) => void): void;
+export default useDomCss;

package/es/hooks/useDomCss/index.miniapp.js

@@ -0,0 +1,17 @@
+import Taro from '@tarojs/taro';
+import useDomReady from "../useDomReady";
+import { getTargetElement } from "../../domTarget";
+function useDomCss(target, computedStyle, cb) {
+  useDomReady(function () {
+    var ele = getTargetElement(target);
+    if (ele) {
+      var query = Taro.createSelectorQuery();
+      query.select("#".concat(ele === null || ele === void 0 ? void 0 : ele.uid)).fields({
+        computedStyle: computedStyle
+      }).exec(function (res) {
+        cb === null || cb === void 0 || cb(res === null || res === void 0 ? void 0 : res[0]);
+      });
+    }
+  });
+}
+export default useDomCss;

package/es/hooks/useDomReady/index.d.ts

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

package/es/hooks/useDomReady/index.js

@@ -0,0 +1,7 @@
+import React from 'react';
+function useDomReady(cb) {
+  React.useEffect(function () {
+    cb === null || cb === void 0 || cb();
+  }, []);
+}
+export default useDomReady;

package/es/hooks/useDomReady/index.miniapp.d.ts

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

package/es/hooks/useDomReady/index.miniapp.js

@@ -0,0 +1,9 @@
+import Taro from '@tarojs/taro';
+function useDomReady(cb) {
+  Taro.useReady(function () {
+    Taro.nextTick(function () {
+      cb === null || cb === void 0 || cb();
+    });
+  });
+}
+export default useDomReady;

package/es/hooks/useEventCallback.d.ts

@@ -0,0 +1,6 @@
+/**
+ * https://github.com/facebook/react/issues/14099#issuecomment-440013892
+ *
+ * @param {function} fn
+ */
+export default function useEventCallback(fn: any): (...args: any[]) => any;

package/es/hooks/useEventCallback.js

@@ -0,0 +1,18 @@
+import React, { useLayoutEffect } from 'react';
+
+/**
+ * https://github.com/facebook/react/issues/14099#issuecomment-440013892
+ *
+ * @param {function} fn
+ */
+export default function useEventCallback(fn) {
+  var ref = React.useRef(fn);
+  useLayoutEffect(function () {
+    ref.current = fn;
+  });
+
+  // @ts-ignore
+  return React.useCallback(function () {
+    return (0, ref.current).apply(void 0, arguments);
+  }, []);
+}

package/es/hooks/useForkRef.d.ts

@@ -0,0 +1,2 @@
+import * as React from 'react';
+export default function useForkRef<Instance>(...refs: Array<React.Ref<Instance> | undefined>): React.RefCallback<Instance> | null;

package/es/hooks/useForkRef.js

@@ -0,0 +1,25 @@
+import * as React from 'react';
+import setRef from "../setRef";
+export default function useForkRef() {
+  for (var _len = arguments.length, refs = new Array(_len), _key = 0; _key < _len; _key++) {
+    refs[_key] = arguments[_key];
+  }
+  /**
+   * This will create a new function if the refs passed to this hook change and are all defined.
+   * This means react will call the old forkRef with `null` and the new forkRef
+   * with the ref. Cleanup naturally emerges from this behavior.
+   */
+  return React.useMemo(function () {
+    if (refs.every(function (ref) {
+      return ref == null;
+    })) {
+      return null;
+    }
+    return function (instance) {
+      refs.forEach(function (ref) {
+        setRef(ref, instance);
+      });
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, refs);
+}

package/es/hooks/useMemoizedFn.d.ts

@@ -0,0 +1,3 @@
+type noop = (this: any, ...args: any[]) => any;
+export default function useMemoizedFn<T extends noop>(fn: T): T;
+export {};

package/es/hooks/useMemoizedFn.js

@@ -0,0 +1,25 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+import { useMemo, useRef } from 'react';
+import isDev from "../isDev";
+import { isFunction } from "../isType";
+export default function useMemoizedFn(fn) {
+  if (isDev) {
+    if (!isFunction(fn)) {
+      console.error("useMemoizedFn expected parameter is a function, got ".concat(_typeof(fn)));
+    }
+  }
+  var fnRef = useRef(fn);
+  fnRef.current = useMemo(function () {
+    return fn;
+  }, [fn]);
+  var memoizedFn = useRef();
+  if (!memoizedFn.current) {
+    memoizedFn.current = function () {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      return fnRef.current.apply(this, args);
+    };
+  }
+  return memoizedFn.current;
+}

package/es/hooks/useSize.d.ts

@@ -0,0 +1,7 @@
+import type { BasicTarget } from '../domTarget';
+type Size = {
+    width: number;
+    height: number;
+};
+declare function useSize(target: BasicTarget): Size;
+export default useSize;