@1money/react-ui 1.16.0 → 1.17.0

package/es/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/es/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/es/components/useControlledState/index.js

@@ -0,0 +1,32 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { useState } from 'react';
+import useLayoutEffect from '../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`.
+ */
+export default function useControlledState(defaultStateValue, value) {
+  var _useState = useState(defaultStateValue),
+    _useState2 = _slicedToArray(_useState, 2),
+    innerValue = _useState2[0],
+    setInnerValue = _useState2[1];
+  var mergedValue = value !== undefined ? value : innerValue;
+  useLayoutEffect(function (mount) {
+    if (!mount && value !== undefined) {
+      setInnerValue(value);
+    }
+  }, [value]);
+  return [
+  // Value
+  mergedValue,
+  // Update function
+  setInnerValue];
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvc3JjL2NvbXBvbmVudHMvdXNlQ29udHJvbGxlZFN0YXRlL2luZGV4LnRzIiwiY29tcG9uZW50cy91c2VDb250cm9sbGVkU3RhdGUvaW5kZXguanMiXSwibmFtZXMiOlsidXNlU3RhdGUiLCJ1c2VMYXlvdXRFZmZlY3QiLCJ1c2VDb250cm9sbGVkU3RhdGUiLCJkZWZhdWx0U3RhdGVWYWx1ZSIsInZhbHVlIiwiX3VzZVN0YXRlIiwiX3VzZVN0YXRlMiIsIl9zbGljZWRUb0FycmF5IiwiaW5uZXJWYWx1ZSIsInNldElubmVyVmFsdWUiLCJtZXJnZWRWYWx1ZSIsInVuZGVmaW5lZCIsIm1vdW50Il0sIm1hcHBpbmdzIjoiO0FBQUEsU0FBU0EsUUFBUSxRQUFRLE9BQU87QUFDaEMsT0FBT0MsZUFBZSxNQUFNLG9CQUFvQjtBQUloRDtBQ0ZBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FESUEsZUFBYyxTQUFVQyxrQkFBa0JBLENBQ3hDQyxpQkFBZ0MsRUFDaENDLEtBQVMsRUFBQTtFQUVULElBQUFDLFNBQUEsR0FBb0NMLFFBQVEsQ0FBSUcsaUJBQWlCLENBQUM7SUFBQUcsVUFBQSxHQUFBQyxjQUFBLENBQUFGLFNBQUE7SUFBM0RHLFVBQVUsR0FBQUYsVUFBQTtJQUFFRyxhQUFhLEdBQUFILFVBQUE7RUFFaEMsSUFBTUksV0FBVyxHQUFHTixLQUFLLEtBQUtPLFNBQVMsR0FBR1AsS0FBSyxHQUFHSSxVQUFVO0VBRTVEUCxlQUFlLENBQ2IsVUFBQVcsS0FBSyxFQUFHO0lBQ04sSUFBSSxDQUFDQSxLQUFLLElBQUlSLEtBQUssS0FBS08sU0FBUyxFQUFFO01BQ2pDRixhQUFhLENBQUNMLEtBQUssQ0FBQztJQUN0QjtFQUNGLENBQUMsRUFDRCxDQUFDQSxLQUFLLENBQUMsQ0FDUjtFQUVELE9BQU87RUFDTDtFQUNBTSxXQUFXO0VBQ1g7RUFDQUQsYUFBYSxDQUNkO0FBQ0giLCJmaWxlIjoiY29tcG9uZW50cy91c2VDb250cm9sbGVkU3RhdGUvaW5kZXguanMiLCJzb3VyY2VzQ29udGVudCI6W251bGwsImltcG9ydCB7IHVzZVN0YXRlIH0gZnJvbSAncmVhY3QnO1xuaW1wb3J0IHVzZUxheW91dEVmZmVjdCBmcm9tICcuLi91c2VMYXlvdXRFZmZlY3QnO1xuLyoqXG4gKiBTaW1pbGFyIHRvIGB1c2VTdGF0ZWAgYnV0IHdpbGwgdXNlIHByb3BzIHZhbHVlIGlmIHByb3ZpZGVkLlxuICogRnJvbSBSZWFjdCAxOCwgd2UgZG8gbm90IG5lZWQgc2FmZSBgdXNlU3RhdGVgIHNpbmNlIGl0IHdpbGwgbm90IHRocm93IGZvciB1bm1vdW50ZWQgdXBkYXRlLlxuICogVGhpcyBob29rIHJlbW92ZXMgdGhlIGBvbkNoYW5nZWAgJiBgcG9zdFN0YXRlYCBsb2dpYyBzaW5jZSB3ZSBvbmx5IG5lZWQgYmFzaWMgbWVyZ2VkIHN0YXRlIGxvZ2ljLlxuICpcbiAqIFRoZSBgbWVyZ2VkVmFsdWVgIHJldHVybiBhbHJlYWR5IHJlZmxlY3RzIHRoZSBsYXRlc3QgY29udHJvbGxlZCBgdmFsdWVgIHdpdGhvdXRcbiAqIHRoZSBsYXlvdXQgZWZmZWN0LiBUaGUgZWZmZWN0IGV4aXN0cyB0byBzeW5jIGBpbm5lclZhbHVlYCBmb3IgdGhlIGVkZ2UgY2FzZSB3aGVyZVxuICogdGhlIGNvbXBvbmVudCBzdGFydHMgaW4gdW5jb250cm9sbGVkIG1vZGUgKGNhbGxpbmcgYHNldElubmVyVmFsdWVgIGRpcmVjdGx5KSBhbmRcbiAqIHRoZW4gdHJhbnNpdGlvbnMgdG8gY29udHJvbGxlZCBtb2RlIChwYXJlbnQgc3RhcnRzIHByb3ZpZGluZyBgdmFsdWVgKS4gV2l0aG91dCB0aGlzXG4gKiBzeW5jLCByZXZlcnRpbmcgYmFjayB0byB1bmNvbnRyb2xsZWQgbW9kZSB3b3VsZCBzaG93IHRoZSBzdGFsZSBgaW5uZXJWYWx1ZWAuXG4gKi9cbmV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uIHVzZUNvbnRyb2xsZWRTdGF0ZShkZWZhdWx0U3RhdGVWYWx1ZSwgdmFsdWUpIHtcbiAgICBjb25zdCBbaW5uZXJWYWx1ZSwgc2V0SW5uZXJWYWx1ZV0gPSB1c2VTdGF0ZShkZWZhdWx0U3RhdGVWYWx1ZSk7XG4gICAgY29uc3QgbWVyZ2VkVmFsdWUgPSB2YWx1ZSAhPT0gdW5kZWZpbmVkID8gdmFsdWUgOiBpbm5lclZhbHVlO1xuICAgIHVzZUxheW91dEVmZmVjdChtb3VudCA9PiB7XG4gICAgICAgIGlmICghbW91bnQgJiYgdmFsdWUgIT09IHVuZGVmaW5lZCkge1xuICAgICAgICAgICAgc2V0SW5uZXJWYWx1ZSh2YWx1ZSk7XG4gICAgICAgIH1cbiAgICB9LCBbdmFsdWVdKTtcbiAgICByZXR1cm4gW1xuICAgICAgICAvLyBWYWx1ZVxuICAgICAgICBtZXJnZWRWYWx1ZSxcbiAgICAgICAgLy8gVXBkYXRlIGZ1bmN0aW9uXG4gICAgICAgIHNldElubmVyVmFsdWUsXG4gICAgXTtcbn0iXSwic291cmNlUm9vdCI6Ii4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYyJ9

package/es/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/es/components/useEventCallback/index.js

@@ -0,0 +1,17 @@
+import { useCallback } from 'react';
+import useLatest from '../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
+ */
+export default function useEventCallback(fn) {
+  var fnRef = useLatest(fn);
+  return useCallback(function () {
+    return fnRef.current.apply(fnRef, arguments);
+  }, []);
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvc3JjL2NvbXBvbmVudHMvdXNlRXZlbnRDYWxsYmFjay9pbmRleC50cyIsImNvbXBvbmVudHMvdXNlRXZlbnRDYWxsYmFjay9pbmRleC5qcyJdLCJuYW1lcyI6WyJ1c2VDYWxsYmFjayIsInVzZUxhdGVzdCIsInVzZUV2ZW50Q2FsbGJhY2siLCJmbiIsImZuUmVmIiwiY3VycmVudCIsImFwcGx5IiwiYXJndW1lbnRzIl0sIm1hcHBpbmdzIjoiQUFBQSxTQUFTQSxXQUFXLFFBQVEsT0FBTztBQUNuQyxPQUFPQyxTQUFTLE1BQU0sY0FBYztBQUlwQztBQ0ZBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FESUEsZUFBYyxTQUFVQyxnQkFBZ0JBLENBQXlCQyxFQUFZLEVBQUE7RUFDM0UsSUFBTUMsS0FBSyxHQUFHSCxTQUFTLENBQUNFLEVBQUUsQ0FBQztFQUUzQixPQUFPSCxXQUFXLENBQUMsWUFBZTtJQUNoQyxPQUFPSSxLQUFLLENBQUNDLE9BQU8sQ0FBQUMsS0FBQSxDQUFiRixLQUFLLEVBQUFHLFNBQWdCLENBQUM7RUFDL0IsQ0FBQyxFQUFFLEVBQUUsQ0FBQztBQUNSIiwiZmlsZSI6ImNvbXBvbmVudHMvdXNlRXZlbnRDYWxsYmFjay9pbmRleC5qcyIsInNvdXJjZXNDb250ZW50IjpbbnVsbCwiaW1wb3J0IHsgdXNlQ2FsbGJhY2sgfSBmcm9tICdyZWFjdCc7XG5pbXBvcnQgdXNlTGF0ZXN0IGZyb20gJy4uL3VzZUxhdGVzdCc7XG4vKipcbiAqIEEgaG9vayB0aGF0IHJldHVybnMgYSBzdGFibGUgY2FsbGJhY2sgcmVmZXJlbmNlIHRoYXQgYWx3YXlzIGludm9rZXNcbiAqIHRoZSBsYXRlc3QgdmVyc2lvbiBvZiB0aGUgcHJvdmlkZWQgZnVuY3Rpb24uIFNpbWlsYXIgdG8gdGhlIFJlYWN0XG4gKiB1c2VFdmVudCBSRkMgcHJvcG9zYWwuXG4gKlxuICogQHBhcmFtIGZuIFRoZSBmdW5jdGlvbiB0byB3cmFwXG4gKiBAcmV0dXJucyBBIHN0YWJsZSBjYWxsYmFjayB0aGF0IGFsd2F5cyBjYWxscyB0aGUgbGF0ZXN0IGZuXG4gKi9cbmV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uIHVzZUV2ZW50Q2FsbGJhY2soZm4pIHtcbiAgICBjb25zdCBmblJlZiA9IHVzZUxhdGVzdChmbik7XG4gICAgcmV0dXJuIHVzZUNhbGxiYWNrKCguLi5hcmdzKSA9PiB7XG4gICAgICAgIHJldHVybiBmblJlZi5jdXJyZW50KC4uLmFyZ3MpO1xuICAgIH0sIFtdKTtcbn0iXSwic291cmNlUm9vdCI6Ii4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYyJ9

package/es/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/es/components/useLayoutEffect/index.js

@@ -0,0 +1,17 @@
+import { useLayoutEffect as reactUseLayoutEffect, useRef } from '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
+ */
+export default function useLayoutEffect(effect, deps) {
+  var isMounted = useRef(false);
+  reactUseLayoutEffect(function () {
+    var mount = !isMounted.current;
+    isMounted.current = true;
+    return effect(mount);
+  }, deps);
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvc3JjL2NvbXBvbmVudHMvdXNlTGF5b3V0RWZmZWN0L2luZGV4LnRzIiwiY29tcG9uZW50cy91c2VMYXlvdXRFZmZlY3QvaW5kZXguanMiXSwibmFtZXMiOlsidXNlTGF5b3V0RWZmZWN0IiwicmVhY3RVc2VMYXlvdXRFZmZlY3QiLCJ1c2VSZWYiLCJlZmZlY3QiLCJkZXBzIiwiaXNNb3VudGVkIiwibW91bnQiLCJjdXJyZW50Il0sIm1hcHBpbmdzIjoiQUFBQSxTQUNFQSxlQUFlLElBQUlDLG9CQUFvQixFQUN2Q0MsTUFBTSxRQUVELE9BQU87QUFJZDtBQ05BO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBRFFBLGVBQWMsU0FBVUYsZUFBZUEsQ0FBQ0csTUFBc0IsRUFBRUMsSUFBcUIsRUFBQTtFQUNuRixJQUFNQyxTQUFTLEdBQUdILE1BQU0sQ0FBQyxLQUFLLENBQUM7RUFFL0JELG9CQUFvQixDQUFDLFlBQUs7SUFDeEIsSUFBTUssS0FBSyxHQUFHLENBQUNELFNBQVMsQ0FBQ0UsT0FBTztJQUNoQ0YsU0FBUyxDQUFDRSxPQUFPLEdBQUcsSUFBSTtJQUN4QixPQUFPSixNQUFNLENBQUNHLEtBQUssQ0FBQztFQUN0QixDQUFDLEVBQUVGLElBQUksQ0FBQztBQUNWIiwiZmlsZSI6ImNvbXBvbmVudHMvdXNlTGF5b3V0RWZmZWN0L2luZGV4LmpzIiwic291cmNlc0NvbnRlbnQiOltudWxsLCJpbXBvcnQgeyB1c2VMYXlvdXRFZmZlY3QgYXMgcmVhY3RVc2VMYXlvdXRFZmZlY3QsIHVzZVJlZiwgfSBmcm9tICdyZWFjdCc7XG4vKipcbiAqIEEgY3VzdG9tIGB1c2VMYXlvdXRFZmZlY3RgIHRoYXQgcGFzc2VzIGEgYm9vbGVhbiBpbmRpY2F0aW5nIHdoZXRoZXJcbiAqIGl0J3MgdGhlIGluaXRpYWwgbW91bnQgKGB0cnVlYCkgb3IgYSBzdWJzZXF1ZW50IHVwZGF0ZSAoYGZhbHNlYCkuXG4gKlxuICogQHBhcmFtIGVmZmVjdCBUaGUgZWZmZWN0IGNhbGxiYWNrIHRoYXQgcmVjZWl2ZXMgYSBgbW91bnRgIHBhcmFtZXRlclxuICogQHBhcmFtIGRlcHMgVGhlIGRlcGVuZGVuY3kgYXJyYXlcbiAqL1xuZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24gdXNlTGF5b3V0RWZmZWN0KGVmZmVjdCwgZGVwcykge1xuICAgIGNvbnN0IGlzTW91bnRlZCA9IHVzZVJlZihmYWxzZSk7XG4gICAgcmVhY3RVc2VMYXlvdXRFZmZlY3QoKCkgPT4ge1xuICAgICAgICBjb25zdCBtb3VudCA9ICFpc01vdW50ZWQuY3VycmVudDtcbiAgICAgICAgaXNNb3VudGVkLmN1cnJlbnQgPSB0cnVlO1xuICAgICAgICByZXR1cm4gZWZmZWN0KG1vdW50KTtcbiAgICB9LCBkZXBzKTtcbn0iXSwic291cmNlUm9vdCI6Ii4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYyJ9

package/es/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/es/components/useLayoutState/index.js

@@ -0,0 +1,71 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { useRef, useState, useEffect, useCallback } from '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]`
+ */
+export default function useLayoutState(defaultState) {
+  var stateRef = useRef(defaultState);
+  var _useState = useState({}),
+    _useState2 = _slicedToArray(_useState, 2),
+    forceUpdate = _useState2[1];
+  var lastPromiseRef = useRef(null);
+  var updateBatchRef = useRef([]);
+  var setFrameState = 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({});
+        }
+      }
+    });
+  }, []);
+  useEffect(function () {
+    return function () {
+      lastPromiseRef.current = null;
+    };
+  }, []);
+  return [stateRef.current, setFrameState];
+}
+/** Lock frame, when frame pass reset the lock. */
+export function useTimeoutLock(defaultState) {
+  var frameRef = useRef(defaultState !== null && defaultState !== void 0 ? defaultState : null);
+  var timeoutRef = 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;
+  }
+  useEffect(function () {
+    return cleanUp;
+  }, []);
+  return [setState, getState];
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/es/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/es/components/useMemoizedFn/index.js

