react-redux - npm Package Compare versions

Comparing version 9.0.4 to 9.1.0

dist/react-redux.d.ts

 import * as React$1 from 'react';
-import { Context, ComponentType, ComponentClass, ClassAttributes, JSX, FunctionComponent, ReactNode } from 'react';
+import { Context, ReactNode, ComponentType, ComponentClass, ClassAttributes, JSX, FunctionComponent } from 'react';
 import { Action, UnknownAction, Store, Dispatch } from 'redux';
 
-type VoidFunc = () => void;
-type Listener = {
-    callback: VoidFunc;
-    next: Listener | null;
-    prev: Listener | null;
-};
-declare function createListenerCollection(): {
-    clear(): void;
-    notify(): void;
-    get(): Listener[];
-    subscribe(callback: () => void): () => void;
-};
-type ListenerCollection = ReturnType<typeof createListenerCollection>;
-interface Subscription {
-    addNestedSub: (listener: VoidFunc) => VoidFunc;
-    notifyNestedSubs: VoidFunc;
-    handleChangeWrapper: VoidFunc;
-    isSubscribed: () => boolean;
-    onStateChange?: VoidFunc | null;
-    trySubscribe: VoidFunc;
-    tryUnsubscribe: VoidFunc;
-    getListeners: () => ListenerCollection;
-}
-
-interface ReactReduxContextValue<SS = any, A extends Action<string> = UnknownAction> extends Pick<ProviderProps, 'stabilityCheck' | 'identityFunctionCheck'> {
-    store: Store<SS, A>;
-    subscription: Subscription;
-    getServerState?: () => SS;
-}
-declare const ReactReduxContext: Context<ReactReduxContextValue<any, UnknownAction> | null>;
-type ReactReduxContextInstance = typeof ReactReduxContext;
-
 /**
@@ -85,85 +53,200 @@ * Copyright 2015, Yahoo! Inc.
 
-type SelectorFactory<S, TProps, TOwnProps, TFactoryOptions> = (dispatch: Dispatch<Action<string>>, factoryOptions: TFactoryOptions) => Selector<S, TProps, TOwnProps>;
-type Selector<S, TProps, TOwnProps = null> = TOwnProps extends null | undefined ? (state: S) => TProps : (state: S, ownProps: TOwnProps) => TProps;
-type MapStateToProps<TStateProps, TOwnProps, State> = (state: State, ownProps: TOwnProps) => TStateProps;
-type MapStateToPropsFactory<TStateProps, TOwnProps, State> = (initialState: State, ownProps: TOwnProps) => MapStateToProps<TStateProps, TOwnProps, State>;
-type MapStateToPropsParam<TStateProps, TOwnProps, State> = MapStateToPropsFactory<TStateProps, TOwnProps, State> | MapStateToProps<TStateProps, TOwnProps, State> | null | undefined;
-type MapDispatchToPropsFunction<TDispatchProps, TOwnProps> = (dispatch: Dispatch<Action<string>>, ownProps: TOwnProps) => TDispatchProps;
-type MapDispatchToProps<TDispatchProps, TOwnProps> = MapDispatchToPropsFunction<TDispatchProps, TOwnProps> | TDispatchProps;
-type MapDispatchToPropsFactory<TDispatchProps, TOwnProps> = (dispatch: Dispatch<Action<string>>, ownProps: TOwnProps) => MapDispatchToPropsFunction<TDispatchProps, TOwnProps>;
-type MapDispatchToPropsParam<TDispatchProps, TOwnProps> = MapDispatchToPropsFactory<TDispatchProps, TOwnProps> | MapDispatchToProps<TDispatchProps, TOwnProps>;
-type MapDispatchToPropsNonObject<TDispatchProps, TOwnProps> = MapDispatchToPropsFactory<TDispatchProps, TOwnProps> | MapDispatchToPropsFunction<TDispatchProps, TOwnProps>;
-type MergeProps<TStateProps, TDispatchProps, TOwnProps, TMergedProps> = (stateProps: TStateProps, dispatchProps: TDispatchProps, ownProps: TOwnProps) => TMergedProps;
+type VoidFunc = () => void;
+type Listener = {
+    callback: VoidFunc;
+    next: Listener | null;
+    prev: Listener | null;
+};
+declare function createListenerCollection(): {
+    clear(): void;
+    notify(): void;
+    get(): Listener[];
+    subscribe(callback: () => void): () => void;
+};
+type ListenerCollection = ReturnType<typeof createListenerCollection>;
+interface Subscription {
+    addNestedSub: (listener: VoidFunc) => VoidFunc;
+    notifyNestedSubs: VoidFunc;
+    handleChangeWrapper: VoidFunc;
+    isSubscribed: () => boolean;
+    onStateChange?: VoidFunc | null;
+    trySubscribe: VoidFunc;
+    tryUnsubscribe: VoidFunc;
+    getListeners: () => ListenerCollection;
+}
 
-interface ConnectProps {
-    /** A custom Context instance that the component can use to access the store from an alternate Provider using that same Context instance */
-    context?: ReactReduxContextInstance;
-    /** A Redux store instance to be used for subscriptions instead of the store from a Provider */
-    store?: Store;
+interface ProviderProps<A extends Action<string> = UnknownAction, S = unknown> {
+    /**
+     * The single Redux store in your application.
+     */
+    store: Store<S, A>;
+    /**
+     * An optional server state snapshot. Will be used during initial hydration render if available, to ensure that the UI output is consistent with the HTML generated on the server.
+     */
+    serverState?: S;
+    /**
+     * Optional context to be used internally in react-redux. Use React.createContext() to create a context to be used.
+     * If this is used, you'll need to customize `connect` by supplying the same context provided to the Provider.
+     * Set the initial value to null, and the hooks will error
+     * if this is not overwritten by Provider.
+     */
+    context?: Context<ReactReduxContextValue<S, A> | null>;
+    /**
+     * Determines the frequency of stability checks for all selectors.
+     * This setting overrides the global configuration for
+     * the `useSelector` stability check, allowing you to specify how often
+     * these checks should occur in development mode.
+     *
+     * @since 8.1.0
+     */
+    stabilityCheck?: DevModeCheckFrequency;
+    /**
+     * Determines the frequency of identity function checks for all selectors.
+     * This setting overrides the global configuration for
+     * the `useSelector` identity function check, allowing you to specify how often
+     * these checks should occur in development mode.
+     *
+     * **Note**: Previously referred to as `noopCheck`.
+     *
+     * @since 9.0.0
+     */
+    identityFunctionCheck?: DevModeCheckFrequency;
+    children: ReactNode;
 }
