use-good-hooks 1.0.41 → 1.0.43

package/README.md

@@ -245,7 +245,6 @@ const TextEditor = () => {
 - `options`: (Optional) Configuration options:
     - `debounceMs`: Time in milliseconds to debounce the state changes (default: 250)
     - `debounceSettings`: Debounce settings object from Lodash
-    - `immutable`: Boolean indicating if the state should be treated as immutable (default: true)
     - `maxCapacity`: Maximum number of history entries to keep (default: 10)
     - `onChange`: Function to call when the state changes, receives `{ action, state }`
     - `paused`: Boolean indicating if the history is paused (default: false)
@@ -609,6 +608,28 @@ const DelayedComponent = () => {
 - `setLate`: A function to update the state after the specified delay. It can also accept a second boolean argument to update the state immediately.
 - `cancel`: A function to cancel a pending state update.
 
+### `useUnmount`
+
+Runs a callback when the component unmounts for real. React's Strict Mode simulates an unmount right after mount (cleanup, then setup again on the same instance); a plain `useEffect` cleanup fires there too, which aborts in-flight requests or tears down subscriptions that the remount never rebuilds. `useUnmount` defers the callback by one microtask and cancels it if the effect is set up again, so only the real unmount reaches it. The latest callback is always the one called.
+
+```typescript
+import useUnmount from 'use-good-hooks/use-unmount';
+
+const Subscriber = ({ channel }) => {
+  const controller = useRef(new AbortController());
+
+  useUnmount(() => {
+    controller.current.abort();
+  });
+
+  return <p>Listening to {channel}</p>;
+};
+```
+
+#### Parameters
+
+- `fn`: The callback to run on unmount. It is called once, one microtask after the real unmount, and never on a Strict Mode remount.
+
 ## 🧪 Running Tests
 
 This library is thoroughly tested with Vitest and React Testing Library. To run the tests:

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

@@ -29,7 +29,6 @@ declare type HistoryOnChange<T> = ({ action, state }: {
 export declare type HistoryOptions<T> = {
     debounceMs?: number;
     debounceSettings?: DebounceSettings;
-    immutable?: boolean;
     maxCapacity?: number;
     onChange?: HistoryOnChange<T>;
     paused?: boolean;

package/dist/use-history-state.js

@@ -1,27 +1,24 @@
-import { useRef as A, useReducer as N, useMemo as D, useEffect as O } from "react";
-import T from "lodash/cloneDeep";
-import b from "lodash/debounce";
-import c from "lodash/size";
-const h = {
+import { useRef as U, useReducer as I, useMemo as A, useEffect as T } from "react";
+import h from "lodash/cloneDeep";
+import b from "lodash/isEqual";
+import C from "lodash/debounce";
+import o from "lodash/size";
+const L = {
   future: [],
   past: [],
   present: null
-}, i = (f, p) => p ? f : T(f), g = (f, p, w) => w ? f === p : JSON.stringify(f) === JSON.stringify(p), F = (f, p) => {
-  const w = A(f), d = A(p ?? {}), [l, a] = N(
+}, p = (l) => h(l), M = (l, f) => b(l, f), v = (l, f) => {
+  const w = U(l), d = U(f ?? {}), [c, u] = I(
     (n, e) => {
-      const {
-        immutable: u = !0,
-        maxCapacity: r = 10,
-        onChange: S = () => null
-      } = d.current, { future: R, past: y, paused: E, present: m } = n;
+      const { maxCapacity: y = 10, onChange: t = () => null } = d.current, { future: m, past: i, paused: S, present: E } = n;
       if (e.type === "INITIAL") {
         const s = {
           future: [],
           past: [],
-          paused: E,
-          present: i(e.initialState, u)
+          paused: S,
+          present: p(e.initialState)
         };
-        return S({
+        return t({
           action: e.type,
           state: s.present
         }), s;
@@ -32,18 +29,18 @@ const h = {
             paused: !0
           };
         if (e.type === "REDO") {
-          if (c(R) === 0)
+          if (o(m) === 0)
             return n;
-          const s = R[0], o = {
-            future: R.slice(1),
-            past: [...y, i(m, u)],
-            paused: E,
-            present: i(s, u)
+          const s = m[0], a = {
+            future: m.slice(1),
+            past: [...i, p(E)],
+            paused: S,
+            present: p(s)
           };
-          return S({
+          return t({
             action: e.type,
-            state: o.present
-          }), o;
+            state: a.present
+          }), a;
         } else {
           if (e.type === "RESUME")
             return {
@@ -51,115 +48,112 @@ const h = {
               paused: !1
             };
           if (e.type === "REPLACE") {
-            const { newPresent: s } = e, t = {
+            const { newPresent: s } = e, r = {
               ...n,
               future: [],
               past: [],
               present: s
             };
-            return S({
+            return t({
               action: e.type,
-              state: t.present
-            }), t;
+              state: r.present
+            }), r;
           } else if (e.type === "SET") {
             const { newPresent: s } = e;
-            if (g(s, m, u))
+            if (M(s, E))
               return n;
-            if (E) {
-              const U = {
+            if (S) {
+              const R = {
                 ...n,
-                present: i(s, u)
+                present: p(s)
               };
-              return S({
+              return t({
                 action: e.type,
-                state: U.present
-              }), U;
+                state: R.present
+              }), R;
             }
-            let t = [...y];
-            m !== null && (t = [...t, i(m, u)]), r > 0 && c(t) > r && (t = t.slice(c(t) - r));
-            const o = {
+            let r = [...i];
+            E !== null && (r = [...r, p(E)]), y > 0 && o(r) > y && (r = r.slice(o(r) - y));
+            const a = {
               future: [],
-              past: t,
-              paused: E,
-              present: i(s, u)
+              past: r,
+              paused: S,
+              present: p(s)
             };
-            return S({
+            return t({
               action: e.type,
-              state: o.present
-            }), o;
+              state: a.present
+            }), a;
           } else if (e.type === "UNDO") {
-            if (c(y) === 0)
+            if (o(i) === 0)
               return n;
-            const s = y[c(y) - 1], t = y.slice(0, c(y) - 1), o = {
-              future: [i(m, u), ...R],
-              past: t,
-              paused: E,
-              present: i(s, u)
+            const s = i[o(i) - 1], r = i.slice(0, o(i) - 1), a = {
+              future: [p(E), ...m],
+              past: r,
+              paused: S,
+              present: p(s)
             };
-            return S({
+            return t({
               action: e.type,
-              state: o.present
-            }), o;
+              state: a.present
+            }), a;
           } else
             throw new Error("Unsupported action type");
         }
       }
     },
     {
-      ...h,
+      ...L,
       paused: d.current.paused ?? !1,
-      present: i(
-        w.current,
-        d.current.immutable
-      )
+      present: p(w.current)
     }
-  ), P = D(() => ({
-    canRedo: c(l.future) !== 0,
-    canUndo: c(l.past) !== 0,
-    future: l.future,
-    past: l.past,
-    paused: l.paused,
-    present: l.present
-  }), [l]), I = D(() => {
-    const { debounceMs: n = 250, debounceSettings: e } = d.current, u = b(
-      (r) => a({ type: "SET", newPresent: r }),
+  ), D = A(() => ({
+    canRedo: o(c.future) !== 0,
+    canUndo: o(c.past) !== 0,
+    future: c.future,
+    past: c.past,
+    paused: c.paused,
+    present: c.present
+  }), [c]), P = A(() => {
+    const { debounceMs: n = 250, debounceSettings: e } = d.current, y = C(
+      (t) => u({ type: "SET", newPresent: t }),
       n,
       e
     );
     return {
       initial: () => {
-        a({
+        u({
           type: "INITIAL",
           initialState: w.current
         });
       },
       pause: () => {
-        a({ type: "PAUSE" });
+        u({ type: "PAUSE" });
       },
       redo: () => {
-        a({ type: "REDO" });
+        u({ type: "REDO" });
       },
-      replace: (r) => {
-        a({ type: "REPLACE", newPresent: r });
+      replace: (t) => {
+        u({ type: "REPLACE", newPresent: t });
       },
       resume: () => {
-        a({ type: "RESUME" });
+        u({ type: "RESUME" });
       },
-      set: (r) => {
-        n ? u(r) : a({ type: "SET", newPresent: r });
+      set: (t) => {
+        n ? y(t) : u({ type: "SET", newPresent: t });
       },
-      setDirect: (r) => {
-        a({ type: "SET", newPresent: r });
+      setDirect: (t) => {
+        u({ type: "SET", newPresent: t });
       },
       undo: () => {
-        a({ type: "UNDO" });
+        u({ type: "UNDO" });
       }
     };
   }, []);
-  return O(() => {
-    p && (d.current = p);
-  }, [p]), [P, I];
+  return T(() => {
+    f && (d.current = f);
+  }, [f]), [D, P];
 };
 export {
-  F as default
+  v as default
 };

package/dist/use-unmount.d.ts

@@ -0,0 +1,4 @@
+declare const useUnmount: (fn: () => void) => void;
+export default useUnmount;
+
+export { }

package/dist/use-unmount.js

@@ -0,0 +1,14 @@
+import { useRef as u, useEffect as n } from "react";
+const s = (e) => {
+  const t = u(e), r = u(!1);
+  n(() => {
+    t.current = e;
+  }, [e]), n(() => (r.current = !1, () => {
+    r.current = !0, queueMicrotask(() => {
+      r.current && t.current();
+    });
+  }), []);
+};
+export {
+  s as default
+};

package/package.json

@@ -50,5 +50,5 @@
 		"test:coverage": "vitest --coverage --run",
 		"test:watch": "vitest"
 	},
-	"version": "1.0.41"
+	"version": "1.0.43"
 }