use-good-hooks 1.0.41 → 1.0.42

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)

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/package.json

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