+declare function Provider<A extends Action<string> = UnknownAction, S = unknown>({ store, context, children, serverState, stabilityCheck, identityFunctionCheck, }: ProviderProps<A, S>): React$1.JSX.Element;
+
+interface ReactReduxContextValue<SS = any, A extends Action<string> = UnknownAction> extends Pick<ProviderProps, 'stabilityCheck' | 'identityFunctionCheck'> {
+    store: Store<SS, A>;
+    subscription: Subscription;
+    getServerState?: () => SS;
+}
+declare const ReactReduxContext: Context<ReactReduxContextValue<any, UnknownAction> | null>;
+type ReactReduxContextInstance = typeof ReactReduxContext;
+
 /**
- * Infers the type of props that a connector will inject into a component.
+ * The frequency of development mode checks.
+ *
+ * @since 8.1.0
+ * @internal
  */
-type ConnectedProps<TConnector> = TConnector extends InferableComponentEnhancerWithProps<infer TInjectedProps, any> ? unknown extends TInjectedProps ? TConnector extends InferableComponentEnhancer<infer TInjectedProps> ? TInjectedProps : never : TInjectedProps : never;
-interface ConnectOptions<State = unknown, TStateProps = {}, TOwnProps = {}, TMergedProps = {}> {
-    forwardRef?: boolean;
-    context?: typeof ReactReduxContext;
-    areStatesEqual?: (nextState: State, prevState: State, nextOwnProps: TOwnProps, prevOwnProps: TOwnProps) => boolean;
-    areOwnPropsEqual?: (nextOwnProps: TOwnProps, prevOwnProps: TOwnProps) => boolean;
-    areStatePropsEqual?: (nextStateProps: TStateProps, prevStateProps: TStateProps) => boolean;
-    areMergedPropsEqual?: (nextMergedProps: TMergedProps, prevMergedProps: TMergedProps) => boolean;
+type DevModeCheckFrequency = 'never' | 'once' | 'always';
+/**
+ * Represents the configuration for development mode checks.
+ *
+ * @since 9.0.0
+ * @internal
+ */
+interface DevModeChecks {
+    /**
+     * Overrides the global stability check for the selector.
+     * - `once` - Run only the first time the selector is called.
+     * - `always` - Run every time the selector is called.
+     * - `never` - Never run the stability check.
+     *
+     * @default 'once'
+     *
+     * @since 8.1.0
+     */
+    stabilityCheck: DevModeCheckFrequency;
+    /**
+     * Overrides the global identity function check for the selector.
+     * - `once` - Run only the first time the selector is called.
+     * - `always` - Run every time the selector is called.
+     * - `never` - Never run the identity function check.
+     *
+     * **Note**: Previously referred to as `noopCheck`.
+     *
+     * @default 'once'
+     *
+     * @since 9.0.0
+     */
+    identityFunctionCheck: DevModeCheckFrequency;
 }
+interface UseSelectorOptions<Selected = unknown> {
+    equalityFn?: EqualityFn<Selected>;
+    /**
+     * `useSelector` performs additional checks in development mode to help
+     * identify and warn about potential issues in selector behavior. This
+     * option allows you to customize the behavior of these checks per selector.
+     *
+     * @since 9.0.0
+     */
+    devModeChecks?: Partial<DevModeChecks>;
+}
 /**
- * Connects a React component to a Redux store.
+ * Represents a custom hook that allows you to extract data from the
+ * Redux store state, using a selector function. The selector function
+ * takes the current state as an argument and returns a part of the state
+ * or some derived data. The hook also supports an optional equality
+ * function or options object to customize its behavior.
  *
- * - Without arguments, just wraps the component, without changing the behavior / props
+ * @template StateType - The specific type of state this hook operates on.
  *
- * - If 2 params are passed (3rd param, mergeProps, is skipped), default behavior
- * is to override ownProps (as stated in the docs), so what remains is everything that's
- * not a state or dispatch prop
+ * @public
+ */
+interface UseSelector<StateType = unknown> {
+    /**
+     * A function that takes a selector function as its first argument.
+     * The selector function is responsible for selecting a part of
+     * the Redux store's state or computing derived data.
+     *
+     * @param selector - A function that receives the current state and returns a part of the state or some derived data.
+     * @param equalityFnOrOptions - An optional equality function or options object for customizing the behavior of the selector.
+     * @returns The selected part of the state or derived data.
+     *
+     * @template TState - The specific type of state this hook operates on.
+     * @template Selected - The type of the value that the selector function will return.
+     */
+    <TState extends StateType = StateType, Selected = unknown>(selector: (state: TState) => Selected, equalityFnOrOptions?: EqualityFn<Selected> | UseSelectorOptions<Selected>): Selected;
+    /**
+     * Creates a "pre-typed" version of {@linkcode useSelector useSelector}
+     * where the `state` type is predefined.
+     *
+     * This allows you to set the `state` type once, eliminating the need to
+     * specify it with every {@linkcode useSelector useSelector} call.
+     *
+     * @returns A pre-typed `useSelector` with the state type already defined.
+     *
+     * @example
+     * ```ts
+     * export const useAppSelector = useSelector.withTypes<RootState>()
+     * ```
+     *
+     * @template OverrideStateType - The specific type of state this hook operates on.
+     *
+     * @since 9.1.0
+     */
+    withTypes: <OverrideStateType extends StateType>() => UseSelector<OverrideStateType>;
+}
+/**
+ * Hook factory, which creates a `useSelector` hook bound to a given context.
  *
- * - When 3rd param is passed, we don't know if ownProps propagate and whether they
- * should be valid component props, because it depends on mergeProps implementation.
- * As such, it is the user's responsibility to extend ownProps interface from state or
- * dispatch props or both when applicable
+ * @param {React.Context} [context=ReactReduxContext] Context passed to your `<Provider>`.
+ * @returns {Function} A `useSelector` hook bound to the specified context.
+ */
+declare function createSelectorHook(context?: React.Context<ReactReduxContextValue<any, any> | null>): UseSelector;
+/**
+ * A hook to access the redux store's state. This hook takes a selector function
+ * as an argument. The selector is called with the store state.
  *
- * @param mapStateToProps
- * @param mapDispatchToProps
- * @param mergeProps
- * @param options
+ * This hook takes an optional equality comparison function as the second parameter
+ * that allows you to customize the way the selected state is compared to determine
+ * whether the component needs to be re-rendered.
+ *
+ * @param {Function} selector the selector function
+ * @param {Function=} equalityFn the function that will be used to determine equality
+ *
+ * @returns {any} the selected state
+ *
+ * @example
+ *
+ * import React from 'react'
+ * import { useSelector } from 'react-redux'
+ *
+ * export const CounterComponent = () => {
+ *   const counter = useSelector(state => state.counter)
+ *   return <div>{counter}</div>
+ * }
  */
-interface Connect<DefaultState = unknown> {
-    (): InferableComponentEnhancer<DispatchProp>;
-    /** mapState only */
-    <TStateProps = {}, no_dispatch = {}, TOwnProps = {}, State = DefaultState>(mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>): InferableComponentEnhancerWithProps<TStateProps & DispatchProp, TOwnProps>;
-    /** mapDispatch only (as a function) */
-    <no_state = {}, TDispatchProps = {}, TOwnProps = {}>(mapStateToProps: null | undefined, mapDispatchToProps: MapDispatchToPropsNonObject<TDispatchProps, TOwnProps>): InferableComponentEnhancerWithProps<TDispatchProps, TOwnProps>;
-    /** mapDispatch only (as an object) */
-    <no_state = {}, TDispatchProps = {}, TOwnProps = {}>(mapStateToProps: null | undefined, mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>): InferableComponentEnhancerWithProps<ResolveThunks<TDispatchProps>, TOwnProps>;
-    /** mapState and mapDispatch (as a function)*/
-    <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, State = DefaultState>(mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>, mapDispatchToProps: MapDispatchToPropsNonObject<TDispatchProps, TOwnProps>): InferableComponentEnhancerWithProps<TStateProps & TDispatchProps, TOwnProps>;
-    /** mapState and mapDispatch (nullish) */
-    <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, State = DefaultState>(mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>, mapDispatchToProps: null | undefined): InferableComponentEnhancerWithProps<TStateProps, TOwnProps>;
-    /** mapState and mapDispatch (as an object) */
-    <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, State = DefaultState>(mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>, mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>): InferableComponentEnhancerWithProps<TStateProps & ResolveThunks<TDispatchProps>, TOwnProps>;
-    /** mergeProps only */
-    <no_state = {}, no_dispatch = {}, TOwnProps = {}, TMergedProps = {}>(mapStateToProps: null | undefined, mapDispatchToProps: null | undefined, mergeProps: MergeProps<undefined, DispatchProp, TOwnProps, TMergedProps>): InferableComponentEnhancerWithProps<TMergedProps, TOwnProps>;
-    /** mapState and mergeProps */
-    <TStateProps = {}, no_dispatch = {}, TOwnProps = {}, TMergedProps = {}, State = DefaultState>(mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>, mapDispatchToProps: null | undefined, mergeProps: MergeProps<TStateProps, DispatchProp, TOwnProps, TMergedProps>): InferableComponentEnhancerWithProps<TMergedProps, TOwnProps>;
-    /** mapDispatch (as a object) and mergeProps */
-    <no_state = {}, TDispatchProps = {}, TOwnProps = {}, TMergedProps = {}>(mapStateToProps: null | undefined, mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>, mergeProps: MergeProps<undefined, TDispatchProps, TOwnProps, TMergedProps>): InferableComponentEnhancerWithProps<TMergedProps, TOwnProps>;
-    /** mapState and options */
-    <TStateProps = {}, no_dispatch = {}, TOwnProps = {}, State = DefaultState>(mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>, mapDispatchToProps: null | undefined, mergeProps: null | undefined, options: ConnectOptions<State, TStateProps, TOwnProps>): InferableComponentEnhancerWithProps<DispatchProp & TStateProps, TOwnProps>;
-    /** mapDispatch (as a function) and options */
-    <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}>(mapStateToProps: null | undefined, mapDispatchToProps: MapDispatchToPropsNonObject<TDispatchProps, TOwnProps>, mergeProps: null | undefined, options: ConnectOptions<{}, TStateProps, TOwnProps>): InferableComponentEnhancerWithProps<TDispatchProps, TOwnProps>;
-    /** mapDispatch (as an object) and options*/
-    <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}>(mapStateToProps: null | undefined, mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>, mergeProps: null | undefined, options: ConnectOptions<{}, TStateProps, TOwnProps>): InferableComponentEnhancerWithProps<ResolveThunks<TDispatchProps>, TOwnProps>;
-    /** mapState,  mapDispatch (as a function), and options */
-    <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, State = DefaultState>(mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>, mapDispatchToProps: MapDispatchToPropsNonObject<TDispatchProps, TOwnProps>, mergeProps: null | undefined, options: ConnectOptions<State, TStateProps, TOwnProps>): InferableComponentEnhancerWithProps<TStateProps & TDispatchProps, TOwnProps>;
-    /** mapState,  mapDispatch (as an object), and options */
-    <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, State = DefaultState>(mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>, mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>, mergeProps: null | undefined, options: ConnectOptions<State, TStateProps, TOwnProps>): InferableComponentEnhancerWithProps<TStateProps & ResolveThunks<TDispatchProps>, TOwnProps>;
-    /** mapState, mapDispatch, mergeProps, and options */
-    <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, TMergedProps = {}, State = DefaultState>(mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>, mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>, mergeProps: MergeProps<TStateProps, TDispatchProps, TOwnProps, TMergedProps>, options?: ConnectOptions<State, TStateProps, TOwnProps, TMergedProps>): InferableComponentEnhancerWithProps<TMergedProps, TOwnProps>;
-}
-declare const _default: Connect<unknown>;
+declare const useSelector: UseSelector<unknown>;
 
