refactor: export useDispatch, only return restate in useRestate

- useDispatch now returns store.dispatch
- useRestate will now only return the state and not dispatch

Author: animify

example/Comp.tsx

@@ -1,19 +1,21 @@
 import React from 'react';
-import { useRestate, useAction } from '../src';
+import { useRestate, useAction, useDispatch } from '../src';
 
 export default function Component() {
-    const [restate, dispatch] = useRestate((state: { count: number }) => {
+    const dispatch = useDispatch();
+    const { count } = useRestate((state: { count: number }) => {
         return { count: state.count };
     });
 
     const incrementAction = { type: 'INCREMENT' };
+    const derementAction = { type: 'DECREMENT' };
     const increment = useAction(incrementAction);
 
     return (
         <div>
-            <p>{restate.count}</p>
+            <p>{count}</p>
             <a onClick={increment}>Increment count</a>
-            <a onClick={() => dispatch({ type: 'DECREMENT' })}>Decrement count</a>
+            <a onClick={() => dispatch(derementAction)}>Decrement count</a>
         </div>
     );
 }

src/index.ts

@@ -17,9 +17,7 @@ const useStore = () => {
     return store;
 };
 
-export function useRestate<TState, USelector>(
-    selectFrom: (state: TState) => USelector,
-): [USelector, Dispatch] {
+export function useRestate<TState, TSelector>(selectFrom: (state: TState) => TSelector): TSelector {
     const store = useStore();
 
     const [restate, setRestate] = useState(() => selectFrom(store.getState()));
@@ -49,12 +47,18 @@ export function useRestate<TState, USelector>(
         [store, selectFrom],
     );
 
-    return [restate, store.dispatch];
+    return restate;
 }
 
-export function useAction<TAction extends Action>(action: TAction): () => TAction {
+export function useDispatch<TAction extends Action>(): Dispatch<TAction> {
     const store = useStore();
-    const dispatch = useCallback(() => store.dispatch(action), [action]);
 
-    return dispatch;
+    return store.dispatch;
+}
+
+export function useAction<TAction extends Action>(action: TAction): () => TAction {
+    const dispatch = useDispatch();
+    const memoizedDispatch = useCallback(() => dispatch(action), [action]);
+
+    return memoizedDispatch;
 }