@stryke/hooks 0.1.3

package/dist/use-compose-refs.d.ts

@@ -0,0 +1,25 @@
+import { type Ref } from "react";
+/**
+ * Set a given ref to a given value
+ * This utility takes care of different types of refs: callback refs and RefObject(s)
+ *
+ * @param ref - The ref to set
+ * @param value - The value to set the ref to
+ */
+export declare function setRef<T>(ref: Ref<T> | undefined, value: T): void;
+/**
+ * A utility to compose multiple refs together
+ * Accepts callback refs and RefObject(s)
+ *
+ * @param refs - The refs to compose
+ * @returns A function that sets all refs to a given value
+ */
+export declare function composeRefs<T>(...refs: Ref<T>[]): (node: T) => void;
+/**
+ * A custom hook that composes multiple refs
+ * Accepts callback refs and RefObject(s)
+ *
+ * @param refs - The refs to compose
+ * @returns A function that sets all refs to a given value
+ */
+export declare function useComposedRefs<T>(...refs: Ref<T>[]): (node: T) => void;

package/dist/use-compose-refs.mjs

@@ -0,0 +1 @@
+import{isFunction as f}from"@stryke/types/type-checks/is-function";import{useCallback as n}from"react";export function setRef(e,o){e&&(f(e)?e(o):e.current=o)}export function composeRefs(...e){return o=>{for(const t of e)setRef(t,o)}}export function useComposedRefs(...e){return n(composeRefs(...e),e)}

package/dist/use-copy-to-clipboard.cjs

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useCopyToClipboard = useCopyToClipboard;
+var _base = require("@stryke/types/utility-types/base");
+var _react = require("react");
+function i(r) {
+  const t = document.createElement("textarea");
+  t.value = r, document.body.append(t), t.select(), document.execCommand("copy"), t.remove();
+}
+function useCopyToClipboard() {
+  const [r, t] = (0, _react.useState)(null),
+    n = (0, _react.useCallback)(e => {
+      (async () => {
+        try {
+          if (navigator?.clipboard?.writeText) await navigator.clipboard.writeText(e ?? _base.EMPTY_STRING), t(e ?? _base.EMPTY_STRING);else throw new Error("writeText not supported");
+        } catch {
+          i(e ?? _base.EMPTY_STRING), t(e ?? _base.EMPTY_STRING);
+        }
+      })();
+    }, []);
+  return [r, n];
+}

package/dist/use-copy-to-clipboard.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Copies a value to the clipboard
+ *
+ * @returns A tuple with the copied value and a function to copy a value to the clipboard
+ */
+export declare function useCopyToClipboard(): (string | ((value: string | null) => void) | null)[];

package/dist/use-copy-to-clipboard.mjs

@@ -0,0 +1 @@
+import{EMPTY_STRING as o}from"@stryke/types/utility-types/base";import{useCallback as a,useState as c}from"react";function i(r){const t=document.createElement("textarea");t.value=r,document.body.append(t),t.select(),document.execCommand("copy"),t.remove()}export function useCopyToClipboard(){const[r,t]=c(null),n=a(e=>{(async()=>{try{if(navigator?.clipboard?.writeText)await navigator.clipboard.writeText(e??o),t(e??o);else throw new Error("writeText not supported")}catch{i(e??o),t(e??o)}})()},[]);return[r,n]}

package/dist/use-debounce.cjs

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useDebounce = useDebounce;
+exports.useDebounceValue = useDebounceValue;
+var _debounce = require("@stryke/helpers/debounce");
+var _react = require("react");
+function useDebounce(e, n, u = {}, r = [e, u, n]) {
+  const t = (0, _react.useRef)(null);
+  return (0, _react.useEffect)(() => () => {
+    t.current?.cancel();
+  }, []), (0, _react.useMemo)(() => (t.current = (0, _debounce.debounce)(e, n, u), t.current), [e, u, n]);
+}
+function useDebounceValue(e, n = 0) {
+  const [u, r] = (0, _react.useState)(e);
+  return (0, _react.useEffect)(() => {
+    const t = setTimeout(() => {
+      r(c => c === e ? c : e);
+    }, n);
+    return () => {
+      clearTimeout(t);
+    };
+  }, [n, e]), u;
+}