@@ -245,128 +328,128 @@ type FixTypeLater = any;
 
+type SelectorFactory<S, TProps, TOwnProps, TFactoryOptions> = (dispatch: Dispatch<Action<string>>, factoryOptions: TFactoryOptions) => Selector<S, TProps, TOwnProps>;
+type Selector<S, TProps, TOwnProps = null> = TOwnProps extends null | undefined ? (state: S) => TProps : (state: S, ownProps: TOwnProps) => TProps;
+type MapStateToProps<TStateProps, TOwnProps, State> = (state: State, ownProps: TOwnProps) => TStateProps;
+type MapStateToPropsFactory<TStateProps, TOwnProps, State> = (initialState: State, ownProps: TOwnProps) => MapStateToProps<TStateProps, TOwnProps, State>;
+type MapStateToPropsParam<TStateProps, TOwnProps, State> = MapStateToPropsFactory<TStateProps, TOwnProps, State> | MapStateToProps<TStateProps, TOwnProps, State> | null | undefined;
+type MapDispatchToPropsFunction<TDispatchProps, TOwnProps> = (dispatch: Dispatch<Action<string>>, ownProps: TOwnProps) => TDispatchProps;
+type MapDispatchToProps<TDispatchProps, TOwnProps> = MapDispatchToPropsFunction<TDispatchProps, TOwnProps> | TDispatchProps;
+type MapDispatchToPropsFactory<TDispatchProps, TOwnProps> = (dispatch: Dispatch<Action<string>>, ownProps: TOwnProps) => MapDispatchToPropsFunction<TDispatchProps, TOwnProps>;
+type MapDispatchToPropsParam<TDispatchProps, TOwnProps> = MapDispatchToPropsFactory<TDispatchProps, TOwnProps> | MapDispatchToProps<TDispatchProps, TOwnProps>;
+type MapDispatchToPropsNonObject<TDispatchProps, TOwnProps> = MapDispatchToPropsFactory<TDispatchProps, TOwnProps> | MapDispatchToPropsFunction<TDispatchProps, TOwnProps>;
+type MergeProps<TStateProps, TDispatchProps, TOwnProps, TMergedProps> = (stateProps: TStateProps, dispatchProps: TDispatchProps, ownProps: TOwnProps) => TMergedProps;
+
+interface ConnectProps {
+    /** A custom Context instance that the component can use to access the store from an alternate Provider using that same Context instance */
+    context?: ReactReduxContextInstance;
+    /** A Redux store instance to be used for subscriptions instead of the store from a Provider */
+    store?: Store;
+}
 /**
- * The frequency of development mode checks.
- *
- * @since 8.1.0
- * @internal
+ * Infers the type of props that a connector will inject into a component.
  */
