Remove extra comments

Author: aryaemami59

src/hooks/useDispatch.ts

@@ -5,20 +5,15 @@ import type { ReactReduxContextValue } from '../components/Context'
 import { ReactReduxContext } from '../components/Context'
 import { createStoreHook, useStore as useDefaultStore } from './useStore'
 
-export interface UseDispatch {
-  <
-    AppDispatch extends Dispatch<Action> = Dispatch<UnknownAction>
-  >(): AppDispatch
-  withTypes: <AppDispatch extends Dispatch<Action>>() => () => AppDispatch
+export interface UseDispatch<
+  DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>
+> {
+  <AppDispatch extends DispatchType = DispatchType>(): AppDispatch
+
+  withTypes: <
+    OverrideDispatchType extends DispatchType
+  >() => UseDispatch<OverrideDispatchType>
 }
-// export interface UseDispatch<
-//   DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>
-// > {
-//   <AppDispatch extends DispatchType = DispatchType>(): AppDispatch
-//   withTypes: <
-//     OverrideDispatchType extends DispatchType
-//   >() => UseDispatch<OverrideDispatchType>
-// }
 
 /**
  * Hook factory, which creates a `useDispatch` hook bound to a given context.
@@ -28,26 +23,22 @@ export interface UseDispatch {
  */
 export function createDispatchHook<
   S = unknown,
-  A extends Action<string> = UnknownAction
+  A extends Action = UnknownAction
   // @ts-ignore
 >(context?: Context<ReactReduxContextValue<S, A> | null> = ReactReduxContext) {
   const useStore =
-    // @ts-ignore
     context === ReactReduxContext ? useDefaultStore : createStoreHook(context)
 
-  const useDispatch = <
-    AppDispatch extends Dispatch<A> = Dispatch<A>
-  >(): AppDispatch => {
+  const useDispatch = () => {
     const store = useStore()
-    // @ts-ignore
     return store.dispatch
   }
 
   Object.assign(useDispatch, {
     withTypes: () => useDispatch,
   })
 
-  return useDispatch as UseDispatch
+  return useDispatch as UseDispatch<Dispatch<A>>
 }
 
 /**

src/hooks/useSelector.ts

@@ -3,7 +3,7 @@ import { React } from '../utils/react'
 
 import type { ReactReduxContextValue } from '../components/Context'
 import { ReactReduxContext } from '../components/Context'
-import type { EqualityFn, NoInfer, TypedUseSelectorHook } from '../types'
+import type { EqualityFn, NoInfer } from '../types'
 import type { uSESWS } from '../utils/useSyncExternalStore'
 import { notInitialized } from '../utils/useSyncExternalStore'
 import {
@@ -66,26 +66,16 @@ export interface UseSelectorOptions<Selected = unknown> {
   devModeChecks?: Partial<DevModeChecks>
 }
 
-export interface UseSelector {
-  <TState = unknown, Selected = unknown>(
+export interface UseSelector<StateType = unknown> {
+  <TState extends StateType = StateType, Selected = unknown>(
     selector: (state: TState) => Selected,
     equalityFnOrOptions?: EqualityFn<Selected> | UseSelectorOptions<Selected>
   ): Selected
-  withTypes: <TState>() => TypedUseSelectorHook<TState>
+
+  withTypes: <
+    OverrideStateType extends StateType
+  >() => UseSelector<OverrideStateType>
 }
-// export interface UseSelector<StateType = unknown> {
-//   <TState extends StateType = StateType, Selected = unknown>(
-//     selector: (state: TState) => Selected,
-//     equalityFn?: EqualityFn<Selected>
-//   ): Selected
-//   <TState extends StateType = StateType, Selected = unknown>(
-//     selector: (state: TState) => Selected,
-//     options?: UseSelectorOptions<Selected>
-//   ): Selected
-//   withTypes: <
-//     OverrideStateType extends StateType
-//   >() => UseSelector<OverrideStateType>
-// }
 
 let useSyncExternalStoreWithSelector = notInitialized as uSESWS
 export const initializeUseSelector = (fn: uSESWS) => {

src/hooks/useStore.ts

@@ -1,5 +1,5 @@
 import type { Context } from 'react'
-import type { Action as BasicAction, Store, UnknownAction } from 'redux'
+import type { Action, Store } from 'redux'
 import type { ReactReduxContextValue } from '../components/Context'
 import { ReactReduxContext } from '../components/Context'
 import {
@@ -9,31 +9,25 @@ import {
 
 export type StoreAction<StoreType extends Store> = StoreType extends Store<
   any,
-  infer Action
+  infer ActionType
 >
-  ? Action
+  ? ActionType
   : never
 
-export interface UseStore {
-  <State = any, Action extends BasicAction = UnknownAction>(): Store<
-    State,
-    Action
-  >
+export interface UseStore<StoreType extends Store> {
+  (): StoreType
 
-  withTypes: <AppStore extends Store>() => () => AppStore
-}
-// export interface UseStore<StoreType extends Store = Store> {
-//   <
-//     State extends ReturnType<StoreType['getState']> = ReturnType<
-//       StoreType['getState']
-//     >,
-//     Action extends BasicAction = StoreAction<Store>
-//   >(): Store<State, Action>
+  <
+    StateType extends ReturnType<StoreType['getState']> = ReturnType<
+      StoreType['getState']
+    >,
+    ActionType extends Action = StoreAction<Store>
+  >(): Store<StateType, ActionType>
 
-//   withTypes: <
-//     OverrideStoreType extends StoreType
-//   >() => UseStore<OverrideStoreType>
-// }
+  withTypes: <
+    OverrideStoreType extends StoreType
+  >() => UseStore<OverrideStoreType>
+}
 
 /**
  * Hook factory, which creates a `useStore` hook bound to a given context.
@@ -42,31 +36,30 @@ export interface UseStore {
  * @returns {Function} A `useStore` hook bound to the specified context.
  */
 export function createStoreHook<
-  S = unknown,
-  A extends BasicAction = BasicAction
+  StateType = unknown,
+  ActionType extends Action = Action
+>(
   // @ts-ignore
->(context?: Context<ReactReduxContextValue<S, A> | null> = ReactReduxContext) {
+  context?: Context<ReactReduxContextValue<
+    StateType,
+    ActionType
+  > | null> = ReactReduxContext
+) {
   const useReduxContext =
-    // @ts-ignore
     context === ReactReduxContext
       ? useDefaultReduxContext
       : // @ts-ignore
         createReduxContextHook(context)
-  const useStore = <
-    State = S,
-    Action2 extends BasicAction = A
-    // @ts-ignore
-  >() => {
+  const useStore = () => {
     const { store } = useReduxContext()
-    // @ts-ignore
-    return store as Store<State, Action2>
+    return store
   }
 
   Object.assign(useStore, {
     withTypes: () => useStore,
   })
 
-  return useStore as UseStore
+  return useStore as UseStore<Store<StateType, ActionType>>
 }
 
 /**