react-vant-nova 1.0.0-test

package/lib/hooks/index.js

@@ -0,0 +1,145 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+Object.defineProperty(exports, "useClickAway", {
+  enumerable: true,
+  get: function () {
+    return _useClickAway.default;
+  }
+});
+Object.defineProperty(exports, "useCountDown", {
+  enumerable: true,
+  get: function () {
+    return _useCountDown.default;
+  }
+});
+Object.defineProperty(exports, "useEventListener", {
+  enumerable: true,
+  get: function () {
+    return _useEventListener.default;
+  }
+});
+Object.defineProperty(exports, "useFormSmart", {
+  enumerable: true,
+  get: function () {
+    return _useFormSmart.default;
+  }
+});
+Object.defineProperty(exports, "useInViewport", {
+  enumerable: true,
+  get: function () {
+    return _useInViewport.default;
+  }
+});
+Object.defineProperty(exports, "useIsomorphicLayoutEffect", {
+  enumerable: true,
+  get: function () {
+    return _useIsomorphicLayoutEffect.default;
+  }
+});
+Object.defineProperty(exports, "useMemoizedFn", {
+  enumerable: true,
+  get: function () {
+    return _useMemoizedFn.default;
+  }
+});
+Object.defineProperty(exports, "useMount", {
+  enumerable: true,
+  get: function () {
+    return _useMount.default;
+  }
+});
+Object.defineProperty(exports, "usePageVisibility", {
+  enumerable: true,
+  get: function () {
+    return _usePageVisibility.default;
+  }
+});
+Object.defineProperty(exports, "usePropsValue", {
+  enumerable: true,
+  get: function () {
+    return _usePropsValue.default;
+  }
+});
+Object.defineProperty(exports, "useScrollParent", {
+  enumerable: true,
+  get: function () {
+    return _useScrollParent.default;
+  }
+});
+Object.defineProperty(exports, "useSetState", {
+  enumerable: true,
+  get: function () {
+    return _useSetState.default;
+  }
+});
+Object.defineProperty(exports, "useTouch", {
+  enumerable: true,
+  get: function () {
+    return _useTouch.default;
+  }
+});
+Object.defineProperty(exports, "useUpdate", {
+  enumerable: true,
+  get: function () {
+    return _useUpdate.default;
+  }
+});
+Object.defineProperty(exports, "useUpdateEffect", {
+  enumerable: true,
+  get: function () {
+    return _useUpdateEffect.default;
+  }
+});
+Object.defineProperty(exports, "useVisibilityChange", {
+  enumerable: true,
+  get: function () {
+    return _useVisibilityChange.default;
+  }
+});
+Object.defineProperty(exports, "useWindowSize", {
+  enumerable: true,
+  get: function () {
+    return _useWindowSize.default;
+  }
+});
+var _useClickAway = _interopRequireDefault(require("./use-click-away"));
+var _useCountDown = _interopRequireDefault(require("./use-count-down"));
+var _useEventListener = _interopRequireDefault(require("./use-event-listener"));
+var _useFormSmart = _interopRequireDefault(require("./use-form-smart"));
+var _useSetState = _interopRequireDefault(require("./use-set-state"));
+var _useUpdateEffect = _interopRequireDefault(require("./use-update-effect"));
+var _useMount = _interopRequireDefault(require("./use-mount"));
+var _usePageVisibility = _interopRequireDefault(require("./use-page-visibility"));
+var _useVisibilityChange = _interopRequireDefault(require("./use-visibility-change"));
+var _useInViewport = _interopRequireDefault(require("./use-in-viewport"));
+var _useTouch = _interopRequireDefault(require("./use-touch"));
+var _useScrollParent = _interopRequireDefault(require("./use-scroll-parent"));
+var _useWindowSize = _interopRequireDefault(require("./use-window-size"));
+var _useIsomorphicLayoutEffect = _interopRequireDefault(require("./use-isomorphic-layout-effect"));
+var _useUpdate = _interopRequireDefault(require("./use-update"));
+var _useMemoizedFn = _interopRequireDefault(require("./use-memoized-fn"));
+var _usePropsValue = _interopRequireDefault(require("./use-props-value"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var _default = exports.default = {
+  useClickAway: _useClickAway.default,
+  useCountDown: _useCountDown.default,
+  useEventListener: _useEventListener.default,
+  useFormSmart: _useFormSmart.default,
+  useSetState: _useSetState.default,
+  useUpdateEffect: _useUpdateEffect.default,
+  useMount: _useMount.default,
+  usePageVisibility: _usePageVisibility.default,
+  useVisibilityChange: _useVisibilityChange.default,
+  useInViewport: _useInViewport.default,
+  useTouch: _useTouch.default,
+  useScrollParent: _useScrollParent.default,
+  useWindowSize: _useWindowSize.default,
+  useIsomorphicLayoutEffect: _useIsomorphicLayoutEffect.default,
+  useUpdate: _useUpdate.default,
+  useMemoizedFn: _useMemoizedFn.default,
+  usePropsValue: _usePropsValue.default
+};

package/lib/hooks/use-click-away.d.ts

@@ -0,0 +1,5 @@
+import { MutableRefObject } from 'react';
+export declare type BasicTarget<T = HTMLElement> = (() => T | null) | T | null | MutableRefObject<T | null | undefined>;
+declare type EventType = MouseEvent | TouchEvent;
+export default function useClickAway(target: BasicTarget | BasicTarget[], onClickAway: (event: EventType) => void, eventName?: string): void;
+export {};

package/lib/hooks/use-click-away.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useClickAway;
+function _react() {
+  const data = _interopRequireWildcard(require("react"));
+  _react = function () {
+    return data;
+  };
+  return data;
+}
+var _getTargetElement = require("../utils/dom/getTargetElement");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+// 鼠标点击事件，click 不会监听右键
+const defaultEvent = 'click';
+function useClickAway(target, onClickAway, eventName = defaultEvent) {
+  const onClickAwayRef = (0, _react().useRef)(onClickAway);
+  onClickAwayRef.current = onClickAway;
+  (0, _react().useEffect)(() => {
+    const handler = event => {
+      const targets = Array.isArray(target) ? target : [target];
+      if (targets.some(targetItem => {
+        const targetElement = (0, _getTargetElement.getTargetElement)(targetItem);
+        return !targetElement || (targetElement === null || targetElement === void 0 ? void 0 : targetElement.contains(event.target));
+      })) {
+        return;
+      }
+      onClickAwayRef.current(event);
+    };
+    document.addEventListener(eventName, handler);
+    return () => {
+      document.removeEventListener(eventName, handler);
+    };
+  }, [target, eventName]);
+}

package/lib/hooks/use-count-down.d.ts

@@ -0,0 +1,32 @@
+export declare type CurrentTime = {
+    /** 剩余总时间,单位毫秒 */
+    total: number;
+    /** 剩余天数	 */
+    days: number;
+    /** 剩余小时	 */
+    hours: number;
+    /** 剩余分钟	 */
+    minutes: number;
+    /** 剩余秒数	 */
+    seconds: number;
+    /** 剩余毫秒	 */
+    milliseconds: number;
+};
+export declare type UseCountDownOptions = {
+    /** 倒计时时长，单位毫秒 */
+    time: number;
+    /** 是否开启毫秒级渲染 */
+    millisecond?: boolean;
+    /** 是否自动开始倒计时 */
+    autostart?: boolean;
+    /** 倒计时改变时触发的回调函数 */
+    onChange?: (current: CurrentTime) => void;
+    /** 倒计时结束时触发的回调函数 */
+    onFinish?: () => void;
+};
+export default function useCountDown(options: UseCountDownOptions): {
+    readonly start: () => void;
+    readonly pause: () => void;
+    readonly reset: (totalTime?: number) => void;
+    readonly current: CurrentTime;
+};

package/lib/hooks/use-count-down.js

@@ -0,0 +1,124 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useCountDown;
+function _react() {
+  const data = _interopRequireWildcard(require("react"));
+  _react = function () {
+    return data;
+  };
+  return data;
+}
+var _utils = require("../utils");
+var _raf = require("../utils/raf");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+const SECOND = 1000;
+const MINUTE = 60 * SECOND;
+const HOUR = 60 * MINUTE;
+const DAY = 24 * HOUR;
+function parseTime(time) {
+  const days = Math.floor(time / DAY);
+  const hours = Math.floor(time % DAY / HOUR);
+  const minutes = Math.floor(time % HOUR / MINUTE);
+  const seconds = Math.floor(time % MINUTE / SECOND);
+  const milliseconds = Math.floor(time % SECOND);
+  return {
+    total: time,
+    days,
+    hours,
+    minutes,
+    seconds,
+    milliseconds
+  };
+}
+function isSameSecond(time1, time2) {
+  return Math.floor(time1 / 1000) === Math.floor(time2 / 1000);
+}
+function useCountDown(options) {
+  const rafId = (0, _react().useRef)(0);
+  const endTime = (0, _react().useRef)(0);
+  const counting = (0, _react().useRef)(false);
+  const [remain, updateRemain] = (0, _react().useState)(() => options.time);
+  const remainRef = (0, _react().useRef)(0);
+  const currentRef = (0, _react().useRef)({});
+  const current = (0, _react().useMemo)(() => parseTime(remain), [remain]);
+  currentRef.current = current;
+  remainRef.current = remain;
+  const pause = () => {
+    counting.current = false;
+    (0, _raf.cancelRaf)(rafId.current);
+  };
+  const getCurrentRemain = () => Math.max(endTime.current - Date.now(), 0);
+  const setRemain = value => {
+    var _a, _b;
+    remainRef.current = value;
+    updateRemain(value);
+    (_a = options.onChange) === null || _a === void 0 ? void 0 : _a.call(options, currentRef.current);
+    if (value === 0) {
+      pause();
+      (_b = options.onFinish) === null || _b === void 0 ? void 0 : _b.call(options);
+    }
+  };
+  const microTick = () => {
+    rafId.current = (0, _raf.raf)(() => {
+      // in case of call reset immediately after finish
+      if (counting.current) {
+        setRemain(getCurrentRemain());
+        if (remainRef.current > 0) {
+          microTick();
+        }
+      }
+    });
+  };
+  const macroTick = () => {
+    rafId.current = (0, _raf.raf)(() => {
+      // in case of call reset immediately after finish
+      if (counting.current) {
+        const remainRemain = getCurrentRemain();
+        if (!isSameSecond(remainRemain, remainRef.current) || remainRemain === 0) {
+          setRemain(remainRemain);
+        }
+        if (remainRef.current > 0) {
+          macroTick();
+        }
+      }
+    });
+  };
+  const tick = () => {
+    // should not start counting in server
+    // see: https://github.com/youzan/vant/issues/7807
+    if (!_utils.inBrowser) {
+      return;
+    }
+    if (options.millisecond) {
+      microTick();
+    } else {
+      macroTick();
+    }
+  };
+  const start = () => {
+    if (!counting.current) {
+      endTime.current = Date.now() + remainRef.current;
+      counting.current = true;
+      tick();
+    }
+  };
+  const reset = (totalTime = options.time) => {
+    pause();
+    remainRef.current = totalTime;
+    updateRemain(totalTime);
+  };
+  (0, _react().useEffect)(() => {
+    if (options.autostart) {
+      start();
+    }
+  }, []);
+  return {
+    start,
+    pause,
+    reset,
+    current
+  };
+}

package/lib/hooks/use-debunce-effect.d.ts

@@ -0,0 +1,4 @@
+import type { DependencyList, EffectCallback } from 'react';
+import type { DebounceOptions } from './use-debunce-fn';
+declare function useDebounceEffect(effect: EffectCallback, deps?: DependencyList, options?: DebounceOptions): void;
+export default useDebounceEffect;

package/lib/hooks/use-debunce-effect.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _react() {
+  const data = _interopRequireWildcard(require("react"));
+  _react = function () {
+    return data;
+  };
+  return data;
+}
+var _useDebunceFn = _interopRequireDefault(require("./use-debunce-fn"));
+var _useUpdateEffect = _interopRequireDefault(require("./use-update-effect"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function useDebounceEffect(effect, deps, options) {
+  const [flag, setFlag] = (0, _react().useState)({});
+  const {
+    run
+  } = (0, _useDebunceFn.default)(() => {
+    setFlag({});
+  }, options);
+  (0, _react().useEffect)(() => {
+    return run();
+  }, deps);
+  (0, _useUpdateEffect.default)(effect, [flag]);
+}
+var _default = exports.default = useDebounceEffect;

package/lib/hooks/use-debunce-fn.d.ts

@@ -0,0 +1,18 @@
+export interface DebounceOptions {
+    wait?: number;
+    leading?: boolean;
+    trailing?: boolean;
+    maxWait?: number;
+}
+declare type noop = (...args: any) => any;
+declare function useDebounceFn<T extends noop>(fn: T, options?: DebounceOptions): {
+    run: {
+        (...args: any[]): any;
+        cancel: () => void;
+        flush: () => any;
+        pending: () => boolean;
+    };
+    cancel: () => void;
+    flush: () => any;
+};
+export default useDebounceFn;

package/lib/hooks/use-debunce-fn.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _react() {
+  const data = _interopRequireWildcard(require("react"));
+  _react = function () {
+    return data;
+  };
+  return data;
+}
+var _useLatest = _interopRequireDefault(require("./use-latest"));
+var _useUnmount = _interopRequireDefault(require("./use-unmount"));
+var _utils = require("../utils");
+var _debounce = require("../utils/debounce");
+var _devLog = require("../utils/dev-log");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function useDebounceFn(fn, options) {
+  var _a;
+  if (process.env.NODE_ENV === 'development') {
+    if (!(0, _utils.isFunction)(fn)) {
+      (0, _devLog.devWarning)('useDebounceFn', `expected parameter is a function, got ${typeof fn}`);
+    }
+  }
+  const fnRef = (0, _useLatest.default)(fn);
+  const wait = (_a = options === null || options === void 0 ? void 0 : options.wait) !== null && _a !== void 0 ? _a : 1000;
+  const debounced = (0, _react().useMemo)(() => (0, _debounce.debounce)((...args) => {
+    return fnRef.current(...args);
+  }, wait, options), []);
+  (0, _useUnmount.default)(() => {
+    debounced.cancel();
+  });
+  return {
+    run: debounced,
+    cancel: debounced.cancel,
+    flush: debounced.flush
+  };
+}
+var _default = exports.default = useDebounceFn;

package/lib/hooks/use-drag-and-pinch.d.ts

@@ -0,0 +1 @@
+export declare const useDragAndPinch: <Config extends import("@use-gesture/react").UserGestureConfig = import("@use-gesture/react").UserGestureConfig>(_handlers: Partial<import("@use-gesture/react").NativeHandlers<import("@use-gesture/react").EventTypes> & import("@use-gesture/react").UserHandlers<import("@use-gesture/react").EventTypes>>, _config?: Config) => Config["target"] extends object ? void : (...args: any[]) => import("@use-gesture/react/dist/declarations/src/types").ReactDOMAttributes;

package/lib/hooks/use-drag-and-pinch.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useDragAndPinch = void 0;
+function _react2() {
+  const data = require("@use-gesture/react");
+  _react2 = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const useDragAndPinch = exports.useDragAndPinch = (0, _react2().createUseGesture)([_react2().dragAction, _react2().pinchAction]);

package/lib/hooks/use-effect-with-target.d.ts

@@ -0,0 +1,4 @@
+import { DependencyList, EffectCallback } from 'react';
+import { BasicTarget } from '../utils/dom/getTargetElement';
+declare const useEffectWithTarget: (effect: EffectCallback, deps: DependencyList, target: BasicTarget<any> | BasicTarget<any>[]) => void;
+export default useEffectWithTarget;

package/lib/hooks/use-effect-with-target.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _react() {
+  const data = _interopRequireWildcard(require("react"));
+  _react = function () {
+    return data;
+  };
+  return data;
+}
+var _useUnmount = _interopRequireDefault(require("./use-unmount"));
+var _getTargetElement = require("../utils/dom/getTargetElement");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function depsAreSame(oldDeps, deps) {
+  if (oldDeps === deps) return true;
+  for (let i = 0; i < oldDeps.length; i++) {
+    if (!Object.is(oldDeps[i], deps[i])) return false;
+  }
+  return true;
+}
+const createEffectWithTarget = useEffectType => {
+  /**
+   *
+   * @param effect
+   * @param deps
+   * @param target target should compare ref.current vs ref.current, dom vs dom, ()=>dom vs ()=>dom
+   */
+  const useEffectWithTarget = (effect, deps, target) => {
+    const hasInitRef = (0, _react().useRef)(false);
+    const lastElementRef = (0, _react().useRef)([]);
+    const lastDepsRef = (0, _react().useRef)([]);
+    const unLoadRef = (0, _react().useRef)();
+    useEffectType(() => {
+      var _a;
+      const targets = Array.isArray(target) ? target : [target];
+      const els = targets.map(item => (0, _getTargetElement.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();
+      }
+    });
+    (0, _useUnmount.default)(() => {
+      var _a;
+      (_a = unLoadRef.current) === null || _a === void 0 ? void 0 : _a.call(unLoadRef);
+      // for react-refresh
+      hasInitRef.current = false;
+    });
+  };
+  return useEffectWithTarget;
+};
+const useEffectWithTarget = createEffectWithTarget(_react().useEffect);
+var _default = exports.default = useEffectWithTarget;

package/lib/hooks/use-event-listener.d.ts

@@ -0,0 +1,11 @@
+import { BasicTarget, TargetElement } from '../utils/dom/getTargetElement';
+export declare let supportsPassive: boolean;
+declare type Target = BasicTarget<TargetElement>;
+export declare type UseEventListenerOptions = {
+    target?: Target;
+    capture?: boolean;
+    passive?: boolean;
+    depends?: Array<unknown>;
+};
+declare function useEventListener(type: string, listener: EventListener, options?: UseEventListenerOptions): void;
+export default useEventListener;

package/lib/hooks/use-event-listener.js

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.supportsPassive = exports.default = void 0;
+function _react() {
+  const data = _interopRequireWildcard(require("react"));
+  _react = function () {
+    return data;
+  };
+  return data;
+}
+var _utils = require("../utils");
+var _getTargetElement = require("../utils/dom/getTargetElement");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/* eslint-disable react-hooks/rules-of-hooks */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+
+// https://developer.mozilla.org/zh-CN/docs/Web/API/EventTarget/addEventListener#使用_passive_改善的滚屏性能
+let supportsPassive = exports.supportsPassive = false;
+if (_utils.inBrowser) {
+  try {
+    const opts = {};
+    Object.defineProperty(opts, 'passive', {
+      get() {
+        exports.supportsPassive = supportsPassive = true;
+      }
+    });
+    window.addEventListener('test-passive', null, opts);
+    // eslint-disable-next-line no-empty
+  } catch (e) {}
+}
+function useEventListener(type, listener, options = {}) {
+  if (!_utils.inBrowser) {
+    return;
+  }
+  const {
+    target = window,
+    passive = false,
+    capture = false,
+    depends = []
+  } = options;
+  let attached;
+  const add = () => {
+    const element = (0, _getTargetElement.getTargetElement)(target);
+    if (element && !attached) {
+      element.addEventListener(type, listener, supportsPassive ? {
+        capture,
+        passive
+      } : capture);
+      attached = true;
+    }
+  };
+  const remove = () => {
+    const element = (0, _getTargetElement.getTargetElement)(target);
+    if (element && attached) {
+      element.removeEventListener(type, listener, capture);
+      attached = false;
+    }
+  };
+  // https://stackoverflow.com/questions/55265255/react-usestate-hook-event-handler-using-initial-state
+  (0, _react().useEffect)(() => {
+    add();
+    return () => remove();
+  }, [target, ...depends]);
+}
+var _default = exports.default = useEventListener;

package/lib/hooks/use-form-smart.d.ts

@@ -0,0 +1,20 @@
+import { Ref } from 'react';
+export declare type FormOption = {
+    /**
+     * initialValues
+     */
+    value?: Record<string, unknown>;
+    /**
+     * sync
+     */
+    sync?: boolean;
+};
+export declare type FormMethod = {
+    set: (values: unknown) => void;
+    get: (name: string) => unknown;
+    submit: () => void;
+    getAll: () => Record<string, unknown>;
+    clear: () => void;
+};
+export declare type FormState = [Ref<unknown>, FormMethod];
+export default function useFormSmart(option?: FormOption): FormState;