fix(useResetState): random initial value changed

packages/hooks/src/useResetState/__tests__/index.test.ts

@@ -2,9 +2,9 @@ import { act, renderHook } from '@testing-library/react';
 import useResetState from '../index';
 
 describe('useResetState', () => {
-  const setUp = <S>(initialState: S) =>
+  const setUp = (initialState) =>
     renderHook(() => {
-      const [state, setState, resetState] = useResetState<S>(initialState);
+      const [state, setState, resetState] = useResetState(initialState);
 
       return {
         state,
@@ -20,33 +20,60 @@ describe('useResetState', () => {
     expect(hook.result.current.state).toEqual({ hello: 'world' });
   });
 
+  it('should support functional initialValue', () => {
+    const hook = setUp(() => ({
+      hello: 'world',
+    }));
+    expect(hook.result.current.state).toEqual({ hello: 'world' });
+  });
+
   it('should reset state', () => {
     const hook = setUp({
       hello: '',
       count: 0,
     });
 
     act(() => {
-      hook.result.current.setState({
-        hello: 'world',
-        count: 1,
-      });
-    });
-
-    act(() => {
+      hook.result.current.setState({ hello: 'world', count: 1 });
       hook.result.current.resetState();
     });
-
     expect(hook.result.current.state).toEqual({ hello: '', count: 0 });
   });
 
   it('should support function update', () => {
     const hook = setUp({
       count: 0,
     });
+
     act(() => {
       hook.result.current.setState((prev) => ({ count: prev.count + 1 }));
     });
     expect(hook.result.current.state).toEqual({ count: 1 });
   });
+
+  it('should keep random initial state', () => {
+    const random = Math.random();
+    const hook = setUp({
+      count: random,
+    });
+
+    act(() => {
+      hook.result.current.setState({ count: Math.random() });
+      hook.result.current.resetState();
+    });
+    expect(hook.result.current.state).toEqual({ count: random });
+  });
+
+  it('should support random functional initialValue', () => {
+    const random = Math.random();
+    const hook = setUp(() => ({
+      count: random,
+    }));
+
+    act(() => {
+      hook.result.current.setState({ count: Math.random() });
+      hook.result.current.resetState();
+    });
+    expect(hook.result.current.state).toEqual({ count: random });
+  });
 });

packages/hooks/src/useResetState/demo/demo1.tsx

@@ -3,25 +3,30 @@ import { useResetState } from 'ahooks';
 
 interface State {
   hello: string;
-  count: number;
+  value: number;
 }
 
+const initialValue = {
+  hello: '',
+  value: Math.random(),
+};
+
 export default () => {
-  const [state, setState, resetState] = useResetState<State>({
-    hello: '',
-    count: 0,
-  });
+  const [state, setState, resetState] = useResetState<State>(initialValue);
 
   return (
     <div>
+      <div>initial state:</div>
+      <pre>{JSON.stringify(initialValue, null, 2)}</pre>
+      <div>current state:</div>
       <pre>{JSON.stringify(state, null, 2)}</pre>
       <p>
         <button
           type="button"
           style={{ marginRight: '8px' }}
-          onClick={() => setState({ hello: 'world', count: 1 })}
+          onClick={() => setState(() => ({ hello: 'world', value: Math.random() }))}
         >
-          set hello and count
+          set hello and value
         </button>
 
         <button type="button" onClick={resetState}>

packages/hooks/src/useResetState/index.ts

@@ -1,16 +1,23 @@
 import { useState } from 'react';
 import type { Dispatch, SetStateAction } from 'react';
 import useMemoizedFn from '../useMemoizedFn';
+import { isFunction } from '../utils';
+import useCreation from '../useCreation';
 
 type ResetState = () => void;
 
 const useResetState = <S>(
   initialState: S | (() => S),
 ): [S, Dispatch<SetStateAction<S>>, ResetState] => {
-  const [state, setState] = useState(initialState);
+  const initialStateMemo = useCreation(
+    () => (isFunction(initialState) ? initialState() : initialState),
+    [],
+  );
+
+  const [state, setState] = useState(initialStateMemo);
 
   const resetState = useMemoizedFn(() => {
-    setState(initialState);
+    setState(initialStateMemo);
   });
 
   return [state, setState, resetState];