@1money/react-ui 1.15.3 → 1.17.0

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==