@bifrostui/utils 0.0.5

package/dist/hooks/useForkRef.js

@@ -0,0 +1,48 @@
+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/hooks/useForkRef.ts
+var useForkRef_exports = {};
+__export(useForkRef_exports, {
+  default: () => useForkRef
+});
+module.exports = __toCommonJS(useForkRef_exports);
+var React = __toESM(require("react"));
+var import_setRef = __toESM(require("../setRef"));
+function useForkRef(...refs) {
+  return React.useMemo(() => {
+    if (refs.every((ref) => ref == null)) {
+      return null;
+    }
+    return (instance) => {
+      refs.forEach((ref) => {
+        (0, import_setRef.default)(ref, instance);
+      });
+    };
+  }, refs);
+}

package/dist/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/dist/hooks/useMemoizedFn.js

@@ -0,0 +1,55 @@
+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/hooks/useMemoizedFn.ts
+var useMemoizedFn_exports = {};
+__export(useMemoizedFn_exports, {
+  default: () => useMemoizedFn
+});
+module.exports = __toCommonJS(useMemoizedFn_exports);
+var import_react = require("react");
+var import_isDev = __toESM(require("../isDev"));
+var import_isType = require("../isType");
+function useMemoizedFn(fn) {
+  if (import_isDev.default) {
+    if (!(0, import_isType.isFunction)(fn)) {
+      console.error(
+        `useMemoizedFn expected parameter is a function, got ${typeof fn}`
+      );
+    }
+  }
+  const fnRef = (0, import_react.useRef)(fn);
+  fnRef.current = (0, import_react.useMemo)(() => fn, [fn]);
+  const memoizedFn = (0, import_react.useRef)();
+  if (!memoizedFn.current) {
+    memoizedFn.current = function(...args) {
+      return fnRef.current.apply(this, args);
+    };
+  }
+  return memoizedFn.current;
+}

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

package/dist/hooks/useSize.js

@@ -0,0 +1,51 @@
+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/hooks/useSize.ts
+var useSize_exports = {};
+__export(useSize_exports, {
+  default: () => useSize_default
+});
+module.exports = __toCommonJS(useSize_exports);
+var import_react = __toESM(require("react"));
+var import_useDomReady = __toESM(require("./useDomReady"));
+var import_getBoundingClientRect = __toESM(require("../getBoundingClientRect"));
+var import_domTarget = require("../domTarget");
+function useSize(target) {
+  const [state, setState] = import_react.default.useState({});
+  (0, import_useDomReady.default)(() => {
+    const el = (0, import_domTarget.getTargetElement)(target);
+    if (el) {
+      (0, import_getBoundingClientRect.default)(el).then((res) => {
+        setState({ width: res.width, height: res.height });
+      });
+    }
+  });
+  return state;
+}
+var useSize_default = useSize;

package/dist/hooks/useTouchEmulator.d.ts

@@ -0,0 +1 @@
+export default function useTouchEmulator(dom?: HTMLElement | Window): void;

package/dist/hooks/useTouchEmulator.js