package/dist/use-debounce.d.ts

@@ -0,0 +1,9 @@
+import { DebounceOptions } from "@stryke/helpers/debounce";
+export declare function useDebounce<A extends (...args: any) => any | undefined | null, DebouncedFn extends A & {
+    cancel: () => void;
+}>(fn: A, wait: number, options?: DebounceOptions, mountArgs?: any[]): DebouncedFn;
+/**
+ * Returns a value once it stops changing after "amt" time.
+ * Note: you may need to memo or this will keep re-rendering
+ */
+export declare function useDebounceValue<A>(val: A, amt?: number): A;

package/dist/use-debounce.mjs

@@ -0,0 +1 @@
+import{debounce as s}from"@stryke/helpers/debounce";import{useEffect as o,useMemo as b,useRef as d,useState as f}from"react";export function useDebounce(e,n,u={},r=[e,u,n]){const t=d(null);return o(()=>()=>{t.current?.cancel()},[]),b(()=>(t.current=s(e,n,u),t.current),[e,u,n])}export function useDebounceValue(e,n=0){const[u,r]=f(e);return o(()=>{const t=setTimeout(()=>{r(c=>c===e?c:e)},n);return()=>{clearTimeout(t)}},[n,e]),u}

package/dist/use-did-finish-ssr.cjs

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useClientValue = useClientValue;
+exports.useDidFinishSSR = useDidFinishSSR;
+exports.useDidFinishSSRSync = useDidFinishSSRSync;
+var _isFunction = require("@stryke/types/type-checks/is-function");
+var _react = require("react");
+const a = () => {},
+  c = () => a;
+function useDidFinishSSR(e, n) {
+  if (process.env.TAMAGUI_TARGET === "native") return e ?? !0;
+  if (n?.sync) return (0, _react.useSyncExternalStore)(c, () => e ?? !0, () => !1);
+  const [t, r] = (0, _react.useState)(e);
+  return (0, _react.useEffect)(() => {
+    r(e ?? !0);
+  }, [e]), t ?? !1;
+}
+function useDidFinishSSRSync(e) {
+  return useDidFinishSSR(e, {
+    sync: !0
+  });
+}
+function useClientValue(e) {
+  return useDidFinishSSR() ? (0, _isFunction.isFunction)(e) ? e() : e : void 0;
+}

package/dist/use-did-finish-ssr.d.ts

@@ -0,0 +1,7 @@
+export declare function useDidFinishSSR<A = boolean>(value?: A, options?: {
+    sync?: boolean;
+}): A | false;
+export declare function useDidFinishSSRSync<A = boolean>(value?: A): A | false;
+type FunctionOrValue<Value> = Value extends () => infer X ? X : Value;
+export declare function useClientValue<Value>(value?: Value): FunctionOrValue<Value> | undefined;
+export {};

package/dist/use-did-finish-ssr.mjs

@@ -0,0 +1 @@
+import{isFunction as u}from"@stryke/types/type-checks/is-function";import{useEffect as o,useState as s,useSyncExternalStore as i}from"react";const a=()=>{},c=()=>a;export function useDidFinishSSR(e,n){if(process.env.TAMAGUI_TARGET==="native")return e??!0;if(n?.sync)return i(c,()=>e??!0,()=>!1);const[t,r]=s(e);return o(()=>{r(e??!0)},[e]),t??!1}export function useDidFinishSSRSync(e){return useDidFinishSSR(e,{sync:!0})}export function useClientValue(e){return useDidFinishSSR()?u(e)?e():e:void 0}

package/dist/use-escape-keydown.cjs

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useEscapeKeydown = useEscapeKeydown;
+var _react = require("react");
+var _useCallbackRef = require("./use-callback-ref.cjs");
+function useEscapeKeydown(s, e = globalThis?.document) {
+  const o = (0, _useCallbackRef.useCallbackRef)(s);
+  (0, _react.useEffect)(() => {
+    const n = t => {
+      t.key === "Escape" && o(t);
+    };
+    return e.addEventListener("keydown", n), () => {
+      e.removeEventListener("keydown", n);
+    };
+  }, [o, e]);
+}

package/dist/use-escape-keydown.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Listens for when the escape key is down
+ */
+export declare function useEscapeKeydown(onEscapeKeyDownProp?: (event: KeyboardEvent) => void, ownerDocument?: Document): void;

package/dist/use-escape-keydown.mjs

@@ -0,0 +1 @@
+import{useEffect as a}from"react";import{useCallbackRef as d}from"./use-callback-ref";export function useEscapeKeydown(s,e=globalThis?.document){const o=d(s);a(()=>{const n=t=>{t.key==="Escape"&&o(t)};return e.addEventListener("keydown",n),()=>{e.removeEventListener("keydown",n)}},[o,e])}

package/dist/use-event.cjs

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useEvent = useEvent;
+var _react = require("react");
+var _useIsomorphicLayoutEffect = require("./use-isomorphic-layout-effect.cjs");
+function useEvent(n) {
+  return s(n, l, !0);
+}
+const l = () => {
+  throw new Error("Cannot call an event handler while rendering.");
+};
+function s(n, r, t) {
+  const e = (0, _react.useRef)(r ?? n);
+  return (0, _useIsomorphicLayoutEffect.useIsomorphicLayoutEffect)(() => {
+    e.current = n;
+  }), (0, _react.useCallback)(t ? (...o) => e.current?.apply(null, o) : () => e.current, []);
+}

package/dist/use-event.d.ts

@@ -0,0 +1,9 @@
+type AnyFunction = (...args: any[]) => any;
+/**
+ * The function returns a memoized event handler.
+ *
+ * @param callback - The event handler to memoize.
+ * @returns A memoized event handler.
+ */
+export declare function useEvent<T extends AnyFunction>(callback?: T): T;
+export {};

package/dist/use-event.mjs

@@ -0,0 +1 @@
+import{useCallback as u,useRef as a}from"react";import{useIsomorphicLayoutEffect as c}from"./use-isomorphic-layout-effect";export function useEvent(n){return s(n,l,!0)}const l=()=>{throw new Error("Cannot call an event handler while rendering.")};function s(n,r,t){const e=a(r??n);return c(()=>{e.current=n}),u(t?(...o)=>e.current?.apply(null,o):()=>e.current,[])}

package/dist/use-hover.cjs

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useHover = void 0;
+var _react = require("react");
+const useHover = () => {
+  const [u, s] = (0, _react.useState)(!1),
+    e = (0, _react.useRef)(null),
+    n = (0, _react.useCallback)(() => {
+      s(!0);
+    }, []),
+    o = (0, _react.useCallback)(() => {
+      s(!1);
+    }, []);
+  return [(0, _react.useCallback)(t => {
+    e.current?.nodeType === Node.ELEMENT_NODE && (e.current.removeEventListener("mouseenter", n), e.current.removeEventListener("mouseleave", o)), t?.nodeType === Node.ELEMENT_NODE && (t.addEventListener("mouseenter", n), t.addEventListener("mouseleave", o)), e.current = t;
+  }, [n, o]), u];
+};
+exports.useHover = useHover;

package/dist/use-hover.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A hook that returns tuple containing a ref and a boolean indicating if the element (referenced by the ref) is being hovered.
+ *
+ * @returns A tuple containing a ref and a boolean indicating if the element is being hovered
+ */
+export declare const useHover: () => [(node: HTMLElement) => void, boolean];

package/dist/use-hover.mjs

@@ -0,0 +1 @@
+import{useCallback as r,useRef as l,useState as E}from"react";export const useHover=()=>{const[u,s]=E(!1),e=l(null),n=r(()=>{s(!0)},[]),o=r(()=>{s(!1)},[]);return[r(t=>{e.current?.nodeType===Node.ELEMENT_NODE&&(e.current.removeEventListener("mouseenter",n),e.current.removeEventListener("mouseleave",o)),t?.nodeType===Node.ELEMENT_NODE&&(t.addEventListener("mouseenter",n),t.addEventListener("mouseleave",o)),e.current=t},[n,o]),u]};