-type DevModeCheckFrequency = 'never' | 'once' | 'always';
-/**
- * Represents the configuration for development mode checks.
- *
- * @since 9.0.0
- * @internal
- */
-interface DevModeChecks {
-    /**
-     * Overrides the global stability check for the selector.
-     * - `once` - Run only the first time the selector is called.
-     * - `always` - Run every time the selector is called.
-     * - `never` - Never run the stability check.
-     *
-     * @default 'once'
-     *
-     * @since 8.1.0
-     */
-    stabilityCheck: DevModeCheckFrequency;
-    /**
-     * Overrides the global identity function check for the selector.
-     * - `once` - Run only the first time the selector is called.
-     * - `always` - Run every time the selector is called.
-     * - `never` - Never run the identity function check.
-     *
-     * **Note**: Previously referred to as `noopCheck`.
-     *
-     * @default 'once'
-     *
-     * @since 9.0.0
-     */
-    identityFunctionCheck: DevModeCheckFrequency;
+type ConnectedProps<TConnector> = TConnector extends InferableComponentEnhancerWithProps<infer TInjectedProps, any> ? unknown extends TInjectedProps ? TConnector extends InferableComponentEnhancer<infer TInjectedProps> ? TInjectedProps : never : TInjectedProps : never;
+interface ConnectOptions<State = unknown, TStateProps = {}, TOwnProps = {}, TMergedProps = {}> {
+    forwardRef?: boolean;
+    context?: typeof ReactReduxContext;
+    areStatesEqual?: (nextState: State, prevState: State, nextOwnProps: TOwnProps, prevOwnProps: TOwnProps) => boolean;
+    areOwnPropsEqual?: (nextOwnProps: TOwnProps, prevOwnProps: TOwnProps) => boolean;
+    areStatePropsEqual?: (nextStateProps: TStateProps, prevStateProps: TStateProps) => boolean;
+    areMergedPropsEqual?: (nextMergedProps: TMergedProps, prevMergedProps: TMergedProps) => boolean;
 }
-interface UseSelectorOptions<Selected = unknown> {
-    equalityFn?: EqualityFn<Selected>;
-    /**
-     * `useSelector` performs additional checks in development mode to help
-     * identify and warn about potential issues in selector behavior. This
-     * option allows you to customize the behavior of these checks per selector.
-     *
-     * @since 9.0.0
-     */
-    devModeChecks?: Partial<DevModeChecks>;
-}
-interface UseSelector {
-    <TState = unknown, Selected = unknown>(selector: (state: TState) => Selected, equalityFn?: EqualityFn<Selected>): Selected;
-    <TState = unknown, Selected = unknown>(selector: (state: TState) => Selected, options?: UseSelectorOptions<Selected>): Selected;
-}
 /**
- * Hook factory, which creates a `useSelector` hook bound to a given context.
+ * Connects a React component to a Redux store.
  *
- * @param {React.Context} [context=ReactReduxContext] Context passed to your `<Provider>`.
- * @returns {Function} A `useSelector` hook bound to the specified context.
- */
-declare function createSelectorHook(context?: React.Context<ReactReduxContextValue<any, any> | null>): UseSelector;
-/**
- * A hook to access the redux store's state. This hook takes a selector function
- * as an argument. The selector is called with the store state.
+ * - Without arguments, just wraps the component, without changing the behavior / props
  *
- * This hook takes an optional equality comparison function as the second parameter
- * that allows you to customize the way the selected state is compared to determine
- * whether the component needs to be re-rendered.
+ * - If 2 params are passed (3rd param, mergeProps, is skipped), default behavior
+ * is to override ownProps (as stated in the docs), so what remains is everything that's
+ * not a state or dispatch prop
  *
- * @param {Function} selector the selector function
- * @param {Function=} equalityFn the function that will be used to determine equality
+ * - When 3rd param is passed, we don't know if ownProps propagate and whether they
+ * should be valid component props, because it depends on mergeProps implementation.
+ * As such, it is the user's responsibility to extend ownProps interface from state or
+ * dispatch props or both when applicable
  *
- * @returns {any} the selected state
+ * @param mapStateToProps
+ * @param mapDispatchToProps
+ * @param mergeProps
+ * @param options
+ */
+interface Connect<DefaultState = unknown> {
+    (): InferableComponentEnhancer<DispatchProp>;
+    /** mapState only */
+    <TStateProps = {}, no_dispatch = {}, TOwnProps = {}, State = DefaultState>(mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>): InferableComponentEnhancerWithProps<TStateProps & DispatchProp, TOwnProps>;
+    /** mapDispatch only (as a function) */
+    <no_state = {}, TDispatchProps = {}, TOwnProps = {}>(mapStateToProps: null | undefined, mapDispatchToProps: MapDispatchToPropsNonObject<TDispatchProps, TOwnProps>): InferableComponentEnhancerWithProps<TDispatchProps, TOwnProps>;
+    /** mapDispatch only (as an object) */
+    <no_state = {}, TDispatchProps = {}, TOwnProps = {}>(mapStateToProps: null | undefined, mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>): InferableComponentEnhancerWithProps<ResolveThunks<TDispatchProps>, TOwnProps>;
+    /** mapState and mapDispatch (as a function)*/
+    <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, State = DefaultState>(mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>, mapDispatchToProps: MapDispatchToPropsNonObject<TDispatchProps, TOwnProps>): InferableComponentEnhancerWithProps<TStateProps & TDispatchProps, TOwnProps>;
+    /** mapState and mapDispatch (nullish) */
+    <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, State = DefaultState>(mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>, mapDispatchToProps: null | undefined): InferableComponentEnhancerWithProps<TStateProps, TOwnProps>;
+    /** mapState and mapDispatch (as an object) */
+    <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, State = DefaultState>(mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>, mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>): InferableComponentEnhancerWithProps<TStateProps & ResolveThunks<TDispatchProps>, TOwnProps>;
+    /** mergeProps only */
+    <no_state = {}, no_dispatch = {}, TOwnProps = {}, TMergedProps = {}>(mapStateToProps: null | undefined, mapDispatchToProps: null | undefined, mergeProps: MergeProps<undefined, DispatchProp, TOwnProps, TMergedProps>): InferableComponentEnhancerWithProps<TMergedProps, TOwnProps>;
+    /** mapState and mergeProps */
+    <TStateProps = {}, no_dispatch = {}, TOwnProps = {}, TMergedProps = {}, State = DefaultState>(mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>, mapDispatchToProps: null | undefined, mergeProps: MergeProps<TStateProps, DispatchProp, TOwnProps, TMergedProps>): InferableComponentEnhancerWithProps<TMergedProps, TOwnProps>;
+    /** mapDispatch (as a object) and mergeProps */
+    <no_state = {}, TDispatchProps = {}, TOwnProps = {}, TMergedProps = {}>(mapStateToProps: null | undefined, mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>, mergeProps: MergeProps<undefined, TDispatchProps, TOwnProps, TMergedProps>): InferableComponentEnhancerWithProps<TMergedProps, TOwnProps>;
+    /** mapState and options */
+    <TStateProps = {}, no_dispatch = {}, TOwnProps = {}, State = DefaultState>(mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>, mapDispatchToProps: null | undefined, mergeProps: null | undefined, options: ConnectOptions<State, TStateProps, TOwnProps>): InferableComponentEnhancerWithProps<DispatchProp & TStateProps, TOwnProps>;
+    /** mapDispatch (as a function) and options */
+    <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}>(mapStateToProps: null | undefined, mapDispatchToProps: MapDispatchToPropsNonObject<TDispatchProps, TOwnProps>, mergeProps: null | undefined, options: ConnectOptions<{}, TStateProps, TOwnProps>): InferableComponentEnhancerWithProps<TDispatchProps, TOwnProps>;
+    /** mapDispatch (as an object) and options*/
+    <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}>(mapStateToProps: null | undefined, mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>, mergeProps: null | undefined, options: ConnectOptions<{}, TStateProps, TOwnProps>): InferableComponentEnhancerWithProps<ResolveThunks<TDispatchProps>, TOwnProps>;
+    /** mapState,  mapDispatch (as a function), and options */
+    <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, State = DefaultState>(mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>, mapDispatchToProps: MapDispatchToPropsNonObject<TDispatchProps, TOwnProps>, mergeProps: null | undefined, options: ConnectOptions<State, TStateProps, TOwnProps>): InferableComponentEnhancerWithProps<TStateProps & TDispatchProps, TOwnProps>;
+    /** mapState,  mapDispatch (as an object), and options */
+    <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, State = DefaultState>(mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>, mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>, mergeProps: null | undefined, options: ConnectOptions<State, TStateProps, TOwnProps>): InferableComponentEnhancerWithProps<TStateProps & ResolveThunks<TDispatchProps>, TOwnProps>;
+    /** mapState, mapDispatch, mergeProps, and options */
+    <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, TMergedProps = {}, State = DefaultState>(mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>, mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>, mergeProps: MergeProps<TStateProps, TDispatchProps, TOwnProps, TMergedProps>, options?: ConnectOptions<State, TStateProps, TOwnProps, TMergedProps>): InferableComponentEnhancerWithProps<TMergedProps, TOwnProps>;
+}
+declare const _default: Connect<unknown>;
+
+declare function shallowEqual(objA: any, objB: any): boolean;
+
+declare function defaultNoopBatch(callback: () => void): void;
+
+/**
+ * Represents a custom hook that provides a dispatch function
+ * from the Redux store.
  *
- * @example
+ * @template DispatchType - The specific type of the dispatch function.
  *
- * import React from 'react'
- * import { useSelector } from 'react-redux'
- *
- * export const CounterComponent = () => {
- *   const counter = useSelector(state => state.counter)
- *   return <div>{counter}</div>
- * }
+ * @since 9.1.0
+ * @public
  */
