use-good-hooks 1.0.30 → 1.0.31

package/README.md

@@ -218,7 +218,7 @@ const TextEditor = () => {
     setState,
     state,
     undo
-  } = useHistoryState('', { capacity: 10 });
+  } = useHistoryState('', { maxCapacity: 10 });
 
   return (
     <div>

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

@@ -5,8 +5,12 @@ export { DebounceSettings }
 declare type HistoryAction<T> = {
     type: 'CLEAR';
     initialPresent: T;
+} | {
+    type: 'PAUSE';
 } | {
     type: 'REDO';
+} | {
+    type: 'RESUME';
 } | {
     type: 'SET';
     newPresent: T;
@@ -22,12 +26,14 @@ declare type HistoryOnChange<T> = ({ action, state }: {
 declare type HistoryState<T> = {
     future: T[];
     past: T[];
+    paused: boolean;
     present: T | null;
 };
 
 declare type UseHistoryOptionsState<T> = {
     debounceSettings?: DebounceSettings;
     debounceTime?: number;
+    immutable?: boolean;
     maxCapacity?: number;
     onChange?: HistoryOnChange<T>;
 };
@@ -40,7 +46,10 @@ declare const useHistoryState: <T>(initialPresent: T, options?: UseHistoryOption
         past: T[];
         future: T[];
     };
+    pause: () => void;
+    paused: boolean;
     redo: () => void;
+    resume: () => void;
     set: (newPresent: T) => void;
     setDirect: (newPresent: T) => void;
     state: T;

package/dist/use-history-state.js

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

package/package.json

@@ -45,9 +45,10 @@
 	"scripts": {
 		"build": "yarn lint && vite build --mode export",
 		"lint": "prettier --write . && eslint .",
-		"npm:publish": "yarn test --run && yarn build && yarn version --patch --no-git-tag-version && yarn publish --non-interactive",
-		"test": "vitest",
-		"test:coverage": "vitest --coverage"
+		"npm:publish": "yarn test && yarn build && yarn version --patch --no-git-tag-version && yarn publish --non-interactive",
+		"test": "vitest --run",
+		"test:coverage": "vitest --coverage --run",
+		"test:watch": "vitest"
 	},
-	"version": "1.0.30"
+	"version": "1.0.31"
 }