@1money/hooks 0.1.0

package/lib/useControlledState/index.js

@@ -0,0 +1,54 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/useControlledState/index.ts
+var useControlledState_exports = {};
+__export(useControlledState_exports, {
+  default: () => useControlledState
+});
+module.exports = __toCommonJS(useControlledState_exports);
+var import_react = require("react");
+var import_useLayoutEffect = __toESM(require("../useLayoutEffect"));
+function useControlledState(defaultStateValue, value) {
+  const [innerValue, setInnerValue] = (0, import_react.useState)(defaultStateValue);
+  const mergedValue = value !== void 0 ? value : innerValue;
+  (0, import_useLayoutEffect.default)(
+    (mount) => {
+      if (!mount && value !== void 0) {
+        setInnerValue(value);
+      }
+    },
+    [value]
+  );
+  return [
+    // Value
+    mergedValue,
+    // Update function
+    setInnerValue
+  ];
+}

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

@@ -0,0 +1,42 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/useEventCallback/index.ts
+var useEventCallback_exports = {};
+__export(useEventCallback_exports, {
+  default: () => useEventCallback
+});
+module.exports = __toCommonJS(useEventCallback_exports);
+var import_react = require("react");
+var import_useLatest = __toESM(require("../useLatest"));
+function useEventCallback(fn) {
+  const fnRef = (0, import_useLatest.default)(fn);
+  return (0, import_react.useCallback)((...args) => {
+    return fnRef.current(...args);
+  }, []);
+}

package/lib/useLatest/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * A hook that returns a ref object whose `.current` property is always
+ * updated to the latest value. Useful for accessing the latest value
+ * in callbacks without causing re-renders or stale closures.
+ *
+ * @param value The value to keep up-to-date
+ * @returns A ref object containing the latest value
+ */
+export default function useLatest<T>(value: T): import("react").RefObject<T>;

package/lib/useLatest/index.js

@@ -0,0 +1,30 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/useLatest/index.ts
+var useLatest_exports = {};
+__export(useLatest_exports, {
+  default: () => useLatest
+});
+module.exports = __toCommonJS(useLatest_exports);
+var import_react = require("react");
+function useLatest(value) {
+  const ref = (0, import_react.useRef)(value);
+  ref.current = value;
+  return ref;
+}

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

@@ -0,0 +1,33 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/useLayoutEffect/index.ts
+var useLayoutEffect_exports = {};
+__export(useLayoutEffect_exports, {
+  default: () => useLayoutEffect
+});
+module.exports = __toCommonJS(useLayoutEffect_exports);
+var import_react = require("react");
+function useLayoutEffect(effect, deps) {
+  const isMounted = (0, import_react.useRef)(false);
+  (0, import_react.useLayoutEffect)(() => {
+    const mount = !isMounted.current;
+    isMounted.current = true;
+    return effect(mount);
+  }, deps);
+}

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

@@ -0,0 +1,85 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/useLayoutState/index.ts
+var useLayoutState_exports = {};
+__export(useLayoutState_exports, {
+  default: () => useLayoutState,
+  useTimeoutLock: () => useTimeoutLock
+});
+module.exports = __toCommonJS(useLayoutState_exports);
+var import_react = require("react");
+function useLayoutState(defaultState) {
+  const stateRef = (0, import_react.useRef)(defaultState);
+  const [, forceUpdate] = (0, import_react.useState)({});
+  const lastPromiseRef = (0, import_react.useRef)(null);
+  const updateBatchRef = (0, import_react.useRef)([]);
+  const setFrameState = (0, import_react.useCallback)((updater) => {
+    updateBatchRef.current.push(updater);
+    const promise = Promise.resolve();
+    lastPromiseRef.current = promise;
+    promise.then(() => {
+      if (lastPromiseRef.current === promise) {
+        const prevBatch = updateBatchRef.current;
+        const prevState = stateRef.current;
+        updateBatchRef.current = [];
+        prevBatch.forEach((batchUpdater) => {
+          stateRef.current = batchUpdater(stateRef.current);
+        });
+        lastPromiseRef.current = null;
+        if (prevState !== stateRef.current) {
+          forceUpdate({});
+        }
+      }
+    });
+  }, []);
+  (0, import_react.useEffect)(
+    () => () => {
+      lastPromiseRef.current = null;
+    },
+    []
+  );
+  return [stateRef.current, setFrameState];
+}
+function useTimeoutLock(defaultState) {
+  const frameRef = (0, import_react.useRef)(defaultState ?? null);
+  const timeoutRef = (0, import_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(() => {
+      frameRef.current = null;
+      timeoutRef.current = null;
+    }, 100);
+  }
+  function getState() {
+    return frameRef.current;
+  }
+  (0, import_react.useEffect)(() => cleanUp, []);
+  return [setState, getState];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useTimeoutLock
+});

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

