use-good-hooks 1.0.31 → 1.0.33

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,7 +4,7 @@ export { DebounceSettings }
 
 declare type HistoryAction<T> = {
     type: 'CLEAR';
-    initialPresent: T;
+    initialState: T;
 } | {
     type: 'PAUSE';
 } | {
@@ -36,16 +36,15 @@ 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;
-    history: {
-        past: T[];
-        future: T[];
-    };
+    future: T[];
+    past: T[];
     pause: () => void;
     paused: boolean;
     redo: () => void;

package/dist/use-history-state.js

@@ -1,21 +1,20 @@
-import { useRef as F, useReducer as H, useCallback as S } from "react";
-import J from "lodash/cloneDeep";
-import L from "lodash/isNil";
+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 M from "./use-debounce-fn.js";
-const k = {
+import L from "./use-debounce-fn.js";
+const M = {
   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 = ({
+}, i = (e, t) => t ? e : H(e), k = (e, t, l) => l ? e === t : JSON.stringify(e) === JSON.stringify(t), q = ({
   action: e,
-  immutable: r,
-  maxCapacity: o,
-  onChange: t,
+  immutable: t,
+  maxCapacity: l,
+  onChange: s,
   state: f
 }) => {
-  const { future: E, past: c, paused: l, present: p } = f;
+  const { future: E, past: n, paused: y, present: p } = f;
   if (e.type === "PAUSE")
     return {
       ...f,
@@ -27,120 +26,119 @@ const k = {
       paused: !1
     };
   if (e.type === "UNDO") {
-    if (d(c) === 0)
+    if (d(n) === 0)
       return f;
-    const s = c[d(c) - 1], u = c.slice(0, d(c) - 1), n = {
-      future: [i(p, r), ...E],
+    const r = n[d(n) - 1], u = n.slice(0, d(n) - 1), c = {
+      future: [i(p, t), ...E],
       past: u,
-      paused: l,
-      present: i(s, r)
+      paused: y,
+      present: i(r, t)
     };
-    return t == null || t({
+    return s == null || s({
       action: e.type,
-      state: n.present
-    }), n;
+      state: c.present
+    }), c;
   } else if (e.type === "REDO") {
     if (d(E) === 0)
       return f;
-    const s = E[0], n = {
+    const r = E[0], c = {
       future: E.slice(1),
-      past: [...c, i(p, r)],
-      paused: l,
-      present: i(s, r)
+      past: [...n, i(p, t)],
+      paused: y,
+      present: i(r, t)
     };
-    return t == null || t({
+    return s == null || s({
       action: e.type,
-      state: n.present
-    }), n;
+      state: c.present
+    }), c;
   } else if (e.type === "SET") {
-    const { newPresent: s } = e;
-    if (q(s, p, r))
+    const { newPresent: r } = e;
+    if (k(r, p, t))
       return f;
-    if (l) {
+    if (y) {
       const w = {
         ...f,
-        present: i(s, r)
+        present: i(r, t)
       };
-      return t == null || t({
+      return s == null || s({
         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 = {
+    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: l,
-      present: i(s, r)
+      paused: y,
+      present: i(r, t)
     };
-    return t == null || t({
+    return s == null || s({
       action: e.type,
-      state: n.present
-    }), n;
+      state: c.present
+    }), c;
   } else if (e.type === "CLEAR") {
-    const s = {
+    const r = {
       future: [],
       past: [],
-      paused: l,
-      present: i(e.initialPresent, r)
+      paused: y,
+      present: i(e.initialState, t)
     };
-    return t == null || t({
+    return s == null || s({
       action: e.type,
-      state: s.present
-    }), s;
+      state: r.present
+    }), r;
   } 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({
-      action: T,
-      immutable: c,
-      maxCapacity: o,
+}, 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,
+      immutable: n,
+      maxCapacity: l,
       onChange: E,
-      state: y
+      state: S
     }),
     {
-      ...k,
-      present: i(l.current, c)
+      ...M,
+      paused: (t == null ? void 0 : t.paused) ?? !1,
+      present: i(y.current, n)
     }
-  ), u = d(p.future) !== 0, n = d(p.past) !== 0, w = S(() => s({
-    initialPresent: l.current,
+  ), u = d(p.future) !== 0, c = d(p.past) !== 0, w = o(() => r({
+    initialState: y.current,
     type: "CLEAR"
-  }), []), U = S(() => {
-    s({ type: "PAUSE" });
-  }, []), P = S(() => {
-    s({ type: "RESUME" });
-  }, []), O = S(() => {
-    u && s({ type: "REDO" });
-  }, [u]), D = M(
-    (y) => s({ type: "SET", newPresent: y }),
-    t,
+  }), []), 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,
     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 = o((S) => r({ type: "SET", newPresent: S }), []), a = o(() => {
+    c && r({ type: "UNDO" });
+  }, [c]), A = o(
+    (S) => {
+      s ? D(S) : R(S);
     },
-    [t, D, R]
+    [s, D, R]
   );
   return {
     canRedo: u,
-    canUndo: n,
+    canUndo: c,
     clear: w,
-    history: {
-      past: p.past,
-      future: p.future
-    },
+    future: p.future,
+    past: p.past,
     pause: U,
     paused: p.paused,
-    redo: O,
-    resume: P,
+    redo: N,
+    resume: O,
     set: A,
     setDirect: R,
     state: p.present,
-    undo: N
+    undo: a
   };
 };
 export {

package/package.json

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