@1money/react-ui 1.16.0 → 1.17.0

package/lib/components/Switch/Switch.js

@@ -12,6 +12,8 @@ var _react = require("react");
 var _inputswitch = require("primereact/inputswitch");
 var _togglebutton = require("primereact/togglebutton");
 var _classnames = _interopRequireWildcard(require("../../utils/classnames"));
+var _useControlledState3 = _interopRequireDefault(require("../useControlledState"));
+var _useEventCallback = _interopRequireDefault(require("../useEventCallback"));
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
 var __rest = void 0 && (void 0).__rest || function (s, e) {
@@ -24,35 +26,36 @@ var __rest = void 0 && (void 0).__rest || function (s, e) {
 };
 var Switch = exports.Switch = function Switch(props) {
   var type = props.type,
-    defaultChecked = props.defaultChecked,
+    checkedProp = props.checked,
+    _props$defaultChecked = props.defaultChecked,
+    defaultChecked = _props$defaultChecked === void 0 ? false : _props$defaultChecked,
     className = props.className,
-    _onChange = props.onChange,
+    onChange = props.onChange,
     _props$prefixCls = props.prefixCls,
     prefixCls = _props$prefixCls === void 0 ? 'switch' : _props$prefixCls,
-    rest = __rest(props, ["type", "defaultChecked", "className", "onChange", "prefixCls"]);
+    rest = __rest(props, ["type", "checked", "defaultChecked", "className", "onChange", "prefixCls"]);
   var classes = (0, _classnames["default"])(prefixCls);
-  var _useState = (0, _react.useState)(defaultChecked || false),
-    _useState2 = (0, _slicedToArray2["default"])(_useState, 2),
-    checked = _useState2[0],
-    setChecked = _useState2[1];
-  var SwitchComponent = (0, _react.useMemo)(function () {
-    switch (type) {
-      case 'normal':
-        return _inputswitch.InputSwitch;
-      case 'button':
-        return _togglebutton.ToggleButton;
-      default:
-        return _inputswitch.InputSwitch;
-    }
-  }, [type]);
-  return (0, _jsxRuntime.jsx)(SwitchComponent, Object.assign({}, rest, {
-    className: classes(void 0, (0, _classnames.joinCls)(classes(type), className)),
+  var _useControlledState = (0, _useControlledState3["default"])(defaultChecked, checkedProp),
+    _useControlledState2 = (0, _slicedToArray2["default"])(_useControlledState, 2),
+    checked = _useControlledState2[0],
+    setChecked = _useControlledState2[1];
+  var handleChange = (0, _useEventCallback["default"])(function (e) {
+    setChecked(e.value);
+    onChange === null || onChange === void 0 ? void 0 : onChange(e);
+  });
+  var cls = classes(undefined, (0, _classnames.joinCls)(classes(type), className));
+  if (type === 'button') {
+    return (0, _jsxRuntime.jsx)(_togglebutton.ToggleButton, Object.assign({}, rest, {
+      className: cls,
+      checked: checked,
+      onChange: handleChange
+    }));
+  }
+  return (0, _jsxRuntime.jsx)(_inputswitch.InputSwitch, Object.assign({}, rest, {
+    className: cls,
     checked: checked,
-    onChange: function onChange(e) {
-      setChecked(e.value);
-      _onChange === null || _onChange === void 0 ? void 0 : _onChange(e);
-    }
+    onChange: handleChange
   }));
 };
 var _default = exports["default"] = /*#__PURE__*/(0, _react.memo)(Switch);
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/Switch/Switch.js","components/src/components/Switch/Switch.tsx"],"names":["_jsxRuntime","require","_react","_inputswitch","_togglebutton","_classnames","_interopRequireWildcard","_useControlledState3","_interopRequireDefault","_useEventCallback","_getRequireWildcardCache","e","WeakMap","r","t","__esModule","_typeof","has","get","n","__proto__","a","Object","defineProperty","getOwnPropertyDescriptor","u","hasOwnProperty","call","i","set","__rest","s","p","prototype","indexOf","getOwnPropertySymbols","length","propertyIsEnumerable","Switch","exports","props","type","checkedProp","checked","_props$defaultChecked","defaultChecked","className","onChange","_props$prefixCls","prefixCls","rest","classes","classnames","_useControlledState","useControlledState","_useControlledState2","_slicedToArray2","setChecked","handleChange","useEventCallback","value","cls","undefined","joinCls","_jsx","ToggleButton","assign","InputSwitch","_default","memo"],"mappings":"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","file":"components/Switch/Switch.js","sourcesContent":["var __rest = (this && this.__rest) || function (s, e) {\n    var t = {};\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n        t[p] = s[p];\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n                t[p[i]] = s[p[i]];\n        }\n    return t;\n};\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nimport { memo } from 'react';\nimport { InputSwitch } from 'primereact/inputswitch';\nimport { ToggleButton } from 'primereact/togglebutton';\nimport { default as classnames, joinCls } from '../../utils/classnames';\nimport useControlledState from '../useControlledState';\nimport useEventCallback from '../useEventCallback';\nexport const Switch = props => {\n    const { type, checked: checkedProp, defaultChecked = false, className, onChange, prefixCls = 'switch' } = props, rest = __rest(props, [\"type\", \"checked\", \"defaultChecked\", \"className\", \"onChange\", \"prefixCls\"]);\n    const classes = classnames(prefixCls);\n    const [checked, setChecked] = useControlledState(defaultChecked, checkedProp);\n    const handleChange = useEventCallback((e) => {\n        setChecked(e.value);\n        onChange === null || onChange === void 0 ? void 0 : onChange(e);\n    });\n    const cls = classes(undefined, joinCls(classes(type), className));\n    if (type === 'button') {\n        return _jsx(ToggleButton, Object.assign({}, rest, { className: cls, checked: checked, onChange: handleChange }));\n    }\n    return _jsx(InputSwitch, Object.assign({}, rest, { className: cls, checked: checked, onChange: handleChange }));\n};\nexport default memo(Switch);",null],"sourceRoot":"../../../../../../../../../src"}

package/lib/components/Switch/interface.d.ts

@@ -1,12 +1,17 @@
-import type { InputSwitchProps } from 'primereact/inputswitch';
-import type { ToggleButtonProps } from 'primereact/togglebutton';
+import type { InputSwitchChangeEvent, InputSwitchProps } from 'primereact/inputswitch';
+import type { ToggleButtonChangeEvent, ToggleButtonProps } from 'primereact/togglebutton';
+export type SwitchChangeEvent = InputSwitchChangeEvent | ToggleButtonChangeEvent;
+type OmitKeys = 'checked' | 'onChange';
 interface SwitchBaseProps {
     prefixCls?: string;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onChange?(event: SwitchChangeEvent): void;
 }
-interface NormalSwitchProps extends Omit<InputSwitchProps, 'checked'>, SwitchBaseProps {
+interface NormalSwitchProps extends Omit<InputSwitchProps, OmitKeys>, SwitchBaseProps {
     type?: 'normal';
 }
-interface ButtonSwitchProps extends Omit<ToggleButtonProps, 'checked'>, SwitchBaseProps {
+interface ButtonSwitchProps extends Omit<ToggleButtonProps, OmitKeys>, SwitchBaseProps {
     type: 'button';
 }
 export type SwitchProps = NormalSwitchProps | ButtonSwitchProps;

package/lib/components/useControlledState/index.d.ts

@@ -0,0 +1,14 @@
+type Updater<T> = (updater: T | ((origin: T) => T)) => void;
+/**
+ * Similar to `useState` but will use props value if provided.
+ * From React 18, we do not need safe `useState` since it will not throw for unmounted update.
+ * This hook removes the `onChange` & `postState` logic since we only need basic merged state logic.
+ *
+ * The `mergedValue` return already reflects the latest controlled `value` without
+ * the layout effect. The effect exists to sync `innerValue` for the edge case where
+ * the component starts in uncontrolled mode (calling `setInnerValue` directly) and
+ * then transitions to controlled mode (parent starts providing `value`). Without this
+ * sync, reverting back to uncontrolled mode would show the stale `innerValue`.
+ */
+export default function useControlledState<T>(defaultStateValue: T | (() => T), value?: T): [T, Updater<T>];
+export {};

package/lib/components/useControlledState/index.js

@@ -0,0 +1,39 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = useControlledState;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _react = require("react");
+var _useLayoutEffect = _interopRequireDefault(require("../useLayoutEffect"));
+/**
+ * Similar to `useState` but will use props value if provided.
+ * From React 18, we do not need safe `useState` since it will not throw for unmounted update.
+ * This hook removes the `onChange` & `postState` logic since we only need basic merged state logic.
+ *
+ * The `mergedValue` return already reflects the latest controlled `value` without
+ * the layout effect. The effect exists to sync `innerValue` for the edge case where
+ * the component starts in uncontrolled mode (calling `setInnerValue` directly) and
+ * then transitions to controlled mode (parent starts providing `value`). Without this
+ * sync, reverting back to uncontrolled mode would show the stale `innerValue`.
+ */
+function useControlledState(defaultStateValue, value) {
+  var _useState = (0, _react.useState)(defaultStateValue),
+    _useState2 = (0, _slicedToArray2["default"])(_useState, 2),
+    innerValue = _useState2[0],
+    setInnerValue = _useState2[1];
+  var mergedValue = value !== undefined ? value : innerValue;
+  (0, _useLayoutEffect["default"])(function (mount) {
+    if (!mount && value !== undefined) {
+      setInnerValue(value);
+    }
+  }, [value]);
+  return [
+  // Value
+  mergedValue,
+  // Update function
+  setInnerValue];
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/components/useEventCallback/index.d.ts

@@ -0,0 +1,11 @@
+type Fn<T extends unknown[], R> = (...args: T) => R;
+/**
+ * A hook that returns a stable callback reference that always invokes
+ * the latest version of the provided function. Similar to the React
+ * useEvent RFC proposal.
+ *
+ * @param fn The function to wrap
+ * @returns A stable callback that always calls the latest fn
+ */
+export default function useEventCallback<T extends unknown[], R>(fn: Fn<T, R>): Fn<T, R>;
+export {};

package/lib/components/useEventCallback/index.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = useEventCallback;
+var _react = require("react");
+var _useLatest = _interopRequireDefault(require("../useLatest"));
+/**
+ * A hook that returns a stable callback reference that always invokes
+ * the latest version of the provided function. Similar to the React
+ * useEvent RFC proposal.
+ *
+ * @param fn The function to wrap
+ * @returns A stable callback that always calls the latest fn
+ */
+function useEventCallback(fn) {
+  var fnRef = (0, _useLatest["default"])(fn);
+  return (0, _react.useCallback)(function () {
+    return fnRef.current.apply(fnRef, arguments);
+  }, []);
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvc3JjL2NvbXBvbmVudHMvdXNlRXZlbnRDYWxsYmFjay9pbmRleC50cyIsImNvbXBvbmVudHMvdXNlRXZlbnRDYWxsYmFjay9pbmRleC5qcyJdLCJuYW1lcyI6WyJfcmVhY3QiLCJyZXF1aXJlIiwiX3VzZUxhdGVzdCIsIl9pbnRlcm9wUmVxdWlyZURlZmF1bHQiLCJ1c2VFdmVudENhbGxiYWNrIiwiZm4iLCJmblJlZiIsInVzZUxhdGVzdCIsInVzZUNhbGxiYWNrIiwiY3VycmVudCIsImFwcGx5IiwiYXJndW1lbnRzIl0sIm1hcHBpbmdzIjoiOzs7Ozs7O0FBQUEsSUFBQUEsTUFBQSxHQUFBQyxPQUFBO0FBQ0EsSUFBQUMsVUFBQSxHQUFBQyxzQkFBQSxDQUFBRixPQUFBO0FBSUE7QUNGQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBREljLFNBQVVHLGdCQUFnQkEsQ0FBeUJDLEVBQVksRUFBQTtFQUMzRSxJQUFNQyxLQUFLLEdBQUcsSUFBQUMscUJBQVMsRUFBQ0YsRUFBRSxDQUFDO0VBRTNCLE9BQU8sSUFBQUcsa0JBQVcsRUFBQyxZQUFlO0lBQ2hDLE9BQU9GLEtBQUssQ0FBQ0csT0FBTyxDQUFBQyxLQUFBLENBQWJKLEtBQUssRUFBQUssU0FBZ0IsQ0FBQztFQUMvQixDQUFDLEVBQUUsRUFBRSxDQUFDO0FBQ1IiLCJmaWxlIjoiY29tcG9uZW50cy91c2VFdmVudENhbGxiYWNrL2luZGV4LmpzIiwic291cmNlc0NvbnRlbnQiOltudWxsLCJpbXBvcnQgeyB1c2VDYWxsYmFjayB9IGZyb20gJ3JlYWN0JztcbmltcG9ydCB1c2VMYXRlc3QgZnJvbSAnLi4vdXNlTGF0ZXN0Jztcbi8qKlxuICogQSBob29rIHRoYXQgcmV0dXJucyBhIHN0YWJsZSBjYWxsYmFjayByZWZlcmVuY2UgdGhhdCBhbHdheXMgaW52b2tlc1xuICogdGhlIGxhdGVzdCB2ZXJzaW9uIG9mIHRoZSBwcm92aWRlZCBmdW5jdGlvbi4gU2ltaWxhciB0byB0aGUgUmVhY3RcbiAqIHVzZUV2ZW50IFJGQyBwcm9wb3NhbC5cbiAqXG4gKiBAcGFyYW0gZm4gVGhlIGZ1bmN0aW9uIHRvIHdyYXBcbiAqIEByZXR1cm5zIEEgc3RhYmxlIGNhbGxiYWNrIHRoYXQgYWx3YXlzIGNhbGxzIHRoZSBsYXRlc3QgZm5cbiAqL1xuZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24gdXNlRXZlbnRDYWxsYmFjayhmbikge1xuICAgIGNvbnN0IGZuUmVmID0gdXNlTGF0ZXN0KGZuKTtcbiAgICByZXR1cm4gdXNlQ2FsbGJhY2soKC4uLmFyZ3MpID0+IHtcbiAgICAgICAgcmV0dXJuIGZuUmVmLmN1cnJlbnQoLi4uYXJncyk7XG4gICAgfSwgW10pO1xufSJdLCJzb3VyY2VSb290IjoiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjIn0=

package/lib/components/useLayoutEffect/index.d.ts

@@ -0,0 +1,11 @@
+import { type DependencyList } from 'react';
+type EffectCallback = (mount: boolean) => void | (() => void);
+/**
+ * A custom `useLayoutEffect` that passes a boolean indicating whether
+ * it's the initial mount (`true`) or a subsequent update (`false`).
+ *
+ * @param effect The effect callback that receives a `mount` parameter
+ * @param deps The dependency array
+ */
+export default function useLayoutEffect(effect: EffectCallback, deps?: DependencyList): void;
+export {};

package/lib/components/useLayoutEffect/index.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = useLayoutEffect;
+var _react = require("react");
+/**
+ * A custom `useLayoutEffect` that passes a boolean indicating whether
+ * it's the initial mount (`true`) or a subsequent update (`false`).
+ *
+ * @param effect The effect callback that receives a `mount` parameter
+ * @param deps The dependency array
+ */
+function useLayoutEffect(effect, deps) {
+  var isMounted = (0, _react.useRef)(false);
+  (0, _react.useLayoutEffect)(function () {
+    var mount = !isMounted.current;
+    isMounted.current = true;
+    return effect(mount);
+  }, deps);
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvc3JjL2NvbXBvbmVudHMvdXNlTGF5b3V0RWZmZWN0L2luZGV4LnRzIiwiY29tcG9uZW50cy91c2VMYXlvdXRFZmZlY3QvaW5kZXguanMiXSwibmFtZXMiOlsiX3JlYWN0IiwicmVxdWlyZSIsInVzZUxheW91dEVmZmVjdCIsImVmZmVjdCIsImRlcHMiLCJpc01vdW50ZWQiLCJ1c2VSZWYiLCJyZWFjdFVzZUxheW91dEVmZmVjdCIsIm1vdW50IiwiY3VycmVudCJdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBQUEsSUFBQUEsTUFBQSxHQUFBQyxPQUFBO0FBUUE7QUNOQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QURRYyxTQUFVQyxlQUFlQSxDQUFDQyxNQUFzQixFQUFFQyxJQUFxQixFQUFBO0VBQ25GLElBQU1DLFNBQVMsR0FBRyxJQUFBQyxhQUFNLEVBQUMsS0FBSyxDQUFDO0VBRS9CLElBQUFDLHNCQUFvQixFQUFDLFlBQUs7SUFDeEIsSUFBTUMsS0FBSyxHQUFHLENBQUNILFNBQVMsQ0FBQ0ksT0FBTztJQUNoQ0osU0FBUyxDQUFDSSxPQUFPLEdBQUcsSUFBSTtJQUN4QixPQUFPTixNQUFNLENBQUNLLEtBQUssQ0FBQztFQUN0QixDQUFDLEVBQUVKLElBQUksQ0FBQztBQUNWIiwiZmlsZSI6ImNvbXBvbmVudHMvdXNlTGF5b3V0RWZmZWN0L2luZGV4LmpzIiwic291cmNlc0NvbnRlbnQiOltudWxsLCJpbXBvcnQgeyB1c2VMYXlvdXRFZmZlY3QgYXMgcmVhY3RVc2VMYXlvdXRFZmZlY3QsIHVzZVJlZiwgfSBmcm9tICdyZWFjdCc7XG4vKipcbiAqIEEgY3VzdG9tIGB1c2VMYXlvdXRFZmZlY3RgIHRoYXQgcGFzc2VzIGEgYm9vbGVhbiBpbmRpY2F0aW5nIHdoZXRoZXJcbiAqIGl0J3MgdGhlIGluaXRpYWwgbW91bnQgKGB0cnVlYCkgb3IgYSBzdWJzZXF1ZW50IHVwZGF0ZSAoYGZhbHNlYCkuXG4gKlxuICogQHBhcmFtIGVmZmVjdCBUaGUgZWZmZWN0IGNhbGxiYWNrIHRoYXQgcmVjZWl2ZXMgYSBgbW91bnRgIHBhcmFtZXRlclxuICogQHBhcmFtIGRlcHMgVGhlIGRlcGVuZGVuY3kgYXJyYXlcbiAqL1xuZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24gdXNlTGF5b3V0RWZmZWN0KGVmZmVjdCwgZGVwcykge1xuICAgIGNvbnN0IGlzTW91bnRlZCA9IHVzZVJlZihmYWxzZSk7XG4gICAgcmVhY3RVc2VMYXlvdXRFZmZlY3QoKCkgPT4ge1xuICAgICAgICBjb25zdCBtb3VudCA9ICFpc01vdW50ZWQuY3VycmVudDtcbiAgICAgICAgaXNNb3VudGVkLmN1cnJlbnQgPSB0cnVlO1xuICAgICAgICByZXR1cm4gZWZmZWN0KG1vdW50KTtcbiAgICB9LCBkZXBzKTtcbn0iXSwic291cmNlUm9vdCI6Ii4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYyJ9

package/lib/components/useLayoutState/index.d.ts

@@ -0,0 +1,13 @@
+export type Updater<State> = (prev: State) => State;
+/**
+ * Execute code before next frame but async.
+ *
+ * Batches multiple state updates into a single microtask (via `Promise.resolve`),
+ * reducing unnecessary re-renders when multiple updates happen synchronously.
+ *
+ * @param defaultState The initial state value
+ * @returns A tuple of `[state, setFrameState]`
+ */
+export default function useLayoutState<State>(defaultState: State): [State, (updater: Updater<State>) => void];
+/** Lock frame, when frame pass reset the lock. */
+export declare function useTimeoutLock<State>(defaultState?: State): [(state: State) => void, () => State | null];

package/lib/components/useLayoutState/index.js

@@ -0,0 +1,79 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = useLayoutState;
+exports.useTimeoutLock = useTimeoutLock;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _react = require("react");
+/**
+ * Execute code before next frame but async.
+ *
+ * Batches multiple state updates into a single microtask (via `Promise.resolve`),
+ * reducing unnecessary re-renders when multiple updates happen synchronously.
+ *
+ * @param defaultState The initial state value
+ * @returns A tuple of `[state, setFrameState]`
+ */
+function useLayoutState(defaultState) {
+  var stateRef = (0, _react.useRef)(defaultState);
+  var _useState = (0, _react.useState)({}),
+    _useState2 = (0, _slicedToArray2["default"])(_useState, 2),
+    forceUpdate = _useState2[1];
+  var lastPromiseRef = (0, _react.useRef)(null);
+  var updateBatchRef = (0, _react.useRef)([]);
+  var setFrameState = (0, _react.useCallback)(function (updater) {
+    updateBatchRef.current.push(updater);
+    var promise = Promise.resolve();
+    lastPromiseRef.current = promise;
+    promise.then(function () {
+      if (lastPromiseRef.current === promise) {
+        var prevBatch = updateBatchRef.current;
+        var prevState = stateRef.current;
+        updateBatchRef.current = [];
+        prevBatch.forEach(function (batchUpdater) {
+          stateRef.current = batchUpdater(stateRef.current);
+        });
+        lastPromiseRef.current = null;
+        if (prevState !== stateRef.current) {
+          forceUpdate({});
+        }
+      }
+    });
+  }, []);
+  (0, _react.useEffect)(function () {
+    return function () {
+      lastPromiseRef.current = null;
+    };
+  }, []);
+  return [stateRef.current, setFrameState];
+}
+/** Lock frame, when frame pass reset the lock. */
+function useTimeoutLock(defaultState) {
+  var frameRef = (0, _react.useRef)(defaultState !== null && defaultState !== void 0 ? defaultState : null);
+  var timeoutRef = (0, _react.useRef)(null);
+  function cleanUp() {
+    if (timeoutRef.current != null) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+    }
+  }
+  function setState(newState) {
+    frameRef.current = newState;
+    cleanUp();
+    timeoutRef.current = setTimeout(function () {
+      frameRef.current = null;
+      timeoutRef.current = null;
+    }, 100);
+  }
+  function getState() {
+    return frameRef.current;
+  }
+  (0, _react.useEffect)(function () {
+    return cleanUp;
+  }, []);
+  return [setState, getState];
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/components/useMemoizedFn/index.d.ts

@@ -0,0 +1,12 @@
+type Fn<T extends unknown[], R> = (...args: T) => R;
+/**
+ * A hook that returns a memoized version of a callback function.
+ * Unlike `useCallback`, it maintains referential equality across renders
+ * without requiring a dependency array, while always calling the latest
+ * version of the function.
+ *
+ * @param fn The function to memoize
+ * @returns A memoized function with stable reference
+ */
+export default function useMemoizedFn<T extends unknown[], R>(fn: Fn<T, R>): Fn<T, R>;
+export {};

package/lib/components/useMemoizedFn/index.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = useMemoizedFn;
+var _react = require("react");
+/**
+ * A hook that returns a memoized version of a callback function.
+ * Unlike `useCallback`, it maintains referential equality across renders
+ * without requiring a dependency array, while always calling the latest
+ * version of the function.
+ *
+ * @param fn The function to memoize
+ * @returns A memoized function with stable reference
+ */
+function useMemoizedFn(fn) {
+  var fnRef = (0, _react.useRef)(fn);
+  fnRef.current = (0, _react.useMemo)(function () {
+    return fn;
+  }, [fn]);
+  var memoizedFn = (0, _react.useRef)(undefined);
+  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;
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/components/usePrevious/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Returns the last distinct value observed before the current `value`.
+ *
+ * Because the internal effect depends on `[value]`, the ref is only updated
+ * when `value` changes. That means this hook tracks the previous value on
+ * value-change boundaries (not every render).
+ *
+ * @param value The value to track
+ * @returns The previous distinct value, or `undefined` until one exists
+ */
+export default function usePrevious<T>(value: T): T | undefined;

package/lib/components/usePrevious/index.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = usePrevious;
+var _react = require("react");
+/**
+ * Returns the last distinct value observed before the current `value`.
+ *
+ * Because the internal effect depends on `[value]`, the ref is only updated
+ * when `value` changes. That means this hook tracks the previous value on
+ * value-change boundaries (not every render).
+ *
+ * @param value The value to track
+ * @returns The previous distinct value, or `undefined` until one exists
+ */
+function usePrevious(value) {
+  var ref = (0, _react.useRef)(undefined);
+  (0, _react.useEffect)(function () {
+    ref.current = value;
+  }, [value]);
+  return ref.current;
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvc3JjL2NvbXBvbmVudHMvdXNlUHJldmlvdXMvaW5kZXgudHMiLCJjb21wb25lbnRzL3VzZVByZXZpb3VzL2luZGV4LmpzIl0sIm5hbWVzIjpbIl9yZWFjdCIsInJlcXVpcmUiLCJ1c2VQcmV2aW91cyIsInZhbHVlIiwicmVmIiwidXNlUmVmIiwidW5kZWZpbmVkIiwidXNlRWZmZWN0IiwiY3VycmVudCJdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBQUEsSUFBQUEsTUFBQSxHQUFBQyxPQUFBO0FBRUE7QUNBQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QURFYyxTQUFVQyxXQUFXQSxDQUFJQyxLQUFRLEVBQUE7RUFDN0MsSUFBTUMsR0FBRyxHQUFHLElBQUFDLGFBQU0sRUFBZ0JDLFNBQVMsQ0FBQztFQUU1QyxJQUFBQyxnQkFBUyxFQUFDLFlBQUs7SUFDYkgsR0FBRyxDQUFDSSxPQUFPLEdBQUdMLEtBQUs7RUFDckIsQ0FBQyxFQUFFLENBQUNBLEtBQUssQ0FBQyxDQUFDO0VBRVgsT0FBT0MsR0FBRyxDQUFDSSxPQUFPO0FBQ3BCIiwiZmlsZSI6ImNvbXBvbmVudHMvdXNlUHJldmlvdXMvaW5kZXguanMiLCJzb3VyY2VzQ29udGVudCI6W251bGwsImltcG9ydCB7IHVzZUVmZmVjdCwgdXNlUmVmIH0gZnJvbSAncmVhY3QnO1xuLyoqXG4gKiBSZXR1cm5zIHRoZSBsYXN0IGRpc3RpbmN0IHZhbHVlIG9ic2VydmVkIGJlZm9yZSB0aGUgY3VycmVudCBgdmFsdWVgLlxuICpcbiAqIEJlY2F1c2UgdGhlIGludGVybmFsIGVmZmVjdCBkZXBlbmRzIG9uIGBbdmFsdWVdYCwgdGhlIHJlZiBpcyBvbmx5IHVwZGF0ZWRcbiAqIHdoZW4gYHZhbHVlYCBjaGFuZ2VzLiBUaGF0IG1lYW5zIHRoaXMgaG9vayB0cmFja3MgdGhlIHByZXZpb3VzIHZhbHVlIG9uXG4gKiB2YWx1ZS1jaGFuZ2UgYm91bmRhcmllcyAobm90IGV2ZXJ5IHJlbmRlcikuXG4gKlxuICogQHBhcmFtIHZhbHVlIFRoZSB2YWx1ZSB0byB0cmFja1xuICogQHJldHVybnMgVGhlIHByZXZpb3VzIGRpc3RpbmN0IHZhbHVlLCBvciBgdW5kZWZpbmVkYCB1bnRpbCBvbmUgZXhpc3RzXG4gKi9cbmV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uIHVzZVByZXZpb3VzKHZhbHVlKSB7XG4gICAgY29uc3QgcmVmID0gdXNlUmVmKHVuZGVmaW5lZCk7XG4gICAgdXNlRWZmZWN0KCgpID0+IHtcbiAgICAgICAgcmVmLmN1cnJlbnQgPSB2YWx1ZTtcbiAgICB9LCBbdmFsdWVdKTtcbiAgICByZXR1cm4gcmVmLmN1cnJlbnQ7XG59Il0sInNvdXJjZVJvb3QiOiIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMifQ==

package/lib/components/useSafeState/index.d.ts

@@ -0,0 +1,12 @@
+import { type Dispatch, type SetStateAction } from 'react';
+/**
+ * It is exactly the same as `React.useState`, but after the component is unmounted,
+ * the setState in the asynchronous callback will no longer be executed to avoid
+ * memory leakage caused by updating the state after the component is unmounted.
+ *
+ * @param initialState The initial state value or initializer function
+ * @returns A tuple of [state, setSafeState] similar to useState
+ */
+declare function useSafeState<S>(initialState: S | (() => S)): [S, Dispatch<SetStateAction<S>>];
+declare function useSafeState<S = undefined>(): [S | undefined, Dispatch<SetStateAction<S | undefined>>];
+export default useSafeState;

package/lib/components/useSafeState/index.js

@@ -0,0 +1,31 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _react = require("react");
+// eslint-disable-next-line no-redeclare
+function useSafeState(initialState) {
+  var isMountedRef = (0, _react.useRef)(true);
+  var _useState = (0, _react.useState)(initialState),
+    _useState2 = (0, _slicedToArray2["default"])(_useState, 2),
+    state = _useState2[0],
+    setState = _useState2[1];
+  (0, _react.useEffect)(function () {
+    isMountedRef.current = true;
+    return function () {
+      isMountedRef.current = false;
+    };
+  }, []);
+  var setSafeState = (0, _react.useCallback)(function (value) {
+    if (isMountedRef.current) {
+      setState(value);
+    }
+  }, []);
+  return [state, setSafeState];
+}
+var _default = exports["default"] = useSafeState;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvc3JjL2NvbXBvbmVudHMvdXNlU2FmZVN0YXRlL2luZGV4LnRzIl0sIm5hbWVzIjpbIl9yZWFjdCIsInJlcXVpcmUiLCJ1c2VTYWZlU3RhdGUiLCJpbml0aWFsU3RhdGUiLCJpc01vdW50ZWRSZWYiLCJ1c2VSZWYiLCJfdXNlU3RhdGUiLCJ1c2VTdGF0ZSIsIl91c2VTdGF0ZTIiLCJfc2xpY2VkVG9BcnJheTIiLCJzdGF0ZSIsInNldFN0YXRlIiwidXNlRWZmZWN0IiwiY3VycmVudCIsInNldFNhZmVTdGF0ZSIsInVzZUNhbGxiYWNrIiwidmFsdWUiLCJfZGVmYXVsdCIsImV4cG9ydHMiXSwibWFwcGluZ3MiOiI7Ozs7Ozs7O0FBQUEsSUFBQUEsTUFBQSxHQUFBQyxPQUFBO0FBYUE7QUFDQSxTQUFTQyxZQUFZQSxDQUNuQkMsWUFBNEIsRUFBQTtFQUU1QixJQUFNQyxZQUFZLEdBQUcsSUFBQUMsYUFBTSxFQUFDLElBQUksQ0FBQztFQUNqQyxJQUFBQyxTQUFBLEdBQTBCLElBQUFDLGVBQVEsRUFBZ0JKLFlBQXlDLENBQUM7SUFBQUssVUFBQSxPQUFBQyxlQUFBLGFBQUFILFNBQUE7SUFBckZJLEtBQUssR0FBQUYsVUFBQTtJQUFFRyxRQUFRLEdBQUFILFVBQUE7RUFFdEIsSUFBQUksZ0JBQVMsRUFBQyxZQUFLO0lBQ2JSLFlBQVksQ0FBQ1MsT0FBTyxHQUFHLElBQUk7SUFDM0IsT0FBTyxZQUFLO01BQ1ZULFlBQVksQ0FBQ1MsT0FBTyxHQUFHLEtBQUs7SUFDOUIsQ0FBQztFQUNILENBQUMsRUFBRSxFQUFFLENBQUM7RUFFTixJQUFNQyxZQUFZLEdBQUcsSUFBQUMsa0JBQVcsRUFBMEMsVUFBQUMsS0FBSyxFQUFHO0lBQ2hGLElBQUlaLFlBQVksQ0FBQ1MsT0FBTyxFQUFFO01BQ3hCRixRQUFRLENBQUNLLEtBQUssQ0FBQztJQUNqQjtFQUNGLENBQUMsRUFBRSxFQUFFLENBQUM7RUFFTixPQUFPLENBQUNOLEtBQUssRUFBRUksWUFBWSxDQUFDO0FBQzlCO0FBQUMsSUFBQUcsUUFBQSxHQUFBQyxPQUFBLGNBRWNoQixZQUFZIiwiZmlsZSI6ImNvbXBvbmVudHMvdXNlU2FmZVN0YXRlL2luZGV4LmpzIiwic291cmNlc0NvbnRlbnQiOltudWxsXSwic291cmNlUm9vdCI6Ii4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYyJ9

package/lib/components/useSyncState/index.d.ts

@@ -0,0 +1,14 @@
+import { type SetStateAction } from 'react';
+type GetState<T> = () => T;
+type SetState<T> = (value: SetStateAction<T>) => void;
+/**
+ * Same as `React.useState` but will always get the latest state.
+ * This is useful when React merges multiple state updates into one.
+ * e.g. `onTransitionEnd` triggers multiple events at once that will be merged
+ * into a single state update in React.
+ *
+ * @param initialState The initial state value or initializer function
+ * @returns A tuple of [getState, setState] where getState always returns the latest value
+ */
+export default function useSyncState<T>(initialState: T | (() => T)): [GetState<T>, SetState<T>];
+export {};

package/lib/components/useSyncState/index.js

@@ -0,0 +1,44 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = useSyncState;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _react = require("react");
+var _useEventCallback = _interopRequireDefault(require("../useEventCallback"));
+/** Sentinel value distinguishing "not yet initialized" from any valid state, including `null`. */
+var UNINITIALIZED = Symbol('useSyncState.uninitialized');
+/**
+ * Same as `React.useState` but will always get the latest state.
+ * This is useful when React merges multiple state updates into one.
+ * e.g. `onTransitionEnd` triggers multiple events at once that will be merged
+ * into a single state update in React.
+ *
+ * @param initialState The initial state value or initializer function
+ * @returns A tuple of [getState, setState] where getState always returns the latest value
+ */
+function useSyncState(initialState) {
+  var stateRef = (0, _react.useRef)(UNINITIALIZED);
+  // Initialize ref on first render
+  if (stateRef.current === UNINITIALIZED) {
+    stateRef.current = typeof initialState === 'function' ? initialState() : initialState;
+  }
+  var _useState = (0, _react.useState)({}),
+    _useState2 = (0, _slicedToArray2["default"])(_useState, 2),
+    forceUpdate = _useState2[1];
+  var getState = (0, _useEventCallback["default"])(function () {
+    return stateRef.current;
+  });
+  var setState = (0, _useEventCallback["default"])(function (value) {
+    var prevState = stateRef.current;
+    var nextState = typeof value === 'function' ? value(prevState) : value;
+    if (!Object.is(prevState, nextState)) {
+      stateRef.current = nextState;
+      forceUpdate({});
+    }
+  });
+  return [getState, setState];
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/components/useUpdateEffect/index.d.ts

@@ -0,0 +1,9 @@
+import { type DependencyList, type EffectCallback } from 'react';
+/**
+ * A hook identical to `useEffect`, but it skips the effect on the initial mount
+ * and only runs on subsequent updates.
+ *
+ * @param effect The effect callback to run on updates
+ * @param deps The dependency array
+ */
+export default function useUpdateEffect(effect: EffectCallback, deps?: DependencyList): void;

package/lib/components/useUpdateEffect/index.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = useUpdateEffect;
+var _react = require("react");
+/**
+ * A hook identical to `useEffect`, but it skips the effect on the initial mount
+ * and only runs on subsequent updates.
+ *
+ * @param effect The effect callback to run on updates
+ * @param deps The dependency array
+ */
+function useUpdateEffect(effect, deps) {
+  var isMounted = (0, _react.useRef)(false);
+  (0, _react.useEffect)(function () {
+    if (!isMounted.current) {
+      isMounted.current = true;
+      return;
+    }
+    return effect();
+  }, deps);
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvc3JjL2NvbXBvbmVudHMvdXNlVXBkYXRlRWZmZWN0L2luZGV4LnRzIiwiY29tcG9uZW50cy91c2VVcGRhdGVFZmZlY3QvaW5kZXguanMiXSwibmFtZXMiOlsiX3JlYWN0IiwicmVxdWlyZSIsInVzZVVwZGF0ZUVmZmVjdCIsImVmZmVjdCIsImRlcHMiLCJpc01vdW50ZWQiLCJ1c2VSZWYiLCJ1c2VFZmZlY3QiLCJjdXJyZW50Il0sIm1hcHBpbmdzIjoiOzs7Ozs7QUFBQSxJQUFBQSxNQUFBLEdBQUFDLE9BQUE7QUFFQTtBQ0FBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBREVjLFNBQVVDLGVBQWVBLENBQUNDLE1BQXNCLEVBQUVDLElBQXFCLEVBQUE7RUFDbkYsSUFBTUMsU0FBUyxHQUFHLElBQUFDLGFBQU0sRUFBQyxLQUFLLENBQUM7RUFFL0IsSUFBQUMsZ0JBQVMsRUFBQyxZQUFLO0lBQ2IsSUFBSSxDQUFDRixTQUFTLENBQUNHLE9BQU8sRUFBRTtNQUN0QkgsU0FBUyxDQUFDRyxPQUFPLEdBQUcsSUFBSTtNQUN4QjtJQUNGO0lBQ0EsT0FBT0wsTUFBTSxDQUFBLENBQUU7RUFDakIsQ0FBQyxFQUFFQyxJQUFJLENBQUM7QUFDViIsImZpbGUiOiJjb21wb25lbnRzL3VzZVVwZGF0ZUVmZmVjdC9pbmRleC5qcyIsInNvdXJjZXNDb250ZW50IjpbbnVsbCwiaW1wb3J0IHsgdXNlRWZmZWN0LCB1c2VSZWYgfSBmcm9tICdyZWFjdCc7XG4vKipcbiAqIEEgaG9vayBpZGVudGljYWwgdG8gYHVzZUVmZmVjdGAsIGJ1dCBpdCBza2lwcyB0aGUgZWZmZWN0IG9uIHRoZSBpbml0aWFsIG1vdW50XG4gKiBhbmQgb25seSBydW5zIG9uIHN1YnNlcXVlbnQgdXBkYXRlcy5cbiAqXG4gKiBAcGFyYW0gZWZmZWN0IFRoZSBlZmZlY3QgY2FsbGJhY2sgdG8gcnVuIG9uIHVwZGF0ZXNcbiAqIEBwYXJhbSBkZXBzIFRoZSBkZXBlbmRlbmN5IGFycmF5XG4gKi9cbmV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uIHVzZVVwZGF0ZUVmZmVjdChlZmZlY3QsIGRlcHMpIHtcbiAgICBjb25zdCBpc01vdW50ZWQgPSB1c2VSZWYoZmFsc2UpO1xuICAgIHVzZUVmZmVjdCgoKSA9PiB7XG4gICAgICAgIGlmICghaXNNb3VudGVkLmN1cnJlbnQpIHtcbiAgICAgICAgICAgIGlzTW91bnRlZC5jdXJyZW50ID0gdHJ1ZTtcbiAgICAgICAgICAgIHJldHVybjtcbiAgICAgICAgfVxuICAgICAgICByZXR1cm4gZWZmZWN0KCk7XG4gICAgfSwgZGVwcyk7XG59Il0sInNvdXJjZVJvb3QiOiIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMifQ==