use-good-hooks 1.0.33 → 1.0.34

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

@@ -9,6 +9,9 @@ declare type HistoryAction<T> = {
     type: 'PAUSE';
 } | {
     type: 'REDO';
+} | {
+    type: 'REPLACE';
+    newPresent: T;
 } | {
     type: 'RESUME';
 } | {
@@ -48,6 +51,7 @@ declare const useHistoryState: <T>(initialState: T, options?: UseHistoryOptionsS
     pause: () => void;
     paused: boolean;
     redo: () => void;
+    replace: (newPresent: T) => void;
     resume: () => void;
     set: (newPresent: T) => void;
     setDirect: (newPresent: T) => void;

package/dist/use-history-state.js

@@ -1,130 +1,147 @@
-import { useRef as T, useReducer as F, useCallback as o } from "react";
-import H from "lodash/cloneDeep";
-import J from "lodash/isNil";
-import d from "lodash/size";
-import L from "./use-debounce-fn.js";
-const M = {
+import { useRef as F, useReducer as H, useCallback as d } from "react";
+import J from "lodash/cloneDeep";
+import M from "lodash/isNil";
+import E from "lodash/size";
+import k from "./use-debounce-fn.js";
+const q = {
   future: [],
   past: [],
   present: null
-}, i = (e, t) => t ? e : H(e), k = (e, t, l) => l ? e === t : JSON.stringify(e) === JSON.stringify(t), q = ({
+}, l = (e, r) => r ? e : J(e), v = (e, r, y) => y ? e === r : JSON.stringify(e) === JSON.stringify(r), z = ({
   action: e,
-  immutable: t,
-  maxCapacity: l,
-  onChange: s,
+  immutable: r,
+  maxCapacity: y,
+  onChange: t,
   state: f
 }) => {
-  const { future: E, past: n, paused: y, present: p } = f;
-  if (e.type === "PAUSE")
-    return {
-      ...f,
-      paused: !0
-    };
-  if (e.type === "RESUME")
-    return {
-      ...f,
-      paused: !1
-    };
-  if (e.type === "UNDO") {
-    if (d(n) === 0)
-      return f;
-    const r = n[d(n) - 1], u = n.slice(0, d(n) - 1), c = {
-      future: [i(p, t), ...E],
-      past: u,
-      paused: y,
-      present: i(r, t)
-    };
-    return s == null || s({
-      action: e.type,
-      state: c.present
-    }), c;
-  } else if (e.type === "REDO") {
-    if (d(E) === 0)
-      return f;
-    const r = E[0], c = {
-      future: E.slice(1),
-      past: [...n, i(p, t)],
-      paused: y,
-      present: i(r, t)
+  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 s == null || s({
+    return t == null || t({
       action: e.type,
-      state: c.present
-    }), c;
-  } else if (e.type === "SET") {
-    const { newPresent: r } = e;
-    if (k(r, p, t))
-      return f;
-    if (y) {
-      const w = {
+      state: s.present
+    }), s;
+  } else {
+    if (e.type === "PAUSE")
+      return {
         ...f,
-        present: i(r, t)
+        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 s == null || s({
+      return t == null || t({
         action: e.type,
-        state: w.present
-      }), w;
+        state: c.present
+      }), c;
+    } else {
+      if (e.type === "RESUME")
+        return {
+          ...f,
+          paused: !1
+        };
+      if (e.type === "REPLACE") {
+        const { newPresent: s } = e, u = {
+          ...f,
+          future: [],
+          past: [],
+          present: s
+        };
+        return t == null || t({
+          action: e.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)
+          };
+          return t == null || t({
+            action: e.type,
+            state: w.present
+          }), w;
+        }
+        let u = [...n];
+        p !== null && (u = [...u, l(p, r)]), !M(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");
     }
-    let u = [...n];
-    p !== null && (u = [...u, i(p, t)]), !J(l) && l > 0 && d(u) > l && (u = u.slice(d(u) - l));
-    const c = {
-      future: [],
-      past: u,
-      paused: y,
-      present: i(r, t)
-    };
-    return s == null || s({
-      action: e.type,
-      state: c.present
-    }), c;
-  } else if (e.type === "CLEAR") {
-    const r = {
-      future: [],
-      past: [],
-      paused: y,
-      present: i(e.initialState, t)
-    };
-    return s == null || s({
-      action: e.type,
-      state: r.present
-    }), r;
-  } else
-    throw new Error("Unsupported action type");
-}, B = (e, t) => {
-  const { maxCapacity: l, debounceTime: s, debounceSettings: f, onChange: E, immutable: n } = t || {}, y = T(e), [p, r] = F(
-    (S, P) => q({
-      action: P,
+  }
+}, G = (e, r) => {
+  const { maxCapacity: y, debounceTime: t, debounceSettings: f, onChange: o, immutable: n } = r || {}, S = F(e), [p, s] = H(
+    (i, T) => z({
+      action: T,
       immutable: n,
-      maxCapacity: l,
-      onChange: E,
-      state: S
+      maxCapacity: y,
+      onChange: o,
+      state: i
     }),
     {
-      ...M,
-      paused: (t == null ? void 0 : t.paused) ?? !1,
-      present: i(y.current, n)
+      ...q,
+      paused: (r == null ? void 0 : r.paused) ?? !1,
+      present: l(S.current, n)
     }
-  ), u = d(p.future) !== 0, c = d(p.past) !== 0, w = o(() => r({
-    initialState: y.current,
+  ), u = E(p.future) !== 0, c = E(p.past) !== 0, w = d(() => s({
+    initialState: S.current,
     type: "CLEAR"
-  }), []), U = o(() => {
-    r({ type: "PAUSE" });
-  }, []), O = o(() => {
-    r({ type: "RESUME" });
-  }, []), N = o(() => {
-    u && r({ type: "REDO" });
-  }, [u]), D = L(
-    (S) => r({ type: "SET", newPresent: S }),
-    s,
+  }), []), 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 = o((S) => r({ type: "SET", newPresent: S }), []), a = o(() => {
-    c && r({ type: "UNDO" });
-  }, [c]), A = o(
-    (S) => {
-      s ? D(S) : R(S);
+  ), R = d((i) => s({ type: "SET", newPresent: i }), []), N = d(
+    (i) => {
+      t ? D(i) : R(i);
     },
-    [s, D, R]
-  );
+    [t, D, R]
+  ), L = d(() => {
+    c && s({ type: "UNDO" });
+  }, [c]);
   return {
     canRedo: u,
     canUndo: c,
@@ -133,14 +150,15 @@ const M = {
     past: p.past,
     pause: U,
     paused: p.paused,
-    redo: N,
+    redo: P,
+    replace: A,
     resume: O,
-    set: A,
+    set: N,
     setDirect: R,
     state: p.present,
-    undo: a
+    undo: L
   };
 };
 export {
-  B as default
+  G as default
 };

package/package.json

@@ -50,5 +50,5 @@
 		"test:coverage": "vitest --coverage --run",
 		"test:watch": "vitest"
 	},
-	"version": "1.0.33"
+	"version": "1.0.34"
 }