-declare const useSelector: UseSelector;
-
-interface ProviderProps<A extends Action<string> = UnknownAction, S = unknown> {
+interface UseDispatch<DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>> {
     /**
-     * The single Redux store in your application.
-     */
-    store: Store<S, A>;
-    /**
-     * An optional server state snapshot. Will be used during initial hydration render if available, to ensure that the UI output is consistent with the HTML generated on the server.
-     */
-    serverState?: S;
-    /**
-     * Optional context to be used internally in react-redux. Use React.createContext() to create a context to be used.
-     * If this is used, you'll need to customize `connect` by supplying the same context provided to the Provider.
-     * Set the initial value to null, and the hooks will error
-     * if this is not overwritten by Provider.
-     */
-    context?: Context<ReactReduxContextValue<S, A> | null>;
-    /**
-     * Determines the frequency of stability checks for all selectors.
-     * This setting overrides the global configuration for
-     * the `useSelector` stability check, allowing you to specify how often
-     * these checks should occur in development mode.
+     * Returns the dispatch function from the Redux store.
      *
-     * @since 8.1.0
+     * @returns The dispatch function from the Redux store.
+     *
+     * @template AppDispatch - The specific type of the dispatch function.
      */
-    stabilityCheck?: DevModeCheckFrequency;
+    <AppDispatch extends DispatchType = DispatchType>(): AppDispatch;
     /**
-     * Determines the frequency of identity function checks for all selectors.
-     * This setting overrides the global configuration for
-     * the `useSelector` identity function check, allowing you to specify how often
-     * these checks should occur in development mode.
+     * Creates a "pre-typed" version of {@linkcode useDispatch useDispatch}
+     * where the type of the `dispatch` function is predefined.
      *
-     * **Note**: Previously referred to as `noopCheck`.
+     * This allows you to set the `dispatch` type once, eliminating the need to
+     * specify it with every {@linkcode useDispatch useDispatch} call.
      *
-     * @since 9.0.0
+     * @returns A pre-typed `useDispatch` with the dispatch type already defined.
+     *
+     * @example
+     * ```ts
+     * export const useAppDispatch = useDispatch.withTypes<AppDispatch>()
+     * ```
+     *
+     * @template OverrideDispatchType - The specific type of the dispatch function.
+     *
+     * @since 9.1.0
      */
-    identityFunctionCheck?: DevModeCheckFrequency;
-    children: ReactNode;
+    withTypes: <OverrideDispatchType extends DispatchType>() => UseDispatch<OverrideDispatchType>;
 }
-declare function Provider<A extends Action<string> = UnknownAction, S = unknown>({ store, context, children, serverState, stabilityCheck, identityFunctionCheck, }: ProviderProps<A, S>): React$1.JSX.Element;
-
 /**
@@ -378,3 +461,3 @@ * Hook factory, which creates a `useDispatch` hook bound to a given context.
  */
-declare function createDispatchHook<S = unknown, A extends Action<string> = UnknownAction>(context?: Context<ReactReduxContextValue<S, A> | null>): <AppDispatch extends Dispatch<A> = Dispatch<A>>() => AppDispatch;
+declare function createDispatchHook<StateType = unknown, ActionType extends Action = UnknownAction>(context?: Context<ReactReduxContextValue<StateType, ActionType> | null>): UseDispatch<Dispatch<ActionType>>;
 /**
@@ -401,5 +484,58 @@ * A hook to access the redux `dispatch` function.
  */
-declare const useDispatch: <AppDispatch extends Dispatch<UnknownAction> = Dispatch<UnknownAction>>() => AppDispatch;
+declare const useDispatch: UseDispatch<Dispatch<UnknownAction>>;
 
 /**
+ * Represents a type that extracts the action type from a given Redux store.
+ *
+ * @template StoreType - The specific type of the Redux store.
+ *
+ * @since 9.1.0
+ * @internal
+ */
+type ExtractStoreActionType<StoreType extends Store> = StoreType extends Store<any, infer ActionType> ? ActionType : never;
+/**
+ * Represents a custom hook that provides access to the Redux store.
+ *
+ * @template StoreType - The specific type of the Redux store that gets returned.
+ *
+ * @since 9.1.0
+ * @public
+ */
+interface UseStore<StoreType extends Store> {
+    /**
+     * Returns the Redux store instance.
+     *
+     * @returns The Redux store instance.
+     */
+    (): StoreType;
+    /**
+     * Returns the Redux store instance with specific state and action types.
+     *
+     * @returns The Redux store with the specified state and action types.
+     *
+     * @template StateType - The specific type of the state used in the store.
+     * @template ActionType - The specific type of the actions used in the store.
+     */
+    <StateType extends ReturnType<StoreType['getState']> = ReturnType<StoreType['getState']>, ActionType extends Action = ExtractStoreActionType<Store>>(): Store<StateType, ActionType>;
+    /**
+     * Creates a "pre-typed" version of {@linkcode useStore useStore}
+     * where the type of the Redux `store` is predefined.
+     *
+     * This allows you to set the `store` type once, eliminating the need to
+     * specify it with every {@linkcode useStore useStore} call.
+     *
+     * @returns A pre-typed `useStore` with the store type already defined.
+     *
+     * @example
+     * ```ts
+     * export const useAppStore = useStore.withTypes<AppStore>()
+     * ```
+     *
+     * @template OverrideStoreType - The specific type of the Redux store that gets returned.
+     *
+     * @since 9.1.0
+     */
+    withTypes: <OverrideStoreType extends StoreType>() => UseStore<OverrideStoreType>;
+}
+/**
  * Hook factory, which creates a `useStore` hook bound to a given context.
@@ -410,3 +546,3 @@ *
  */
-declare function createStoreHook<S = unknown, A extends Action = UnknownAction>(context?: Context<ReactReduxContextValue<S, A> | null>): <State = S, Action2 extends Action = A>() => Store<State, Action2, {}>;
+declare function createStoreHook<StateType = unknown, ActionType extends Action = Action>(context?: Context<ReactReduxContextValue<StateType, ActionType> | null>): UseStore<Store<StateType, ActionType, {}>>;
 /**
@@ -427,8 +563,4 @@ * A hook to access the redux store.
  */
-declare const useStore: <State = unknown, Action2 extends Action = UnknownAction>() => Store<State, Action2, {}>;
+declare const useStore: UseStore<Store<unknown, Action, {}>>;
 
-declare function shallowEqual(objA: any, objB: any): boolean;
-
-declare function defaultNoopBatch(callback: () => void): void;
-
 /**
@@ -440,2 +572,2 @@ * @deprecated As of React 18, batching is enabled by default for ReactDOM and React Native.
 
-export { AnyIfEmpty, Connect, ConnectProps, ConnectPropsMaybeWithoutContext, ConnectedComponent, ConnectedProps, DispatchProp, DistributiveOmit, EqualityFn, ExtendedEqualityFn, FixTypeLater, GetLibraryManagedProps, GetProps, HandleThunkActionCreator, InferThunkActionCreatorType, InferableComponentEnhancer, InferableComponentEnhancerWithProps, MapDispatchToProps, MapDispatchToPropsFactory, MapDispatchToPropsFunction, MapDispatchToPropsNonObject, MapDispatchToPropsParam, MapStateToProps, MapStateToPropsFactory, MapStateToPropsParam, Mapped, Matching, MergeProps, NoInfer, Provider, ProviderProps, ReactReduxContext, ReactReduxContextValue, ResolveThunks, Selector, SelectorFactory, Shared, Subscription, TypedUseSelectorHook, batch, _default as connect, createDispatchHook, createSelectorHook, createStoreHook, shallowEqual, useDispatch, useSelector, useStore };
+export { AnyIfEmpty, Connect, ConnectProps, ConnectPropsMaybeWithoutContext, ConnectedComponent, ConnectedProps, DispatchProp, DistributiveOmit, EqualityFn, ExtendedEqualityFn, FixTypeLater, GetLibraryManagedProps, GetProps, HandleThunkActionCreator, InferThunkActionCreatorType, InferableComponentEnhancer, InferableComponentEnhancerWithProps, MapDispatchToProps, MapDispatchToPropsFactory, MapDispatchToPropsFunction, MapDispatchToPropsNonObject, MapDispatchToPropsParam, MapStateToProps, MapStateToPropsFactory, MapStateToPropsParam, Mapped, Matching, MergeProps, NoInfer, Provider, ProviderProps, ReactReduxContext, ReactReduxContextValue, ResolveThunks, Selector, SelectorFactory, Shared, Subscription, TypedUseSelectorHook, UseDispatch, UseSelector, UseStore, batch, _default as connect, createDispatchHook, createSelectorHook, createStoreHook, shallowEqual, useDispatch, useSelector, useStore };

dist/react-redux.legacy-esm.js

@@ -97,3 +97,3 @@ var __defProp = Object.defineProperty;
   const useReduxContext2 = context === ReactReduxContext ? useReduxContext : createReduxContextHook(context);
-  return function useSelector2(selector, equalityFnOrOptions = {}) {
+  const useSelector2 = (selector, equalityFnOrOptions = {}) => {
     const { equalityFn = refEquality, devModeChecks = {} } = typeof equalityFnOrOptions === "function" ? { equalityFn: equalityFnOrOptions } : equalityFnOrOptions;
@@ -187,2 +187,6 @@ if (process.env.NODE_ENV !== "production") {
   };
+  Object.assign(useSelector2, {
+    withTypes: () => useSelector2
+  });
+  return useSelector2;
 }
@@ -400,3 +404,3 @@ var useSelector = /* @__PURE__ */ createSelectorHook();
     return false;
-  let proto = Object.getPrototypeOf(obj);
+  const proto = Object.getPrototypeOf(obj);
   if (proto === null)
@@ -540,3 +544,3 @@ return true;
     get() {
-      let listeners = [];
+      const listeners = [];
       let listener = first;
@@ -551,3 +555,3 @@ while (listener) {
       let isSubscribed = true;
-      let listener = last = {
+      const listener = last = {
         callback,
@@ -1104,13 +1108,14 @@ next: null,
 function createStoreHook(context = ReactReduxContext) {
-  const useReduxContext2 = (
+  const useReduxContext2 = context === ReactReduxContext ? useReduxContext : (
     // @ts-ignore
-    context === ReactReduxContext ? useReduxContext : (
-      // @ts-ignore
-      createReduxContextHook(context)
-    )
+    createReduxContextHook(context)
   );
-  return function useStore2() {
+  const useStore2 = () => {
     const { store } = useReduxContext2();
     return store;
   };
+  Object.assign(useStore2, {
+    withTypes: () => useStore2
+  });
+  return useStore2;
 }
@@ -1121,10 +1126,11 @@ var useStore = /* @__PURE__ */ createStoreHook();
 function createDispatchHook(context = ReactReduxContext) {
-  const useStore2 = (
-    // @ts-ignore
-    context === ReactReduxContext ? useStore : createStoreHook(context)
-  );
-  return function useDispatch2() {
+  const useStore2 = context === ReactReduxContext ? useStore : createStoreHook(context);
+  const useDispatch2 = () => {
     const store = useStore2();
     return store.dispatch;
   };
+  Object.assign(useDispatch2, {
+    withTypes: () => useDispatch2
+  });
+  return useDispatch2;
 }
@@ -1131,0 +1137,0 @@ var useDispatch = /* @__PURE__ */ createDispatchHook();

LICENSE.md

@@ -0,0 +0,0 @@ The MIT License (MIT)

package.json

 {
   "name": "react-redux",
-  "version": "9.0.4",
+  "version": "9.1.0",
   "description": "Official React bindings for Redux",
@@ -43,3 +43,4 @@ "keywords": [
     "format": "prettier --write \"{src,test}/**/*.{js,ts,tsx}\" \"docs/**/*.md\"",
-    "lint": "eslint src --ext ts,tsx,js test/utils test/components test/hooks",
+    "lint": "eslint src test",
+    "lint:fix": "eslint src test --fix",
     "prepare": "yarn clean && yarn build",
@@ -93,4 +94,4 @@ "pretest": "yarn lint",
     "@types/react-native": "^0.67.4",
-    "@typescript-eslint/eslint-plugin": "^4.28.0",
-    "@typescript-eslint/parser": "^4.28.0",
+    "@typescript-eslint/eslint-plugin": "^6.17.0",
+    "@typescript-eslint/parser": "^6.17.0",
     "babel-eslint": "^10.1.0",
@@ -100,7 +101,7 @@ "babel-jest": "^29",
     "cross-env": "^7.0.2",
-    "eslint": "^7.12.0",
-    "eslint-config-prettier": "^6.14.0",
-    "eslint-plugin-import": "^2.22.1",
-    "eslint-plugin-prettier": "^3.1.4",
-    "eslint-plugin-react": "^7.21.5",
+    "eslint": "^8.56.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-prettier": "^5.1.2",
+    "eslint-plugin-react": "^7.33.2",
     "glob": "^7.1.6",
@@ -110,3 +111,3 @@ "jest": "^29",
     "metro-react-native-babel-preset": "^0.76.6",
-    "prettier": "^2.1.2",
+    "prettier": "^3.1.1",
     "react": "18.2.0",
@@ -113,0 +114,0 @@ "react-dom": "18.2.0",

README.md

@@ -0,0 +0,0 @@ # React Redux

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

734554

increased by0.95%

Lines of code

4039

increased by3.86%

No dependency changes