@@ -0,0 +1,111 @@
+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/hooks/useTouchEmulator.ts
+var useTouchEmulator_exports = {};
+__export(useTouchEmulator_exports, {
+  default: () => useTouchEmulator
+});
+module.exports = __toCommonJS(useTouchEmulator_exports);
+var import_react = require("react");
+var eventTarget;
+var Touch = function Touch2(target, identifier, pos, deltaX, deltaY) {
+  deltaX = deltaX || 0;
+  deltaY = deltaY || 0;
+  this.identifier = identifier;
+  this.target = target;
+  this.clientX = pos.clientX + deltaX;
+  this.clientY = pos.clientY + deltaY;
+  this.screenX = pos.screenX + deltaX;
+  this.screenY = pos.screenY + deltaY;
+  this.pageX = pos.pageX + deltaX;
+  this.pageY = pos.pageY + deltaY;
+};
+function TouchList() {
+  const touchList = [];
+  touchList.item = (index) => {
+    return this[index] || null;
+  };
+  touchList.identifiedTouch = (id) => {
+    return this[id + 1] || null;
+  };
+  return touchList;
+}
+var initiated = false;
+function onMouse(touchType) {
+  return function(ev) {
+    if (ev.type === "mousedown") {
+      initiated = true;
+    }
+    if (ev.type === "mouseup") {
+      initiated = false;
+    }
+    if (ev.type === "mousemove" && !initiated) {
+      return;
+    }
+    if (ev.type === "mousedown" || !eventTarget || eventTarget && !eventTarget.dispatchEvent) {
+      eventTarget = ev.target;
+    }
+    triggerTouch(touchType, ev);
+    if (ev.type === "mouseup") {
+      eventTarget = null;
+    }
+  };
+}
+function triggerTouch(eventName, mouseEv) {
+  const touchEvent = document.createEvent("Event");
+  touchEvent.initEvent(eventName, true, false);
+  touchEvent.altKey = mouseEv.altKey;
+  touchEvent.ctrlKey = mouseEv.ctrlKey;
+  touchEvent.metaKey = mouseEv.metaKey;
+  touchEvent.shiftKey = mouseEv.shiftKey;
+  touchEvent.touches = getActiveTouches(mouseEv);
+  touchEvent.targetTouches = getActiveTouches(mouseEv);
+  touchEvent.changedTouches = createTouchList(mouseEv);
+  eventTarget.dispatchEvent(touchEvent);
+}
+function createTouchList(mouseEv) {
+  const touchList = TouchList();
+  touchList.push(new Touch(eventTarget, 1, mouseEv, 0, 0));
+  return touchList;
+}
+function getActiveTouches(mouseEv) {
+  if (mouseEv.type === "mouseup") {
+    return TouchList();
+  }
+  return createTouchList(mouseEv);
+}
+function useTouchEmulator(dom = window) {
+  const touchStart = onMouse("touchstart");
+  const touchMove = onMouse("touchmove");
+  const touchEnd = onMouse("touchend");
+  (0, import_react.useEffect)(() => {
+    if (dom) {
+      dom.addEventListener("mousedown", touchStart, true);
+      dom.addEventListener("mousemove", touchMove, true);
+      dom.addEventListener("mouseup", touchEnd, true);
+    }
+    return () => {
+      if (dom) {
+        dom.removeEventListener("mousedown", touchStart, true);
+        dom.removeEventListener("mousemove", touchMove, true);
+        dom.removeEventListener("mouseup", touchEnd, true);
+      }
+    };
+  }, [dom]);
+}

package/dist/hooks/useValue.d.ts

@@ -0,0 +1,12 @@
+import { ChangeEvent } from 'react';
+type Options<T> = {
+    value?: T;
+    defaultValue: T;
+    onChange?: (e: ChangeEvent<HTMLElement>, data: Record<string, any>) => void;
+    config?: {
+        name?: string;
+        state?: string;
+    };
+};
+export default function useValue<T>(options: Options<T>): readonly [T, (e: any, val: any) => void];
+export {};

package/dist/hooks/useValue.js