package/dist/use-idle.cjs

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useIdle = void 0;
+var _throttle = require("@stryke/helpers/throttle");
+var _react = require("react");
+const useIdle = (o = 1e3 * 60) => {
+  const [l, n] = (0, _react.useState)(!1);
+  return (0, _react.useEffect)(() => {
+    let t = -1;
+    const i = () => {
+        n(!0);
+      },
+      e = (0, _throttle.throttle)(() => {
+        n(!1), globalThis.clearTimeout(t), t = globalThis.setTimeout(i, o);
+      }, 500),
+      s = () => {
+        document.hidden || e();
+      };
+    return t = globalThis.setTimeout(i, o), globalThis.addEventListener("mousemove", e), globalThis.addEventListener("mousedown", e), window.addEventListener("resize", e), globalThis.addEventListener("keydown", e), globalThis.addEventListener("touchstart", e), window.addEventListener("wheel", e), document.addEventListener("visibilitychange", s), () => {
+      globalThis.removeEventListener("mousemove", e), globalThis.removeEventListener("mousedown", e), window.removeEventListener("resize", e), globalThis.removeEventListener("keydown", e), globalThis.removeEventListener("touchstart", e), window.removeEventListener("wheel", e), document.removeEventListener("visibilitychange", s), globalThis.clearTimeout(t);
+    };
+  }, [o]), l;
+};
+exports.useIdle = useIdle;

package/dist/use-idle.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A hook that returns a boolean indicating if the user is idle.
+ *
+ * @param ms - The number of milliseconds to wait before considering the user as idle
+ * @returns A boolean indicating if the user is idle
+ */
+export declare const useIdle: (ms?: number) => boolean;

package/dist/use-idle.mjs

@@ -0,0 +1 @@
+import{throttle as r}from"@stryke/helpers/throttle";import{useEffect as d,useState as a}from"react";export const useIdle=(o=1e3*60)=>{const[l,n]=a(!1);return d(()=>{let t=-1;const i=()=>{n(!0)},e=r(()=>{n(!1),globalThis.clearTimeout(t),t=globalThis.setTimeout(i,o)},500),s=()=>{document.hidden||e()};return t=globalThis.setTimeout(i,o),globalThis.addEventListener("mousemove",e),globalThis.addEventListener("mousedown",e),window.addEventListener("resize",e),globalThis.addEventListener("keydown",e),globalThis.addEventListener("touchstart",e),window.addEventListener("wheel",e),document.addEventListener("visibilitychange",s),()=>{globalThis.removeEventListener("mousemove",e),globalThis.removeEventListener("mousedown",e),window.removeEventListener("resize",e),globalThis.removeEventListener("keydown",e),globalThis.removeEventListener("touchstart",e),window.removeEventListener("wheel",e),document.removeEventListener("visibilitychange",s),globalThis.clearTimeout(t)}},[o]),l};

package/dist/use-isomorphic-layout-effect.cjs

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useIsomorphicLayoutEffect = void 0;
+var _isRuntimeServer = require("@stryke/helpers/is-runtime-server");
+var _react = require("react");
+const useIsomorphicLayoutEffect = exports.useIsomorphicLayoutEffect = (0, _isRuntimeServer.isRuntimeServer)() ? _react.useEffect : _react.useLayoutEffect;

package/dist/use-isomorphic-layout-effect.d.ts

@@ -0,0 +1,7 @@
+import { useEffect } from "react";
+/**
+ * The function checks if the code is running on the server-side
+ *
+ * @returns An indicator specifying if the code is running on the server-side
+ */
+export declare const useIsomorphicLayoutEffect: typeof useEffect;

package/dist/use-isomorphic-layout-effect.mjs

@@ -0,0 +1 @@
+import{isRuntimeServer as e}from"@stryke/helpers/is-runtime-server";import{useEffect as o,useLayoutEffect as t}from"react";export const useIsomorphicLayoutEffect=e()?o:t;

