@1money/react-ui 1.15.3 → 1.17.0

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