@@ -0,0 +1,49 @@
+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/hooks/useValue.ts
+var useValue_exports = {};
+__export(useValue_exports, {
+  default: () => useValue
+});
+module.exports = __toCommonJS(useValue_exports);
+var import_react = require("react");
+function useValue(options) {
+  const { value, defaultValue, onChange, config = {} } = options;
+  const { state, name } = config;
+  const [internalValue, setInternalValue] = (0, import_react.useState)(defaultValue);
+  const initialDefaultValue = (0, import_react.useRef)(defaultValue);
+  const isControlled = value !== void 0;
+  (0, import_react.useEffect)(() => {
+    if (!isControlled && JSON.stringify(defaultValue) !== JSON.stringify(initialDefaultValue.current) && state && name) {
+      console.error(
+        [
+          `BUI: A component is changing the default ${state} state of an uncontrolled ${name} after being initialized. To suppress this warning opt to use a controlled ${name}.`
+        ].join("\n")
+      );
+    }
+  }, [defaultValue]);
+  const triggerChange = (0, import_react.useCallback)(
+    (e, val) => {
+      setInternalValue(val);
+      onChange == null ? void 0 : onChange(e, { value: val });
+    },
+    [onChange]
+  );
+  return [isControlled ? value : internalValue, triggerChange];
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export { default as debounce } from './debounce';
+export { default as convertHexToRGBA } from './hex2rgba';
+export { useDidMountEffect, useEventCallback, useForkRef, useTouchEmulator, useValue, useDomReady, useSize, useDomCss, } from './hooks';
+export { default as isDev } from './isDev';
+export { isMini, isWeapp, isAlipay } from './isMini';
+export { default as setRef } from './setRef';
+export { default as throttle } from './throttle';
+export { default as toArray } from './toArray';
+export { default as blockTouch } from './touchBlocker';
+export { easing, duration, getTransitionProps, createTransitions, } from './transitions';
+export { default as getBoundingClientRect } from './getBoundingClientRect';
+export * from './isType';

package/dist/index.js

@@ -0,0 +1,96 @@
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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/index.ts
+var src_exports = {};
+__export(src_exports, {
+  blockTouch: () => import_touchBlocker.default,
+  convertHexToRGBA: () => import_hex2rgba.default,
+  createTransitions: () => import_transitions.createTransitions,
+  debounce: () => import_debounce.default,
+  duration: () => import_transitions.duration,
+  easing: () => import_transitions.easing,
+  getBoundingClientRect: () => import_getBoundingClientRect.default,
+  getTransitionProps: () => import_transitions.getTransitionProps,
+  isAlipay: () => import_isMini.isAlipay,
+  isDev: () => import_isDev.default,
+  isMini: () => import_isMini.isMini,
+  isWeapp: () => import_isMini.isWeapp,
+  setRef: () => import_setRef.default,
+  throttle: () => import_throttle.default,
+  toArray: () => import_toArray.default,
+  useDidMountEffect: () => import_hooks.useDidMountEffect,
+  useDomCss: () => import_hooks.useDomCss,
+  useDomReady: () => import_hooks.useDomReady,
+  useEventCallback: () => import_hooks.useEventCallback,
+  useForkRef: () => import_hooks.useForkRef,
+  useSize: () => import_hooks.useSize,
+  useTouchEmulator: () => import_hooks.useTouchEmulator,
+  useValue: () => import_hooks.useValue
+});
+module.exports = __toCommonJS(src_exports);
+var import_debounce = __toESM(require("./debounce"));
+var import_hex2rgba = __toESM(require("./hex2rgba"));
+var import_hooks = require("./hooks");
+var import_isDev = __toESM(require("./isDev"));
+var import_isMini = require("./isMini");
+var import_setRef = __toESM(require("./setRef"));
+var import_throttle = __toESM(require("./throttle"));
+var import_toArray = __toESM(require("./toArray"));
+var import_touchBlocker = __toESM(require("./touchBlocker"));
+var import_transitions = require("./transitions");
+var import_getBoundingClientRect = __toESM(require("./getBoundingClientRect"));
+__reExport(src_exports, require("./isType"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  blockTouch,
+  convertHexToRGBA,
+  createTransitions,
+  debounce,
+  duration,
+  easing,
+  getBoundingClientRect,
+  getTransitionProps,
+  isAlipay,
+  isDev,
+  isMini,
+  isWeapp,
+  setRef,
+  throttle,
+  toArray,
+  useDidMountEffect,
+  useDomCss,
+  useDomReady,
+  useEventCallback,
+  useForkRef,
+  useSize,
+  useTouchEmulator,
+  useValue,
+  ...require("./isType")
+});

package/dist/isDev.d.ts

@@ -0,0 +1,2 @@
+declare const isDev: boolean;
+export default isDev;

package/dist/isDev.js

@@ -0,0 +1,26 @@
+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/isDev.ts
+var isDev_exports = {};
+__export(isDev_exports, {
+  default: () => isDev_default
+});
+module.exports = __toCommonJS(isDev_exports);
+var isDev = process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test";
+var isDev_default = isDev;

package/dist/isMini.d.ts

@@ -0,0 +1,4 @@
+declare const isMini: boolean;
+declare const isWeapp: boolean;
+declare const isAlipay: boolean;
+export { isMini, isWeapp, isAlipay };

package/dist/isMini.js

@@ -0,0 +1,35 @@
+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/isMini.ts
+var isMini_exports = {};
+__export(isMini_exports, {
+  isAlipay: () => isAlipay,
+  isMini: () => isMini,
+  isWeapp: () => isWeapp
+});
+module.exports = __toCommonJS(isMini_exports);
+var isMini = typeof process.env.TARO_ENV === "string";
+var isWeapp = process.env.TARO_ENV === "weapp";
+var isAlipay = process.env.TARO_ENV === "alipay";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isAlipay,
+  isMini,
+  isWeapp
+});