package/dist/use-keyboard-visible.cjs

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useKeyboardVisible = void 0;
+var _react = require("react");
+var _reactNative = require("react-native");
+const useKeyboardVisible = () => {
+  const [o, e] = (0, _react.useState)(!1);
+  return (0, _react.useEffect)(() => {
+    const i = _reactNative.Keyboard.addListener("keyboardDidShow", () => {
+        e(!0);
+      }),
+      d = _reactNative.Keyboard.addListener("keyboardDidHide", () => {
+        e(!1);
+      });
+    return () => {
+      d.remove(), i.remove();
+    };
+  }, []), o;
+};
+exports.useKeyboardVisible = useKeyboardVisible;

package/dist/use-keyboard-visible.d.ts

@@ -0,0 +1 @@
+export declare const useKeyboardVisible: () => boolean;

package/dist/use-keyboard-visible.mjs

@@ -0,0 +1 @@
+import{useEffect as s,useState as t}from"react";import{Keyboard as r}from"react-native";export const useKeyboardVisible=()=>{const[o,e]=t(!1);return s(()=>{const i=r.addListener("keyboardDidShow",()=>{e(!0)}),d=r.addListener("keyboardDidHide",()=>{e(!1)});return()=>{d.remove(),i.remove()}},[]),o};

package/dist/use-memo-stable.cjs

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useMemoStable = useMemoStable;
+var _react = require("react");
+const i = (t, e) => {
+  if (t.length !== e.length) return !1;
+  for (const [u, r] of t.entries()) if (r !== e[u]) return !1;
+  return !0;
+};
+function useMemoStable(t, e) {
+  const u = (0, _react.useState)(() => ({
+      inputs: e,
+      result: t()
+    }))[0],
+    r = (0, _react.useRef)(!0),
+    n = (0, _react.useRef)(u),
+    s = r.current || !!(e && n.current.inputs && i(e, n.current.inputs)),
+    a = (0, _react.useMemo)(() => s ? n.current : {
+      inputs: e,
+      result: t()
+    }, [e, t, s]);
+  return (0, _react.useEffect)(() => {
+    r.current = !1, n.current = a;
+  }, [a]), a.result;
+}

package/dist/use-memo-stable.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `useMemo` and `useCallback` cache the most recent result. However, this cache can be destroyed by React when it wants to.
+ *
+ * `useMemoStable` and `useCallbackStable` are concurrent mode safe alternatives to `useMemo` and `useCallback` that do provide semantic guarantee. What this means is that you will always get the same reference for a memoized value so long as there is no input change.
+ *
+ * Using `useMemoStable` and `useCallbackStable` will consume more memory than useMemo and `useCallback` in order to provide a stable cache. React can release the cache of `useMemo` and `useCallback`, but `useMemoStable` will not release the cache until it is garbage collected.
+ *
+ * @remarks
+ * You may rely on useMemo as a performance optimization, not as a semantic guarantee. In the future, React may choose to “forget” some previously memoized values and recalculate them on next render, e.g. to free memory for offscreen components. Write your code so that it still works without `useMemo` — and then add it to optimize performance.
+ *
+ * @param getResult - The function used to generate the result
+ * @param inputs - The inputs to watch for changes
+ * @returns The memoized result
+ */
+export declare function useMemoStable<TResult>(getResult: () => TResult, inputs?: any[]): TResult;

package/dist/use-memo-stable.mjs

@@ -0,0 +1 @@
+import{useEffect as o,useMemo as l,useRef as c,useState as f}from"react";const i=(t,e)=>{if(t.length!==e.length)return!1;for(const[u,r]of t.entries())if(r!==e[u])return!1;return!0};export function useMemoStable(t,e){const u=f(()=>({inputs:e,result:t()}))[0],r=c(!0),n=c(u),s=r.current||!!(e&&n.current.inputs&&i(e,n.current.inputs)),a=l(()=>s?n.current:{inputs:e,result:t()},[e,t,s]);return o(()=>{r.current=!1,n.current=a},[a]),a.result}