@@ -0,0 +1,36 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/useMemoizedFn/index.ts
+var useMemoizedFn_exports = {};
+__export(useMemoizedFn_exports, {
+  default: () => useMemoizedFn
+});
+module.exports = __toCommonJS(useMemoizedFn_exports);
+var import_react = require("react");
+function useMemoizedFn(fn) {
+  const fnRef = (0, import_react.useRef)(fn);
+  fnRef.current = (0, import_react.useMemo)(() => fn, [fn]);
+  const memoizedFn = (0, import_react.useRef)(void 0);
+  if (!memoizedFn.current) {
+    memoizedFn.current = function(...args) {
+      return fnRef.current.apply(this, args);
+    };
+  }
+  return memoizedFn.current;
+}

package/lib/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/usePrevious/index.js

@@ -0,0 +1,32 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/usePrevious/index.ts
+var usePrevious_exports = {};
+__export(usePrevious_exports, {
+  default: () => usePrevious
+});
+module.exports = __toCommonJS(usePrevious_exports);
+var import_react = require("react");
+function usePrevious(value) {
+  const ref = (0, import_react.useRef)(void 0);
+  (0, import_react.useEffect)(() => {
+    ref.current = value;
+  }, [value]);
+  return ref.current;
+}

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

@@ -0,0 +1,42 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/useSafeState/index.ts
+var useSafeState_exports = {};
+__export(useSafeState_exports, {
+  default: () => useSafeState_default
+});
+module.exports = __toCommonJS(useSafeState_exports);
+var import_react = require("react");
+function useSafeState(initialState) {
+  const isMountedRef = (0, import_react.useRef)(true);
+  const [state, setState] = (0, import_react.useState)(initialState);
+  (0, import_react.useEffect)(() => {
+    isMountedRef.current = true;
+    return () => {
+      isMountedRef.current = false;
+    };
+  }, []);
+  const setSafeState = (0, import_react.useCallback)((value) => {
+    if (isMountedRef.current) {
+      setState(value);
+    }
+  }, []);
+  return [state, setSafeState];
+}
+var useSafeState_default = useSafeState;

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

@@ -0,0 +1,54 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/useSyncState/index.ts
+var useSyncState_exports = {};
+__export(useSyncState_exports, {
+  default: () => useSyncState
+});
+module.exports = __toCommonJS(useSyncState_exports);
+var import_react = require("react");
+var import_useEventCallback = __toESM(require("../useEventCallback"));
+var UNINITIALIZED = Symbol("useSyncState.uninitialized");
+function useSyncState(initialState) {
+  const stateRef = (0, import_react.useRef)(UNINITIALIZED);
+  if (stateRef.current === UNINITIALIZED) {
+    stateRef.current = typeof initialState === "function" ? initialState() : initialState;
+  }
+  const [, forceUpdate] = (0, import_react.useState)({});
+  const getState = (0, import_useEventCallback.default)(() => stateRef.current);
+  const setState = (0, import_useEventCallback.default)((value) => {
+    const prevState = stateRef.current;
+    const nextState = typeof value === "function" ? value(prevState) : value;
+    if (!Object.is(prevState, nextState)) {
+      stateRef.current = nextState;
+      forceUpdate({});
+    }
+  });
+  return [getState, setState];
+}

package/lib/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/useUpdateEffect/index.js

@@ -0,0 +1,35 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/useUpdateEffect/index.ts
+var useUpdateEffect_exports = {};
+__export(useUpdateEffect_exports, {
+  default: () => useUpdateEffect
+});
+module.exports = __toCommonJS(useUpdateEffect_exports);
+var import_react = require("react");
+function useUpdateEffect(effect, deps) {
+  const isMounted = (0, import_react.useRef)(false);
+  (0, import_react.useEffect)(() => {
+    if (!isMounted.current) {
+      isMounted.current = true;
+      return;
+    }
+    return effect();
+  }, deps);
+}