@@ -0,0 +1,27 @@
+import { useMemo, useRef } from '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
+ */
+export default function useMemoizedFn(fn) {
+  var fnRef = useRef(fn);
+  fnRef.current = useMemo(function () {
+    return fn;
+  }, [fn]);
+  var memoizedFn = 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/es/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/es/components/usePrevious/index.js

@@ -0,0 +1,19 @@
+import { useEffect, useRef } from '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
+ */
+export default function usePrevious(value) {
+  var ref = useRef(undefined);
+  useEffect(function () {
+    ref.current = value;
+  }, [value]);
+  return ref.current;
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvc3JjL2NvbXBvbmVudHMvdXNlUHJldmlvdXMvaW5kZXgudHMiLCJjb21wb25lbnRzL3VzZVByZXZpb3VzL2luZGV4LmpzIl0sIm5hbWVzIjpbInVzZUVmZmVjdCIsInVzZVJlZiIsInVzZVByZXZpb3VzIiwidmFsdWUiLCJyZWYiLCJ1bmRlZmluZWQiLCJjdXJyZW50Il0sIm1hcHBpbmdzIjoiQUFBQSxTQUFTQSxTQUFTLEVBQUVDLE1BQU0sUUFBUSxPQUFPO0FBRXpDO0FDQUE7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FERUEsZUFBYyxTQUFVQyxXQUFXQSxDQUFJQyxLQUFRLEVBQUE7RUFDN0MsSUFBTUMsR0FBRyxHQUFHSCxNQUFNLENBQWdCSSxTQUFTLENBQUM7RUFFNUNMLFNBQVMsQ0FBQyxZQUFLO0lBQ2JJLEdBQUcsQ0FBQ0UsT0FBTyxHQUFHSCxLQUFLO0VBQ3JCLENBQUMsRUFBRSxDQUFDQSxLQUFLLENBQUMsQ0FBQztFQUVYLE9BQU9DLEdBQUcsQ0FBQ0UsT0FBTztBQUNwQiIsImZpbGUiOiJjb21wb25lbnRzL3VzZVByZXZpb3VzL2luZGV4LmpzIiwic291cmNlc0NvbnRlbnQiOltudWxsLCJpbXBvcnQgeyB1c2VFZmZlY3QsIHVzZVJlZiB9IGZyb20gJ3JlYWN0Jztcbi8qKlxuICogUmV0dXJucyB0aGUgbGFzdCBkaXN0aW5jdCB2YWx1ZSBvYnNlcnZlZCBiZWZvcmUgdGhlIGN1cnJlbnQgYHZhbHVlYC5cbiAqXG4gKiBCZWNhdXNlIHRoZSBpbnRlcm5hbCBlZmZlY3QgZGVwZW5kcyBvbiBgW3ZhbHVlXWAsIHRoZSByZWYgaXMgb25seSB1cGRhdGVkXG4gKiB3aGVuIGB2YWx1ZWAgY2hhbmdlcy4gVGhhdCBtZWFucyB0aGlzIGhvb2sgdHJhY2tzIHRoZSBwcmV2aW91cyB2YWx1ZSBvblxuICogdmFsdWUtY2hhbmdlIGJvdW5kYXJpZXMgKG5vdCBldmVyeSByZW5kZXIpLlxuICpcbiAqIEBwYXJhbSB2YWx1ZSBUaGUgdmFsdWUgdG8gdHJhY2tcbiAqIEByZXR1cm5zIFRoZSBwcmV2aW91cyBkaXN0aW5jdCB2YWx1ZSwgb3IgYHVuZGVmaW5lZGAgdW50aWwgb25lIGV4aXN0c1xuICovXG5leHBvcnQgZGVmYXVsdCBmdW5jdGlvbiB1c2VQcmV2aW91cyh2YWx1ZSkge1xuICAgIGNvbnN0IHJlZiA9IHVzZVJlZih1bmRlZmluZWQpO1xuICAgIHVzZUVmZmVjdCgoKSA9PiB7XG4gICAgICAgIHJlZi5jdXJyZW50ID0gdmFsdWU7XG4gICAgfSwgW3ZhbHVlXSk7XG4gICAgcmV0dXJuIHJlZi5jdXJyZW50O1xufSJdLCJzb3VyY2VSb290IjoiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjIn0=

package/es/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/es/components/useSafeState/index.js

@@ -0,0 +1,24 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { useState, useCallback, useRef, useEffect } from 'react';
+// eslint-disable-next-line no-redeclare
+function useSafeState(initialState) {
+  var isMountedRef = useRef(true);
+  var _useState = useState(initialState),
+    _useState2 = _slicedToArray(_useState, 2),
+    state = _useState2[0],
+    setState = _useState2[1];
+  useEffect(function () {
+    isMountedRef.current = true;
+    return function () {
+      isMountedRef.current = false;
+    };
+  }, []);
+  var setSafeState = useCallback(function (value) {
+    if (isMountedRef.current) {
+      setState(value);
+    }
+  }, []);
+  return [state, setSafeState];
+}
+export default useSafeState;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvc3JjL2NvbXBvbmVudHMvdXNlU2FmZVN0YXRlL2luZGV4LnRzIl0sIm5hbWVzIjpbInVzZVN0YXRlIiwidXNlQ2FsbGJhY2siLCJ1c2VSZWYiLCJ1c2VFZmZlY3QiLCJ1c2VTYWZlU3RhdGUiLCJpbml0aWFsU3RhdGUiLCJpc01vdW50ZWRSZWYiLCJfdXNlU3RhdGUiLCJfdXNlU3RhdGUyIiwiX3NsaWNlZFRvQXJyYXkiLCJzdGF0ZSIsInNldFN0YXRlIiwiY3VycmVudCIsInNldFNhZmVTdGF0ZSIsInZhbHVlIl0sIm1hcHBpbmdzIjoiO0FBQUEsU0FBU0EsUUFBUSxFQUFFQyxXQUFXLEVBQUVDLE1BQU0sRUFBRUMsU0FBUyxRQUE0QyxPQUFPO0FBYXBHO0FBQ0EsU0FBU0MsWUFBWUEsQ0FDbkJDLFlBQTRCLEVBQUE7RUFFNUIsSUFBTUMsWUFBWSxHQUFHSixNQUFNLENBQUMsSUFBSSxDQUFDO0VBQ2pDLElBQUFLLFNBQUEsR0FBMEJQLFFBQVEsQ0FBZ0JLLFlBQXlDLENBQUM7SUFBQUcsVUFBQSxHQUFBQyxjQUFBLENBQUFGLFNBQUE7SUFBckZHLEtBQUssR0FBQUYsVUFBQTtJQUFFRyxRQUFRLEdBQUFILFVBQUE7RUFFdEJMLFNBQVMsQ0FBQyxZQUFLO0lBQ2JHLFlBQVksQ0FBQ00sT0FBTyxHQUFHLElBQUk7SUFDM0IsT0FBTyxZQUFLO01BQ1ZOLFlBQVksQ0FBQ00sT0FBTyxHQUFHLEtBQUs7SUFDOUIsQ0FBQztFQUNILENBQUMsRUFBRSxFQUFFLENBQUM7RUFFTixJQUFNQyxZQUFZLEdBQUdaLFdBQVcsQ0FBMEMsVUFBQWEsS0FBSyxFQUFHO0lBQ2hGLElBQUlSLFlBQVksQ0FBQ00sT0FBTyxFQUFFO01BQ3hCRCxRQUFRLENBQUNHLEtBQUssQ0FBQztJQUNqQjtFQUNGLENBQUMsRUFBRSxFQUFFLENBQUM7RUFFTixPQUFPLENBQUNKLEtBQUssRUFBRUcsWUFBWSxDQUFDO0FBQzlCO0FBRUEsZUFBZVQsWUFBWSIsImZpbGUiOiJjb21wb25lbnRzL3VzZVNhZmVTdGF0ZS9pbmRleC5qcyIsInNvdXJjZXNDb250ZW50IjpbbnVsbF0sInNvdXJjZVJvb3QiOiIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMifQ==

package/es/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/es/components/useSyncState/index.js

@@ -0,0 +1,37 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { useState, useRef } from 'react';
+import useEventCallback from '../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
+ */
+export default function useSyncState(initialState) {
+  var stateRef = useRef(UNINITIALIZED);
+  // Initialize ref on first render
+  if (stateRef.current === UNINITIALIZED) {
+    stateRef.current = typeof initialState === 'function' ? initialState() : initialState;
+  }
+  var _useState = useState({}),
+    _useState2 = _slicedToArray(_useState, 2),
+    forceUpdate = _useState2[1];
+  var getState = useEventCallback(function () {
+    return stateRef.current;
+  });
+  var setState = useEventCallback(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/es/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/es/components/useUpdateEffect/index.js

@@ -0,0 +1,19 @@
+import { useEffect, useRef } 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, deps) {
+  var isMounted = useRef(false);
+  useEffect(function () {
+    if (!isMounted.current) {
+      isMounted.current = true;
+      return;
+    }
+    return effect();
+  }, deps);
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvc3JjL2NvbXBvbmVudHMvdXNlVXBkYXRlRWZmZWN0L2luZGV4LnRzIiwiY29tcG9uZW50cy91c2VVcGRhdGVFZmZlY3QvaW5kZXguanMiXSwibmFtZXMiOlsidXNlRWZmZWN0IiwidXNlUmVmIiwidXNlVXBkYXRlRWZmZWN0IiwiZWZmZWN0IiwiZGVwcyIsImlzTW91bnRlZCIsImN1cnJlbnQiXSwibWFwcGluZ3MiOiJBQUFBLFNBQVNBLFNBQVMsRUFBRUMsTUFBTSxRQUFrRCxPQUFPO0FBRW5GO0FDQUE7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FERUEsZUFBYyxTQUFVQyxlQUFlQSxDQUFDQyxNQUFzQixFQUFFQyxJQUFxQixFQUFBO0VBQ25GLElBQU1DLFNBQVMsR0FBR0osTUFBTSxDQUFDLEtBQUssQ0FBQztFQUUvQkQsU0FBUyxDQUFDLFlBQUs7SUFDYixJQUFJLENBQUNLLFNBQVMsQ0FBQ0MsT0FBTyxFQUFFO01BQ3RCRCxTQUFTLENBQUNDLE9BQU8sR0FBRyxJQUFJO01BQ3hCO0lBQ0Y7SUFDQSxPQUFPSCxNQUFNLENBQUEsQ0FBRTtFQUNqQixDQUFDLEVBQUVDLElBQUksQ0FBQztBQUNWIiwiZmlsZSI6ImNvbXBvbmVudHMvdXNlVXBkYXRlRWZmZWN0L2luZGV4LmpzIiwic291cmNlc0NvbnRlbnQiOltudWxsLCJpbXBvcnQgeyB1c2VFZmZlY3QsIHVzZVJlZiB9IGZyb20gJ3JlYWN0Jztcbi8qKlxuICogQSBob29rIGlkZW50aWNhbCB0byBgdXNlRWZmZWN0YCwgYnV0IGl0IHNraXBzIHRoZSBlZmZlY3Qgb24gdGhlIGluaXRpYWwgbW91bnRcbiAqIGFuZCBvbmx5IHJ1bnMgb24gc3Vic2VxdWVudCB1cGRhdGVzLlxuICpcbiAqIEBwYXJhbSBlZmZlY3QgVGhlIGVmZmVjdCBjYWxsYmFjayB0byBydW4gb24gdXBkYXRlc1xuICogQHBhcmFtIGRlcHMgVGhlIGRlcGVuZGVuY3kgYXJyYXlcbiAqL1xuZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24gdXNlVXBkYXRlRWZmZWN0KGVmZmVjdCwgZGVwcykge1xuICAgIGNvbnN0IGlzTW91bnRlZCA9IHVzZVJlZihmYWxzZSk7XG4gICAgdXNlRWZmZWN0KCgpID0+IHtcbiAgICAgICAgaWYgKCFpc01vdW50ZWQuY3VycmVudCkge1xuICAgICAgICAgICAgaXNNb3VudGVkLmN1cnJlbnQgPSB0cnVlO1xuICAgICAgICAgICAgcmV0dXJuO1xuICAgICAgICB9XG4gICAgICAgIHJldHVybiBlZmZlY3QoKTtcbiAgICB9LCBkZXBzKTtcbn0iXSwic291cmNlUm9vdCI6Ii4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYyJ9