use-good-hooks 1.0.40 → 1.0.42

package/README.md

@@ -230,7 +230,7 @@ const TextEditor = () => {
         <button onClick={actions.redo} disabled={!state.canRedo}>
           Redo
         </button>
-        <button onClick={actions.clear}>Clear History</button>
+        <button onClick={actions.initial}>Initial State</button>
       </div>
       <p>Past states: {state.past.length}</p>
       <p>Future states: {state.future.length}</p>
@@ -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)
@@ -256,7 +255,7 @@ Returns a tuple `[historyState, historyActions]`:
 
 **historyState** (Object): - `canRedo`: Boolean indicating if redo is possible - `canUndo`: Boolean indicating if undo is possible - `future`: Array of future states (for redo) - `past`: Array of past states (for undo) - `paused`: Boolean indicating if the history is paused - `present`: The current state value
 
-**historyActions** (Object): - `clear`: Function to clear the history and reset to initial state - `pause`: Function to pause history tracking (updates won't be recorded) - `redo`: Function to move to the next state (redo) - `replace`: Function to replace the state without adding to history - `resume`: Function to resume history tracking - `set`: Function to update the state and record history (debounced by default) - `setDirect`: Function to update the state immediately, bypassing debounce - `undo`: Function to move to the previous state (undo)
+**historyActions** (Object): - `initial`: Function to reset to initial state - `pause`: Function to pause history tracking (updates won't be recorded) - `redo`: Function to move to the next state (redo) - `replace`: Function to replace the state without adding to history - `resume`: Function to resume history tracking - `set`: Function to update the state and record history (debounced by default) - `setDirect`: Function to update the state immediately, bypassing debounce - `undo`: Function to move to the previous state (undo)
 
 #### Example with onChange callback
 
@@ -265,7 +264,7 @@ const Editor = () => {
   const [state, actions] = useHistoryState('', {
     onChange: ({ action, state }) => {
       console.log(`Action: ${action}, State: ${state}`);
-      // Action can be: 'SET', 'UNDO', 'REDO', 'CLEAR', 'REPLACE'
+      // Action can be: 'SET', 'UNDO', 'REDO', 'INITIAL', 'REPLACE'
     }
   });
 

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

@@ -3,7 +3,7 @@ import { DebounceSettings } from 'lodash';
 export { DebounceSettings }
 
 export declare type HistoryAction<T> = {
-    type: 'CLEAR';
+    type: 'INITIAL';
     initialState: T;
 } | {
     type: 'PAUSE';
@@ -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;
@@ -50,7 +49,7 @@ declare const useHistoryState: <T>(initialState: T, options?: HistoryOptions<T>)
     paused: boolean;
     present: T;
 }, {
-    clear: () => void;
+    initial: () => void;
     pause: () => void;
     redo: () => void;
     replace: (newPresent: T) => void;

package/dist/use-history-state.js

@@ -1,27 +1,24 @@
-import { useRef as A, useReducer as O, useMemo as D, useEffect as b } from "react";
+import { useRef as U, useReducer as I, useMemo as A, useEffect as T } from "react";
 import h from "lodash/cloneDeep";
-import g from "lodash/debounce";
-import i from "lodash/size";
+import b from "lodash/isEqual";
+import C from "lodash/debounce";
+import o from "lodash/size";
 const L = {
   future: [],
   past: [],
   present: null
-}, c = (f, p) => p ? f : h(f), M = (f, p, w) => w ? f === p : JSON.stringify(f) === JSON.stringify(p), H = (f, p) => {
-  const w = A(f), E = A(p ?? {}), [l, a] = O(
+}, 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
-      } = E.current, { future: R, past: y, paused: d, present: m } = n;
-      if (e.type === "CLEAR") {
+      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: d,
-          present: c(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 L = {
             paused: !0
           };
         if (e.type === "REDO") {
-          if (i(R) === 0)
+          if (o(m) === 0)
             return n;
-          const s = R[0], o = {
-            future: R.slice(1),
-            past: [...y, c(m, u)],
-            paused: d,
-            present: c(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,55 +48,55 @@ const L = {
               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 (M(s, m, u))
+            if (M(s, E))
               return n;
-            if (d) {
-              const U = {
+            if (S) {
+              const R = {
                 ...n,
-                present: c(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, c(m, u)]), r > 0 && i(t) > r && (t = t.slice(i(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: d,
-              present: c(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 (i(y) === 0)
+            if (o(i) === 0)
               return n;
-            const s = y[i(y) - 1], t = y.slice(0, i(y) - 1), o = {
-              future: [c(m, u), ...R],
-              past: t,
-              paused: d,
-              present: c(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");
         }
@@ -107,59 +104,56 @@ const L = {
     },
     {
       ...L,
-      paused: E.current.paused ?? !1,
-      present: c(
-        w.current,
-        E.current.immutable
-      )
+      paused: d.current.paused ?? !1,
+      present: p(w.current)
     }
-  ), P = D(() => ({
-    canRedo: i(l.future) !== 0,
-    canUndo: i(l.past) !== 0,
-    future: l.future,
-    past: l.past,
-    paused: l.paused,
-    present: l.present
-  }), [l]), C = D(() => {
-    const { debounceMs: n = 250, debounceSettings: e } = E.current, u = g(
-      (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 {
-      clear: () => {
-        a({
-          type: "CLEAR",
+      initial: () => {
+        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 b(() => {
-    p && (E.current = p);
-  }, [p]), [P, C];
+  return T(() => {
+    f && (d.current = f);
+  }, [f]), [D, P];
 };
 export {
-  H as default
+  v as default
 };

package/package.json

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