chore: adjust code

package.json

@@ -19,6 +19,7 @@
     "prepare": "stan-builder",
     "prepublishOnly": "npm run release",
     "release": "./scripts/release.sh",
+    "lint:fix": "eslint --fix --ext js,jsx,ts,tsx src",
     "test": "jest"
   },
   "repository": {
@@ -40,6 +41,7 @@
     "access": "public"
   },
   "dependencies": {
+    "fast-deep-equal": "^3.1.3",
     "@babel/runtime": "^7.12.5",
     "@planjs/utils": "^1.8.4",
     "resize-observer-polyfill": "^1.5.1"

src/hooks/createGlobalState.ts

@@ -5,7 +5,7 @@ export function createGlobalState<S = any>(initialState?: S) {
     state: initialState,
     setState(state: S) {
       store.state = state;
-      store.setters.forEach(setter => setter(store.state));
+      store.setters.forEach((setter) => setter(store.state));
     },
     setters: [],
   };
@@ -15,9 +15,9 @@ export function createGlobalState<S = any>(initialState?: S) {
 
     useEffect(
       () => () => {
-        store.setters = store.setters.filter(setter => setter !== stateSetter);
+        store.setters = store.setters.filter((setter) => setter !== stateSetter);
       },
-      []
+      [],
     );
 
     /* eslint-disable-next-line */

src/hooks/index.ts

@@ -7,7 +7,6 @@ export { default as useUpdateEffect } from './useUpdateEffect';
 export { default as useForceUpdate } from './useForceUpdate';
 export { default as createStateContext } from './createStateContext';
 export { default as createGlobalState } from './createGlobalState';
-export { default as useUpdate } from './useUpdate';
 export { default as useDeepEffect } from './useDeepEffect';
 
 export { default as useInterval } from './useInterval';

src/hooks/useAsyncRetry.ts

@@ -5,7 +5,7 @@ export type AsyncStateRetry<T> = AsyncState<T> & {
   retry(): void;
 };
 
-const useAsyncRetry = <T>(fn: () => Promise<T>, deps: DependencyList = []) => {
+const useAsyncRetry = <T>(fn: () => Promise<T>, deps: DependencyList = []): AsyncStateRetry<T> => {
   const [attempt, setAttempt] = useState<number>(0);
   const state = useAsync(fn, [...deps, attempt]);
 
@@ -14,14 +14,14 @@ const useAsyncRetry = <T>(fn: () => Promise<T>, deps: DependencyList = []) => {
     if (stateLoading) {
       if (process.env.NODE_ENV === 'development') {
         console.log(
-          'You are calling useAsyncRetry hook retry() method while loading in progress, this is a no-op.'
+          'You are calling useAsyncRetry hook retry() method while loading in progress, this is a no-op.',
         );
       }
 
       return;
     }
 
-    setAttempt(currentAttempt => currentAttempt + 1);
+    setAttempt((currentAttempt) => currentAttempt + 1);
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [...deps, stateLoading]);
 

src/hooks/useCounter.ts

@@ -1,5 +1,5 @@
-import useCreation from './useCreation';
 import { useState, useMemo } from 'react';
+import useCreation from './useCreation';
 
 interface Options {
   min?: number;
@@ -41,10 +41,10 @@ function useCounter(initialValue: number = 0, options: Options = {}): [number, A
       });
     };
     const inc = (delta: number = 1) => {
-      setValue(c => c + delta);
+      setValue((c) => c + delta);
     };
     const dec = (delta: number = 1) => {
-      setValue(c => c - delta);
+      setValue((c) => c - delta);
     };
     const set = (value: number | ((c: number) => number)) => {
       setValue(value);

src/hooks/useCreation.ts

@@ -1,11 +1,12 @@
 import { useRef } from 'react';
+import type { DependencyList } from 'react';
 
 /**
  * 确保实例不会被重复创建
  * @param factory
  * @param deps
  */
-export default function useCreation<T>(factory: () => T, deps: any[]) {
+export default function useCreation<T>(factory: () => T, deps: DependencyList) {
   const { current } = useRef({
     deps,
     obj: undefined as undefined | T,
@@ -19,7 +20,7 @@ export default function useCreation<T>(factory: () => T, deps: any[]) {
   return current.obj as T;
 }
 
-function depsAreSame(oldDeps: any[], deps: any[]): boolean {
+function depsAreSame(oldDeps: DependencyList, deps: DependencyList): boolean {
   if (oldDeps === deps) return true;
   for (const i in oldDeps) {
     if (oldDeps[i] !== deps[i]) return false;

src/hooks/useDebounce.ts

@@ -9,7 +9,7 @@ function useDebounce<T>(value: T, wait: number) {
       setState(value);
     },
     [value],
-    wait
+    wait,
   );
 
   return state;

src/hooks/useDebounceFn.ts

@@ -12,12 +12,12 @@ function useDebounceFn<T extends any[]>(fn: (...args: T) => any, wait: number):
 function useDebounceFn<T extends any[]>(
   fn: (...args: T) => any,
   deps: DependencyList,
-  wait: number
+  wait: number,
 ): ReturnValue<T>;
 function useDebounceFn<T extends any[]>(
   fn: (...args: T) => any,
   deps: DependencyList | number,
-  wait?: number
+  wait?: number,
 ): ReturnValue<T> {
   const _deps: DependencyList = (Array.isArray(deps) ? deps : []) as DependencyList;
   const _wait: number = typeof deps === 'number' ? deps : wait || 0;
@@ -39,7 +39,7 @@ function useDebounceFn<T extends any[]>(
         fnRef.current(...args);
       }, _wait);
     },
-    [_wait, cancel]
+    [_wait, cancel],
   );
 
   useUpdateEffect(() => {

src/hooks/useDeepEffect.ts

@@ -1,25 +1,41 @@
-import { useEffect, useRef } from 'react';
-import _ from 'lodash';
+import { useRef, useEffect } from 'react';
+import type { DependencyList, EffectCallback } from 'react';
+import deepEqual from 'fast-deep-equal/react';
+import { isPrimitive } from '@planjs/utils';
+
+const warnDeps = (dependencies: DependencyList) => {
+  if (dependencies.length === 0) {
+    console.warn('useDeepEffect should not be used with no dependencies. Use useEffect instead.');
+  }
+
+  if (dependencies.every(isPrimitive)) {
+    console.warn('useDeepEffect should not be used with primitive values. Use useEffect instead.');
+  }
+};
+
+function useDeepCompareMemoize(value: DependencyList) {
+  const ref = useRef<DependencyList>();
+  const signalRef = useRef<number>(0);
+
+  if (!deepEqual(value, ref.current)) {
+    ref.current = value;
+    signalRef.current += 1;
+  }
+
+  return [signalRef.current];
+}
 
 /**
  * 使用上与 useEffect 完全相同，只是它进行了深比较
- * @param effect
+ * @param fn
  * @param deps
  */
-const useDeepEffect: typeof useEffect = (effect, deps) => {
-  const oldDepsRef = useRef<React.DependencyList>([]);
-
-  useEffect(() => {
-    const isUpdate = oldDepsRef.current.some((dep, index) => {
-      return !_.isEqual(dep, deps?.[index]);
-    });
-
-    if (isUpdate) {
-      oldDepsRef.current = deps || [];
-      return effect();
-    }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, deps);
-};
+function useDeepEffect(fn: EffectCallback, deps: DependencyList): ReturnType<typeof useEffect> {
+  if (process.env.NODE_ENV !== 'production') {
+    warnDeps(deps);
+  }
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  return useEffect(fn, useDeepCompareMemoize(deps));
+}
 
 export default useDeepEffect;

src/hooks/useError.ts

@@ -1,4 +1,4 @@
-import { useState, useEffect, useCallback } from 'react';
+import { useCallback, useEffect, useState } from 'react';
 
 const useError = (): ((err: Error) => void) => {
   const [error, setError] = useState<Error | null>(null);
@@ -9,11 +9,9 @@ const useError = (): ((err: Error) => void) => {
     }
   }, [error]);
 
-  const dispatchError = useCallback((err: Error) => {
+  return useCallback((err: Error) => {
     setError(err);
   }, []);
-
-  return dispatchError;
 };
 
 export default useError;

src/hooks/useHover.ts

@@ -1,4 +1,5 @@
-import { useState, useEffect, RefObject } from 'react';
+import { useState, useEffect } from 'react';
+import type { RefObject } from 'react';
 
 function useHover<T extends HTMLElement = HTMLElement>(elementRef: RefObject<T>): boolean {
   const [value, setValue] = useState<boolean>(false);
@@ -19,7 +20,7 @@ function useHover<T extends HTMLElement = HTMLElement>(elementRef: RefObject<T>)
     }
   }, [elementRef]);
 
-  return !!value;
+  return value;
 }
 
 export default useHover;

src/hooks/useKeyPress.ts

@@ -133,21 +133,21 @@ const defaultEvents: Array<keyEvent> = ['keydown'];
 function useKeyPress<T extends HTMLElement = HTMLInputElement>(
   keyFilter: KeyFilter,
   eventHandler: EventHandler = noop,
-  option: EventOption = {}
+  option: EventOption = {},
 ): RefObject<T> {
   const { events = defaultEvents, target } = option;
   const element = useRef<T>();
   const callbackRef = useRef(eventHandler);
   callbackRef.current = eventHandler;
 
   const callbackHandler = useCallback(
-    event => {
+    (event) => {
       const genGuard: KeyPredicate = genKeyFormater(keyFilter);
       if (genGuard(event)) {
         return callbackRef.current(event);
       }
     },
-    [keyFilter]
+    [keyFilter],
   );
 
   useEffect(() => {

src/hooks/useLifecycles.ts

@@ -1,6 +1,6 @@
 import { useEffect } from 'react';
 
-const useLifecycles = (mount: () => void, unmount?:() => void) => {
+const useLifecycles = (mount: () => void, unmount?: () => void) => {
   useEffect(() => {
     if (mount) {
       mount();

src/hooks/useLocalStorageState.ts

@@ -1,12 +1,12 @@
 import useStorageState from './useStorageState';
 
 function useLocalStorageState<T = undefined>(
-  key: string
+  key: string,
 ): [T | undefined, (value?: T | ((previousState?: T) => T)) => void];
 
 function useLocalStorageState<T>(
   key: string,
-  defaultValue: T | (() => T)
+  defaultValue: T | (() => T),
 ): [T, (value?: T | ((previousState: T) => T)) => void];
 
 function useLocalStorageState<T>(key: string, defaultValue?: T | (() => T)) {

src/hooks/useMap.ts

@@ -3,14 +3,15 @@ import { useMemo, useState, useCallback } from 'react';
 function useMap<K, T>(initialValue?: Iterable<readonly [K, T]>) {
   const initialMap = useMemo<Map<K, T>>(
     () => (initialValue === undefined ? new Map() : new Map(initialValue)) as Map<K, T>,
-    []
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [],
   );
   const [map, setMap] = useState(initialMap);
 
   const stableActions = useMemo(
     () => ({
       set: (key: K, entry: T) => {
-        setMap(prev => {
+        setMap((prev) => {
           const temp = new Map(prev);
           temp.set(key, entry);
           return temp;
@@ -20,19 +21,19 @@ function useMap<K, T>(initialValue?: Iterable<readonly [K, T]>) {
         setMap(new Map(newMap));
       },
       remove: (key: K) => {
-        setMap(prev => {
+        setMap((prev) => {
           const temp = new Map(prev);
           temp.delete(key);
           return temp;
         });
       },
       reset: () => setMap(initialMap),
     }),
-    [setMap, initialMap]
+    [setMap, initialMap],
   );
 
   const utils = {
-    get: useCallback(key => map.get(key), [map]),
+    get: useCallback((key) => map.get(key), [map]),
     ...stableActions,
   };
 

src/hooks/useMount.ts

@@ -1,9 +1,10 @@
-/**
- * @description 模拟react类组件的compoentDidMount()
- */
 import { useEffect } from 'react';
+import type { EffectCallback } from 'react';
 
-const useMount = (fn: Function) => {
+/**
+ * @description 模拟react类组件的componentDidMount()
+ */
+const useMount = (fn: EffectCallback) => {
   useEffect(() => {
     fn();
     // eslint-disable-next-line react-hooks/exhaustive-deps

src/hooks/usePersistFn.ts

@@ -9,6 +9,7 @@ function usePersistFn<T extends noop>(fn: T) {
 
   ref.current = fn;
 
+  // eslint-disable-next-line react-hooks/exhaustive-deps
   return useCallback(((...args) => ref.current(...args)) as T, [ref]);
 }
 

src/hooks/useResizeObserver.ts

@@ -26,6 +26,6 @@ export default function useResizeObserver(handler: (evt: any) => void, element?:
         element && observer.unobserve(element);
       };
     },
-    [element] // 如果 element 变化，就再次运行
+    [element], // 如果 element 变化，就再次运行
   );
 }

src/hooks/useSessionStorageState.ts

@@ -1,12 +1,12 @@
 import useStorageState from './useStorageState';
 
 function useSessionStorageState<T = undefined>(
-  key: string
+  key: string,
 ): [T | undefined, (value?: T | ((previousState?: T) => T)) => void];
 
 function useSessionStorageState<T>(
   key: string,
-  defaultValue: T | (() => T)
+  defaultValue: T | (() => T),
 ): [T, (value?: T | ((previousState: T) => T)) => void];
 
 function useSessionStorageState<T>(key: string, defaultValue?: T | (() => T)) {