use-good-hooks 1.0.32 → 1.0.34

package/README.md

@@ -243,16 +243,26 @@ const TextEditor = () => {
 
 - `initialState`: The initial state value
 - `options`: (Optional) Configuration options:
-    - `capacity`: Maximum number of history entries to keep (default: 10)
+    - `debounceSettings`: Debounce settings object (default: { leading: true, trailing: false })
+    - `debounceTime`: Time in milliseconds to debounce the state changes (default: 0)
+    - `immutable`: Boolean indicating if the state should be treated as immutable (default: false)
+    - `maxCapacity`: Maximum number of history entries to keep (default: 10)
+    - `onChange`: Function to call when the state changes
+    - `paused`: Boolean indicating if the history is paused (default: false)
 
 #### Returns
 
 - Object with:
     - `canRedo`: Boolean indicating if redo is possible
     - `canUndo`: Boolean indicating if undo is possible
-    - `history`: Array of all recorded states
+    - `clear`: Function to clear the history
+    - `future`: Array of future states
+    - `past`: Array of past states
+    - `pause`: Function to pause the history
+    - `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.d.ts

@@ -4,11 +4,14 @@ export { DebounceSettings }
 
 declare type HistoryAction<T> = {
     type: 'CLEAR';
-    initialPresent: T;
+    initialState: T;
 } | {
     type: 'PAUSE';
 } | {
     type: 'REDO';
+} | {
+    type: 'REPLACE';
+    newPresent: T;
 } | {
     type: 'RESUME';
 } | {
@@ -36,9 +39,10 @@ declare type UseHistoryOptionsState<T> = {
     immutable?: boolean;
     maxCapacity?: number;
     onChange?: HistoryOnChange<T>;
+    paused?: boolean;
 };
 
-declare const useHistoryState: <T>(initialPresent: T, options?: UseHistoryOptionsState<T>) => {
+declare const useHistoryState: <T>(initialState: T, options?: UseHistoryOptionsState<T>) => {
     canRedo: boolean;
     canUndo: boolean;
     clear: () => void;
@@ -47,6 +51,7 @@ declare const useHistoryState: <T>(initialPresent: T, options?: UseHistoryOption
     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,146 +1,164 @@
-import { useRef as F, useReducer as H, useCallback as S } from "react";
+import { useRef as F, useReducer as H, useCallback as d } from "react";
 import J from "lodash/cloneDeep";
-import L from "lodash/isNil";
-import d from "lodash/size";
-import M from "./use-debounce-fn.js";
-const k = {
+import M from "lodash/isNil";
+import E from "lodash/size";
+import k from "./use-debounce-fn.js";
+const q = {
   future: [],
   past: [],
-  paused: !1,
   present: null
-}, i = (e, r) => r ? e : J(e), q = (e, r, o) => o ? e === r : JSON.stringify(e) === JSON.stringify(r), v = ({
+}, l = (e, r) => r ? e : J(e), v = (e, r, y) => y ? e === r : JSON.stringify(e) === JSON.stringify(r), z = ({
   action: e,
   immutable: r,
-  maxCapacity: o,
+  maxCapacity: y,
   onChange: t,
   state: f
 }) => {
-  const { future: E, past: c, paused: l, 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(c) === 0)
-      return f;
-    const s = c[d(c) - 1], u = c.slice(0, d(c) - 1), n = {
-      future: [i(p, r), ...E],
-      past: u,
-      paused: l,
-      present: i(s, r)
-    };
-    return t == null || t({
-      action: e.type,
-      state: n.present
-    }), n;
-  } else if (e.type === "REDO") {
-    if (d(E) === 0)
-      return f;
-    const s = E[0], n = {
-      future: E.slice(1),
-      past: [...c, i(p, r)],
-      paused: l,
-      present: i(s, r)
-    };
-    return t == null || t({
-      action: e.type,
-      state: n.present
-    }), n;
-  } else if (e.type === "SET") {
-    const { newPresent: s } = e;
-    if (q(s, p, r))
-      return f;
-    if (l) {
-      const w = {
-        ...f,
-        present: i(s, r)
-      };
-      return t == null || t({
-        action: e.type,
-        state: w.present
-      }), w;
-    }
-    let u = [...c];
-    p !== null && (u = [...u, i(p, r)]), !L(o) && o > 0 && d(u) > o && (u = u.slice(d(u) - o));
-    const n = {
-      future: [],
-      past: u,
-      paused: l,
-      present: i(s, r)
-    };
-    return t == null || t({
-      action: e.type,
-      state: n.present
-    }), n;
-  } else if (e.type === "CLEAR") {
+  const { future: o, past: n, paused: S, present: p } = f;
+  if (e.type === "CLEAR") {
     const s = {
       future: [],
       past: [],
-      paused: l,
-      present: i(e.initialPresent, r)
+      paused: S,
+      present: l(e.initialState, r)
     };
     return t == null || t({
       action: e.type,
       state: s.present
     }), s;
-  } else
-    throw new Error("Unsupported action type");
-}, B = (e, r) => {
-  const { maxCapacity: o, debounceTime: t, debounceSettings: f, onChange: E, immutable: c } = r || {}, l = F(e), [p, s] = H(
-    (y, T) => v({
+  } 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,
+          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");
+    }
+  }
+}, 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: c,
-      maxCapacity: o,
-      onChange: E,
-      state: y
+      immutable: n,
+      maxCapacity: y,
+      onChange: o,
+      state: i
     }),
     {
-      ...k,
-      present: i(l.current, c)
+      ...q,
+      paused: (r == null ? void 0 : r.paused) ?? !1,
+      present: l(S.current, n)
     }
-  ), u = d(p.future) !== 0, n = d(p.past) !== 0, w = S(() => s({
-    initialPresent: l.current,
+  ), u = E(p.future) !== 0, c = E(p.past) !== 0, w = d(() => s({
+    initialState: S.current,
     type: "CLEAR"
-  }), []), U = S(() => {
+  }), []), U = d(() => {
     s({ type: "PAUSE" });
-  }, []), P = S(() => {
-    s({ type: "RESUME" });
-  }, []), O = S(() => {
+  }, []), P = d(() => {
     u && s({ type: "REDO" });
-  }, [u]), D = M(
-    (y) => s({ type: "SET", newPresent: y }),
+  }, [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 = S((y) => s({ type: "SET", newPresent: y }), []), N = S(() => {
-    n && s({ type: "UNDO" });
-  }, [n]), A = S(
-    (y) => {
-      t ? D(y) : R(y);
+  ), R = d((i) => s({ type: "SET", newPresent: i }), []), N = d(
+    (i) => {
+      t ? D(i) : R(i);
     },
     [t, D, R]
-  );
+  ), L = d(() => {
+    c && s({ type: "UNDO" });
+  }, [c]);
   return {
     canRedo: u,
-    canUndo: n,
+    canUndo: c,
     clear: w,
     future: p.future,
     past: p.past,
     pause: U,
     paused: p.paused,
-    redo: O,
-    resume: P,
-    set: A,
+    redo: P,
+    replace: A,
+    resume: O,
+    set: N,
     setDirect: R,
     state: p.present,
-    undo: N
+    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.32"
+	"version": "1.0.34"
 }