use-good-hooks 1.0.38 → 1.0.39

package/README.md

@@ -262,7 +262,6 @@ const TextEditor = () => {
     - `paused`: Boolean indicating if the history is paused
     - `redo`: Function to move to the next state (redo)
     - `set`: Function to update the state and record history
-    - `setDirect`: Function to update the state without recording history
     - `state`: The current state value
     - `undo`: Function to move to the previous state (undo)
 

package/dist/use-history-state.js

@@ -1,164 +1,155 @@
-import { useRef as M, useReducer as T, useCallback as d } from "react";
-import H from "lodash/cloneDeep";
-import J from "lodash/isNil";
-import E from "lodash/size";
-import k from "./use-debounce-fn.js";
-const q = {
+import { useRef as k, useReducer as I, useCallback as l, useEffect as K } from "react";
+import Q from "lodash/cloneDeep";
+import W from "lodash/isNil";
+import o from "lodash/size";
+import X from "./use-debounce-fn.js";
+const Y = {
   future: [],
   past: [],
   present: null
-}, l = (e, r) => r ? e : H(e), v = (e, r, y) => y ? e === r : JSON.stringify(e) === JSON.stringify(r), z = ({
-  action: e,
-  immutable: r,
-  maxCapacity: y,
-  onChange: t,
-  state: f
-}) => {
-  const { future: o, past: n, paused: S, present: p } = f;
-  if (e.type === "CLEAR") {
-    const s = {
-      future: [],
-      past: [],
-      paused: S,
-      present: l(e.initialState, r)
-    };
-    return t == null || t({
-      action: e.type,
-      state: s.present
-    }), s;
-  } else {
-    if (e.type === "PAUSE")
-      return {
-        ...f,
-        paused: !0
-      };
-    if (e.type === "REDO") {
-      if (E(o) === 0)
-        return f;
-      const s = o[0], c = {
-        future: o.slice(1),
-        past: [...n, l(p, r)],
-        paused: S,
-        present: l(s, r)
-      };
-      return t == null || t({
-        action: e.type,
-        state: c.present
-      }), c;
-    } else {
-      if (e.type === "RESUME")
-        return {
-          ...f,
-          paused: !1
-        };
-      if (e.type === "REPLACE") {
-        const { newPresent: s } = e, u = {
-          ...f,
+}, c = (f, p) => p ? f : Q(f), Z = (f, p, S) => S ? f === p : JSON.stringify(f) === JSON.stringify(p), ee = (f, p) => {
+  const { maxCapacity: S, debounceMs: D, debounceSettings: q, onChange: U, immutable: n } = p || {}, b = k(f), e = k(U), [E, i] = I(
+    (t, r) => {
+      var L, x, F, M, T, H;
+      const { future: w, past: y, paused: d, present: m } = t;
+      if (r.type === "CLEAR") {
+        const u = {
           future: [],
           past: [],
-          present: s
+          paused: d,
+          present: c(r.initialState, n)
         };
-        return t == null || t({
-          action: e.type,
+        return (L = e.current) == null || L.call(e, {
+          action: r.type,
           state: u.present
         }), u;
-      } else if (e.type === "SET") {
-        const { newPresent: s } = e;
-        if (v(s, p, r))
-          return f;
-        if (S) {
-          const w = {
-            ...f,
-            present: l(s, r)
+      } else {
+        if (r.type === "PAUSE")
+          return {
+            ...t,
+            paused: !0
+          };
+        if (r.type === "REDO") {
+          if (o(w) === 0)
+            return t;
+          const u = w[0], a = {
+            future: w.slice(1),
+            past: [...y, c(m, n)],
+            paused: d,
+            present: c(u, n)
           };
-          return t == null || t({
-            action: e.type,
-            state: w.present
-          }), w;
+          return (x = e.current) == null || x.call(e, {
+            action: r.type,
+            state: a.present
+          }), a;
+        } else {
+          if (r.type === "RESUME")
+            return {
+              ...t,
+              paused: !1
+            };
+          if (r.type === "REPLACE") {
+            const { newPresent: u } = r, s = {
+              ...t,
+              future: [],
+              past: [],
+              present: u
+            };
+            return (F = e.current) == null || F.call(e, {
+              action: r.type,
+              state: s.present
+            }), s;
+          } else if (r.type === "SET") {
+            const { newPresent: u } = r;
+            if (Z(u, m, n))
+              return t;
+            if (d) {
+              const J = {
+                ...t,
+                present: c(u, n)
+              };
+              return (M = e.current) == null || M.call(e, {
+                action: r.type,
+                state: J.present
+              }), J;
+            }
+            let s = [...y];
+            m !== null && (s = [...s, c(m, n)]), !W(S) && S > 0 && o(s) > S && (s = s.slice(o(s) - S));
+            const a = {
+              future: [],
+              past: s,
+              paused: d,
+              present: c(u, n)
+            };
+            return (T = e.current) == null || T.call(e, {
+              action: r.type,
+              state: a.present
+            }), a;
+          } else if (r.type === "UNDO") {
+            if (o(y) === 0)
+              return t;
+            const u = y[o(y) - 1], s = y.slice(0, o(y) - 1), a = {
+              future: [c(m, n), ...w],
+              past: s,
+              paused: d,
+              present: c(u, n)
+            };
+            return (H = e.current) == null || H.call(e, {
+              action: r.type,
+              state: a.present
+            }), a;
+          } else
+            throw new Error("Unsupported action type");
         }
-        let u = [...n];
-        p !== null && (u = [...u, l(p, r)]), !J(y) && y > 0 && E(u) > y && (u = u.slice(E(u) - y));
-        const c = {
-          future: [],
-          past: u,
-          paused: S,
-          present: l(s, r)
-        };
-        return t == null || t({
-          action: e.type,
-          state: c.present
-        }), c;
-      } else if (e.type === "UNDO") {
-        if (E(n) === 0)
-          return f;
-        const s = n[E(n) - 1], u = n.slice(0, E(n) - 1), c = {
-          future: [l(p, r), ...o],
-          past: u,
-          paused: S,
-          present: l(s, r)
-        };
-        return t == null || t({
-          action: e.type,
-          state: c.present
-        }), c;
-      } else
-        throw new Error("Unsupported action type");
-    }
-  }
-}, G = (e, r) => {
-  const { maxCapacity: y, debounceMs: t, debounceSettings: f, onChange: o, immutable: n } = r || {}, S = M(e), [p, s] = T(
-    (i, F) => z({
-      action: F,
-      immutable: n,
-      maxCapacity: y,
-      onChange: o,
-      state: i
-    }),
+      }
+    },
     {
-      ...q,
-      paused: (r == null ? void 0 : r.paused) ?? !1,
-      present: l(S.current, n)
+      ...Y,
+      paused: (p == null ? void 0 : p.paused) ?? !1,
+      present: c(b.current, n)
     }
-  ), u = E(p.future) !== 0, c = E(p.past) !== 0, w = d(() => s({
-    initialState: S.current,
+  ), P = o(E.future) !== 0, A = o(E.past) !== 0, v = l(() => i({
+    initialState: b.current,
     type: "CLEAR"
-  }), []), U = d(() => {
-    s({ type: "PAUSE" });
-  }, []), P = d(() => {
-    u && s({ type: "REDO" });
-  }, [u]), A = d((i) => {
-    s({ type: "REPLACE", newPresent: i });
-  }, []), O = d(() => {
-    s({ type: "RESUME" });
-  }, []), D = k(
-    (i) => s({ type: "SET", newPresent: i }),
-    t,
-    f
-  ), R = d((i) => s({ type: "SET", newPresent: i }), []), N = d(
-    (i) => {
-      t ? D(i) : R(i);
+  }), []), z = l(() => {
+    i({ type: "PAUSE" });
+  }, []), R = l(() => {
+    P && i({ type: "REDO" });
+  }, [P]), V = l((t) => {
+    i({ type: "REPLACE", newPresent: t });
+  }, []), j = l(() => {
+    i({ type: "RESUME" });
+  }, []), N = X(
+    (t) => i({ type: "SET", newPresent: t }),
+    D,
+    q
+  ), O = l((t) => i({ type: "SET", newPresent: t }), []), B = l(
+    (t) => {
+      D ? N(t) : O(t);
     },
-    [t, D, R]
-  ), L = d(() => {
-    c && s({ type: "UNDO" });
-  }, [c]);
-  return {
-    canRedo: u,
-    canUndo: c,
-    clear: w,
-    future: p.future,
-    past: p.past,
-    pause: U,
-    paused: p.paused,
-    redo: P,
-    replace: A,
-    resume: O,
-    set: N,
-    setDirect: R,
-    state: p.present,
-    undo: L
+    [D, N, O]
+  ), G = l(() => {
+    A && i({ type: "UNDO" });
+  }, [A]);
+  return K(() => {
+    e.current = U;
+  }, [U]), {
+    canRedo: P,
+    canUndo: A,
+    clear: v,
+    future: E.future,
+    past: E.past,
+    pause: z,
+    paused: E.paused,
+    redo: R,
+    replace: V,
+    resume: j,
+    set: B,
+    setDirect: O,
+    state: E.present,
+    undo: G
   };
 };
 export {
-  G as default
+  ee as default
 };

package/package.json

@@ -50,5 +50,5 @@
 		"test:coverage": "vitest --coverage --run",
 		"test:watch": "vitest"
 	},
-	"version": "1.0.38"
+	"version": "1.0.39"
 }