package/dist/use-network-state.cjs

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useNetworkState = useNetworkState;
+exports.useNetworkStateSubscribe = void 0;
+var _isEqual = require("@stryke/types/type-checks/is-equal");
+var _react = require("react");
+const i = () => navigator["connection"] || navigator["mozConnection"] || navigator["webkitConnection"];
+const useNetworkStateSubscribe = e => {
+  globalThis.addEventListener("online", e, {
+    passive: !0
+  }), globalThis.addEventListener("offline", e, {
+    passive: !0
+  });
+  const t = i();
+  return t && t.addEventListener("change", e, {
+    passive: !0
+  }), () => {
+    globalThis.removeEventListener("online", e), globalThis.removeEventListener("offline", e), t && t.removeEventListener("change", e);
+  };
+};
+exports.useNetworkStateSubscribe = useNetworkStateSubscribe;
+const f = () => {
+  throw new Error("useNetworkState is a client-only hook");
+};
+function useNetworkState() {
+  const e = (0, _react.useRef)({});
+  return (0, _react.useSyncExternalStore)(useNetworkStateSubscribe, () => {
+    const r = navigator.onLine,
+      n = i(),
+      o = {
+        online: r,
+        downlink: n?.downlink,
+        downlinkMax: n?.downlinkMax,
+        effectiveType: n?.effectiveType,
+        rtt: n?.rtt,
+        saveData: n?.saveData,
+        type: n?.type
+      };
+    return (0, _isEqual.isEqual)(e.current, o) ? e.current : (e.current = o, o);
+  }, f);
+}

package/dist/use-network-state.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Subscribes to network state changes.
+ *
+ * @param callback - The callback function to call when the network state changes
+ * @returns A function to unsubscribe from the network state changes
+ */
+export declare const useNetworkStateSubscribe: (callback: (event: Event) => any) => () => void;
+/**
+ * A hook that returns the network state.
+ *
+ * @returns The network state
+ */
+export declare function useNetworkState(): NetworkState;

package/dist/use-network-state.mjs

@@ -0,0 +1 @@
+import{isEqual as a}from"@stryke/types/type-checks/is-equal";import{useRef as s,useSyncExternalStore as c}from"react";const i=()=>navigator["connection"]||navigator["mozConnection"]||navigator["webkitConnection"];export const useNetworkStateSubscribe=e=>{globalThis.addEventListener("online",e,{passive:!0}),globalThis.addEventListener("offline",e,{passive:!0});const t=i();return t&&t.addEventListener("change",e,{passive:!0}),()=>{globalThis.removeEventListener("online",e),globalThis.removeEventListener("offline",e),t&&t.removeEventListener("change",e)}};const f=()=>{throw new Error("useNetworkState is a client-only hook")};export function useNetworkState(){const e=s({});return c(useNetworkStateSubscribe,()=>{const r=navigator.onLine,n=i(),o={online:r,downlink:n?.downlink,downlinkMax:n?.downlinkMax,effectiveType:n?.effectiveType,rtt:n?.rtt,saveData:n?.saveData,type:n?.type};return a(e.current,o)?e.current:(e.current=o,o)},f)}

package/dist/use-previous.cjs

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.usePrevious = usePrevious;
+var _react = require("react");
+function usePrevious(r) {
+  const e = (0, _react.useRef)({
+    value: r,
+    previous: r
+  });
+  return (0, _react.useMemo)(() => (e.current.value !== r && (e.current.previous = e.current.value, e.current.value = r), e.current.previous), [r]);
+}

package/dist/use-previous.d.ts

@@ -0,0 +1 @@
+export declare function usePrevious<T>(value: T): T;

package/dist/use-previous.mjs

@@ -0,0 +1 @@
+import{useMemo as u,useRef as t}from"react";export function usePrevious(r){const e=t({value:r,previous:r});return u(()=>(e.current.value!==r&&(e.current.previous=e.current.value,e.current.value=r),e.current.previous),[r])}