package/dist/isType.d.ts

@@ -0,0 +1 @@
+export declare const isFunction: (fn: any) => boolean;

package/dist/isType.js

@@ -0,0 +1,31 @@
+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/isType.ts
+var isType_exports = {};
+__export(isType_exports, {
+  isFunction: () => isFunction
+});
+module.exports = __toCommonJS(isType_exports);
+var isFunction = (fn) => {
+  return fn && {}.toString.call(fn) === "[object Function]";
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isFunction
+});

package/dist/setRef.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export default function setRef<T>(ref: React.MutableRefObject<T | null> | ((instance: T | null) => void) | null | undefined, value: T | null): void;

package/dist/setRef.js

@@ -0,0 +1,31 @@
+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/setRef.ts
+var setRef_exports = {};
+__export(setRef_exports, {
+  default: () => setRef
+});
+module.exports = __toCommonJS(setRef_exports);
+function setRef(ref, value) {
+  if (typeof ref === "function") {
+    ref(value);
+  } else if (ref) {
+    ref.current = value;
+  }
+}

package/dist/throttle.d.ts

@@ -0,0 +1,6 @@
+interface OptionsThrottle {
+    leading?: boolean;
+    trailing?: boolean;
+}
+export default function throttle(fn: any, interval?: number, options?: OptionsThrottle): (...args: any[]) => void;
+export {};

package/dist/throttle.js

@@ -0,0 +1,52 @@
+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/throttle.ts
+var throttle_exports = {};
+__export(throttle_exports, {
+  default: () => throttle
+});
+module.exports = __toCommonJS(throttle_exports);
+function throttle(fn, interval = 200, options = { leading: true, trailing: false }) {
+  const { leading = true, trailing = false } = options;
+  let lastTime = 0;
+  let timer = null;
+  const _throttle = function(...args) {
+    const nowTime = (/* @__PURE__ */ new Date()).getTime();
+    if (!lastTime && !leading)
+      lastTime = nowTime;
+    const remainTime = interval - (nowTime - lastTime);
+    if (remainTime <= 0) {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      fn.apply(this, args);
+      lastTime = nowTime;
+      return;
+    }
+    if (trailing && !timer) {
+      timer = setTimeout(() => {
+        timer = null;
+        lastTime = !leading ? 0 : (/* @__PURE__ */ new Date()).getTime();
+        fn.apply(this, args);
+      }, remainTime);
+    }
+  };
+  return _throttle;
+}

package/dist/toArray.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface Option {
+    keepEmpty?: boolean;
+}
+export default function toArray(children: React.ReactNode, option?: Option): React.ReactElement[];
+export {};