Consolidate connect implementation

Author: markerikson

src/components/connect.tsx

@@ -19,7 +19,7 @@ import defaultSelectorFactory, {
   MapDispatchToPropsParam,
   MergeProps,
   MapDispatchToPropsNonObject,
-  SelectorFactory,
+  SelectorFactoryOptions,
 } from '../connect/selectorFactory'
 import defaultMapDispatchToPropsFactories from '../connect/mapDispatchToProps'
 import defaultMapStateToPropsFactories from '../connect/mapStateToProps'
@@ -205,152 +205,406 @@ export interface ConnectProps {
   store?: Store
 }
 
-export interface ConnectAdvancedOptions {
-  shouldHandleStateChanges?: boolean
-  forwardRef?: boolean
-  context?: typeof ReactReduxContext
-  pure?: boolean
-}
-
-function connectAdvanced<S, TProps, TOwnProps, TFactoryOptions = {}>(
-  /*
-    selectorFactory is a func that is responsible for returning the selector function used to
-    compute new props from state, props, and dispatch. For example:
-
-      export default connectAdvanced((dispatch, options) => (state, props) => ({
-        thing: state.things[props.thingId],
-        saveThing: fields => dispatch(actionCreators.saveThing(props.thingId, fields)),
-      }))(YourComponent)
-
-    Access to dispatch is provided to the factory so selectorFactories can bind actionCreators
-    outside of their selector as an optimization. Options passed to connectAdvanced are passed to
-    the selectorFactory, along with displayName and WrappedComponent, as the second argument.
-
-    Note that selectorFactory is responsible for all caching/memoization of inbound and outbound
-    props. Do not use connectAdvanced directly without memoizing results between calls to your
-    selector, otherwise the Connect component will re-render on every state or props change.
-  */
-  selectorFactory: SelectorFactory<S, TProps, unknown, unknown>,
-  // options object:
-  {
-    // determines whether this HOC subscribes to store changes
-    shouldHandleStateChanges = true,
+function match<T>(
+  arg: unknown,
+  factories: ((value: unknown) => T)[],
+  name: string
+): T {
+  for (let i = factories.length - 1; i >= 0; i--) {
+    const result = factories[i](arg)
+    if (result) return result
+  }
 
-    // use React's forwardRef to expose a ref of the wrapped component
-    forwardRef = false,
+  return ((dispatch: Dispatch, options: { wrappedComponentName: string }) => {
+    throw new Error(
+      `Invalid value of type ${typeof arg} for ${name} argument when connecting component ${
+        options.wrappedComponentName
+      }.`
+    )
+  }) as any
+}
 
-    // the context consumer to use
-    context = ReactReduxContext,
+function strictEqual(a: unknown, b: unknown) {
+  return a === b
+}
 
-    // additional options are passed through to the selectorFactory
-    ...connectOptions
-  }: ConnectAdvancedOptions & Partial<TFactoryOptions> = {}
-) {
-  const Context = context
+/**
+ * Infers the type of props that a connector will inject into a component.
+ */
+export type ConnectedProps<TConnector> =
+  TConnector extends InferableComponentEnhancerWithProps<
+    infer TInjectedProps,
+    any
+  >
+    ? unknown extends TInjectedProps
+      ? TConnector extends InferableComponentEnhancer<infer TInjectedProps>
+        ? TInjectedProps
+        : never
+      : TInjectedProps
+    : never
 
-  type WrappedComponentProps = TOwnProps & ConnectProps
+export interface ConnectOptions<
+  State = DefaultRootState,
+  TStateProps = {},
+  TOwnProps = {},
+  TMergedProps = {}
+> {
+  forwardRef?: boolean
+  context?: typeof ReactReduxContext
+  pure?: boolean
+  areStatesEqual?: (nextState: State, prevState: State) => boolean
 
-  const wrapWithConnect: AdvancedComponentDecorator<
-    TProps,
-    WrappedComponentProps
-  > = (WrappedComponent) => {
-    if (
-      process.env.NODE_ENV !== 'production' &&
-      !isValidElementType(WrappedComponent)
-    ) {
-      throw new Error(
-        `You must pass a component to the function returned by connect. Instead received ${stringifyComponent(
-          WrappedComponent
-        )}`
-      )
-    }
+  areOwnPropsEqual?: (
+    nextOwnProps: TOwnProps,
+    prevOwnProps: TOwnProps
+  ) => boolean
 
-    const wrappedComponentName =
-      WrappedComponent.displayName || WrappedComponent.name || 'Component'
+  areStatePropsEqual?: (
+    nextStateProps: TStateProps,
+    prevStateProps: TStateProps
+  ) => boolean
+  areMergedPropsEqual?: (
+    nextMergedProps: TMergedProps,
+    prevMergedProps: TMergedProps
+  ) => boolean
+}
 
-    const displayName = `Connect(${wrappedComponentName})`
+/* @public */
+function connect(): InferableComponentEnhancer<DispatchProp>
 
-    const selectorFactoryOptions = {
-      ...connectOptions,
-      shouldHandleStateChanges,
-      displayName,
-      wrappedComponentName,
-      WrappedComponent,
-    }
+/* @public */
+function connect<
+  TStateProps = {},
+  no_dispatch = {},
+  TOwnProps = {},
+  State = DefaultRootState
+>(
+  mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>
+): InferableComponentEnhancerWithProps<TStateProps & DispatchProp, TOwnProps>
 
-    const { pure } = connectOptions
+/* @public */
+function connect<no_state = {}, TDispatchProps = {}, TOwnProps = {}>(
+  mapStateToProps: null | undefined,
+  mapDispatchToProps: MapDispatchToPropsNonObject<TDispatchProps, TOwnProps>
+): InferableComponentEnhancerWithProps<TDispatchProps, TOwnProps>
 
-    // If we aren't running in "pure" mode, we don't want to memoize values.
-    // To avoid conditionally calling hooks, we fall back to a tiny wrapper
-    // that just executes the given callback immediately.
-    const usePureOnlyMemo = pure
-      ? useMemo
-      : (callback: () => void) => callback()
+/* @public */
+function connect<no_state = {}, TDispatchProps = {}, TOwnProps = {}>(
+  mapStateToProps: null | undefined,
+  mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>
+): InferableComponentEnhancerWithProps<ResolveThunks<TDispatchProps>, TOwnProps>
 
-    function ConnectFunction<TOwnProps>(props: ConnectProps & TOwnProps) {
-      const [propsContext, reactReduxForwardedRef, wrapperProps] =
-        useMemo(() => {
-          // Distinguish between actual "data" props that were passed to the wrapper component,
-          // and values needed to control behavior (forwarded refs, alternate context instances).
-          // To maintain the wrapperProps object reference, memoize this destructuring.
-          const { reactReduxForwardedRef, ...wrapperProps } = props
-          return [props.context, reactReduxForwardedRef, wrapperProps]
-        }, [props])
+/* @public */
+function connect<
+  TStateProps = {},
+  TDispatchProps = {},
+  TOwnProps = {},
+  State = DefaultRootState
+>(
+  mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>,
+  mapDispatchToProps: MapDispatchToPropsNonObject<TDispatchProps, TOwnProps>
+): InferableComponentEnhancerWithProps<TStateProps & TDispatchProps, TOwnProps>
 
-      const ContextToUse: ReactReduxContextInstance = useMemo(() => {
-        // Users may optionally pass in a custom context instance to use instead of our ReactReduxContext.
-        // Memoize the check that determines which context instance we should use.
-        return propsContext &&
-          propsContext.Consumer &&
-          // @ts-ignore
-          isContextConsumer(<propsContext.Consumer />)
-          ? propsContext
-          : Context
-      }, [propsContext, Context])
+/* @public */
+function connect<
+  TStateProps = {},
+  TDispatchProps = {},
+  TOwnProps = {},
+  State = DefaultRootState
+>(
+  mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>,
+  mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>
+): InferableComponentEnhancerWithProps<
+  TStateProps & ResolveThunks<TDispatchProps>,
+  TOwnProps
+>
 
-      // Retrieve the store and ancestor subscription via context, if available
-      const contextValue = useContext(ContextToUse)
+/* @public */
+function connect<
+  no_state = {},
+  no_dispatch = {},
+  TOwnProps = {},
+  TMergedProps = {}
+>(
+  mapStateToProps: null | undefined,
+  mapDispatchToProps: null | undefined,
+  mergeProps: MergeProps<undefined, undefined, TOwnProps, TMergedProps>
+): InferableComponentEnhancerWithProps<TMergedProps, TOwnProps>
 
-      // The store _must_ exist as either a prop or in context.
-      // We'll check to see if it _looks_ like a Redux store first.
-      // This allows us to pass through a `store` prop that is just a plain value.
-      const didStoreComeFromProps =
-        Boolean(props.store) &&
-        Boolean(props.store!.getState) &&
-        Boolean(props.store!.dispatch)
-      const didStoreComeFromContext =
-        Boolean(contextValue) && Boolean(contextValue!.store)
+/* @public */
+function connect<
+  TStateProps = {},
+  no_dispatch = {},
+  TOwnProps = {},
+  TMergedProps = {},
+  State = DefaultRootState
+>(
+  mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>,
+  mapDispatchToProps: null | undefined,
+  mergeProps: MergeProps<TStateProps, undefined, TOwnProps, TMergedProps>
+): InferableComponentEnhancerWithProps<TMergedProps, TOwnProps>
 
-      if (
-        process.env.NODE_ENV !== 'production' &&
-        !didStoreComeFromProps &&
-        !didStoreComeFromContext
-      ) {
-        throw new Error(
-          `Could not find "store" in the context of ` +
-            `"${displayName}". Either wrap the root component in a <Provider>, ` +
-            `or pass a custom React context provider to <Provider> and the corresponding ` +
-            `React context consumer to ${displayName} in connect options.`
-        )
-      }
+/* @public */
+function connect<
+  no_state = {},
+  TDispatchProps = {},
+  TOwnProps = {},
+  TMergedProps = {}
+>(
+  mapStateToProps: null | undefined,
+  mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>,
+  mergeProps: MergeProps<undefined, TDispatchProps, TOwnProps, TMergedProps>
+): InferableComponentEnhancerWithProps<TMergedProps, TOwnProps>
 
-      // Based on the previous check, one of these must be true
-      const store: Store = didStoreComeFromProps
-        ? props.store!
-        : contextValue!.store
+/* @public */
+// @ts-ignore
+function connect<
+  TStateProps = {},
+  no_dispatch = {},
+  TOwnProps = {},
+  State = DefaultRootState
+>(
+  mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>,
+  mapDispatchToProps: null | undefined,
+  mergeProps: null | undefined,
+  options: ConnectOptions<State, TStateProps, TOwnProps>
+): InferableComponentEnhancerWithProps<DispatchProp & TStateProps, TOwnProps>
 
-      const childPropsSelector = useMemo(() => {
-        // The child props selector needs the store reference as an input.
-        // Re-create this selector whenever the store changes.
-        return selectorFactory(store.dispatch, selectorFactoryOptions)
-      }, [store])
+/* @public */
+function connect<TStateProps = {}, TDispatchProps = {}, TOwnProps = {}>(
+  mapStateToProps: null | undefined,
+  mapDispatchToProps: MapDispatchToPropsNonObject<TDispatchProps, TOwnProps>,
+  mergeProps: null | undefined,
+  options: ConnectOptions<{}, TStateProps, TOwnProps>
+): InferableComponentEnhancerWithProps<TDispatchProps, TOwnProps>
 
-      const [subscription, notifyNestedSubs] = useMemo(() => {
-        if (!shouldHandleStateChanges) return NO_SUBSCRIPTION_ARRAY
+/* @public */
+function connect<TStateProps = {}, TDispatchProps = {}, TOwnProps = {}>(
+  mapStateToProps: null | undefined,
+  mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>,
+  mergeProps: null | undefined,
+  options: ConnectOptions<{}, TStateProps, TOwnProps>
+): InferableComponentEnhancerWithProps<ResolveThunks<TDispatchProps>, TOwnProps>
 
-        // This Subscription's source should match where store came from: props vs. context. A component
-        // connected to the store via props shouldn't use subscription from context, or vice versa.
-        const subscription = createSubscription(
+/* @public */
+function connect<
+  TStateProps = {},
+  TDispatchProps = {},
+  TOwnProps = {},
+  State = DefaultRootState
+>(
+  mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>,
+  mapDispatchToProps: MapDispatchToPropsNonObject<TDispatchProps, TOwnProps>,
+  mergeProps: null | undefined,
+  options: ConnectOptions<State, TStateProps, TOwnProps>
+): InferableComponentEnhancerWithProps<TStateProps & TDispatchProps, TOwnProps>
+
+/* @public */
+function connect<
+  TStateProps = {},
+  TDispatchProps = {},
+  TOwnProps = {},
+  State = DefaultRootState
+>(
+  mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>,
+  mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>,
+  mergeProps: null | undefined,
+  options: ConnectOptions<State, TStateProps, TOwnProps>
+): InferableComponentEnhancerWithProps<
+  TStateProps & ResolveThunks<TDispatchProps>,
+  TOwnProps
+>
+
+/* @public */
+function connect<
+  TStateProps = {},
+  TDispatchProps = {},
+  TOwnProps = {},
+  TMergedProps = {},
+  State = DefaultRootState
+>(
+  mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>,
+  mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>,
+  mergeProps: MergeProps<TStateProps, TDispatchProps, TOwnProps, TMergedProps>,
+  options?: ConnectOptions<State, TStateProps, TOwnProps, TMergedProps>
+): InferableComponentEnhancerWithProps<TMergedProps, TOwnProps>
+
+/**
+ * Connects a React component to a Redux store.
+ *
+ * - Without arguments, just wraps the component, without changing the behavior / props
+ *
+ * - 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
+ *
+ * - 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 mapStateToProps A function that extracts values from state
+ * @param mapDispatchToProps Setup for dispatching actions
+ * @param mergeProps Optional callback to merge state and dispatch props together
+ * @param options Options for configuring the connection
+ *
+ */
+function connect<
+  TStateProps = {},
+  TDispatchProps = {},
+  TOwnProps = {},
+  TMergedProps = {},
+  State = DefaultRootState
+>(
+  mapStateToProps?: MapStateToPropsParam<TStateProps, TOwnProps, State>,
+  mapDispatchToProps?: MapDispatchToPropsParam<TDispatchProps, TOwnProps>,
+  mergeProps?: MergeProps<TStateProps, TDispatchProps, TOwnProps, TMergedProps>,
+  {
+    pure = true,
+    areStatesEqual = strictEqual,
+    areOwnPropsEqual = shallowEqual,
+    areStatePropsEqual = shallowEqual,
+    areMergedPropsEqual = shallowEqual,
+
+    // use React's forwardRef to expose a ref of the wrapped component
+    forwardRef = false,
+
+    // the context consumer to use
+    context = ReactReduxContext,
+  }: ConnectOptions<unknown, unknown, unknown, unknown> = {}
+): unknown {
+  const Context = context
+
+  type WrappedComponentProps = TOwnProps & ConnectProps
+
+  const initMapStateToProps = match(
+    mapStateToProps,
+    // @ts-ignore
+    defaultMapStateToPropsFactories,
+    'mapStateToProps'
+  )!
+  const initMapDispatchToProps = match(
+    mapDispatchToProps,
+    // @ts-ignore
+    defaultMapDispatchToPropsFactories,
+    'mapDispatchToProps'
+  )!
+  const initMergeProps = match(
+    mergeProps,
+    // @ts-ignore
+    defaultMergePropsFactories,
+    'mergeProps'
+  )!
+
+  const shouldHandleStateChanges = Boolean(mapStateToProps)
+
+  const wrapWithConnect: AdvancedComponentDecorator<
+    TOwnProps,
+    WrappedComponentProps
+  > = (WrappedComponent) => {
+    if (
+      process.env.NODE_ENV !== 'production' &&
+      !isValidElementType(WrappedComponent)
+    ) {
+      throw new Error(
+        `You must pass a component to the function returned by connect. Instead received ${stringifyComponent(
+          WrappedComponent
+        )}`
+      )
+    }
+
+    const wrappedComponentName =
+      WrappedComponent.displayName || WrappedComponent.name || 'Component'
+
+    const displayName = `Connect(${wrappedComponentName})`
+
+    const selectorFactoryOptions: SelectorFactoryOptions<any, any, any, any> = {
+      pure,
+      shouldHandleStateChanges,
+      displayName,
+      wrappedComponentName,
+      WrappedComponent,
+      initMapStateToProps,
+      initMapDispatchToProps,
+      // @ts-ignore
+      initMergeProps,
+      areStatesEqual,
+      areStatePropsEqual,
+      areOwnPropsEqual,
+      areMergedPropsEqual,
+    }
+
+    // If we aren't running in "pure" mode, we don't want to memoize values.
+    // To avoid conditionally calling hooks, we fall back to a tiny wrapper
+    // that just executes the given callback immediately.
+    const usePureOnlyMemo = pure
+      ? useMemo
+      : (callback: () => void) => callback()
+
+    function ConnectFunction<TOwnProps>(props: ConnectProps & TOwnProps) {
+      const [propsContext, reactReduxForwardedRef, wrapperProps] =
+        useMemo(() => {
+          // Distinguish between actual "data" props that were passed to the wrapper component,
+          // and values needed to control behavior (forwarded refs, alternate context instances).
+          // To maintain the wrapperProps object reference, memoize this destructuring.
+          const { reactReduxForwardedRef, ...wrapperProps } = props
+          return [props.context, reactReduxForwardedRef, wrapperProps]
+        }, [props])
+
+      const ContextToUse: ReactReduxContextInstance = useMemo(() => {
+        // Users may optionally pass in a custom context instance to use instead of our ReactReduxContext.
+        // Memoize the check that determines which context instance we should use.
+        return propsContext &&
+          propsContext.Consumer &&
+          // @ts-ignore
+          isContextConsumer(<propsContext.Consumer />)
+          ? propsContext
+          : Context
+      }, [propsContext, Context])
+
+      // Retrieve the store and ancestor subscription via context, if available
+      const contextValue = useContext(ContextToUse)
+
+      // The store _must_ exist as either a prop or in context.
+      // We'll check to see if it _looks_ like a Redux store first.
+      // This allows us to pass through a `store` prop that is just a plain value.
+      const didStoreComeFromProps =
+        Boolean(props.store) &&
+        Boolean(props.store!.getState) &&
+        Boolean(props.store!.dispatch)
+      const didStoreComeFromContext =
+        Boolean(contextValue) && Boolean(contextValue!.store)
+
+      if (
+        process.env.NODE_ENV !== 'production' &&
+        !didStoreComeFromProps &&
+        !didStoreComeFromContext
+      ) {
+        throw new Error(
+          `Could not find "store" in the context of ` +
+            `"${displayName}". Either wrap the root component in a <Provider>, ` +
+            `or pass a custom React context provider to <Provider> and the corresponding ` +
+            `React context consumer to ${displayName} in connect options.`
+        )
+      }
+
+      // Based on the previous check, one of these must be true
+      const store: Store = didStoreComeFromProps
+        ? props.store!
+        : contextValue!.store
+
+      const childPropsSelector = useMemo(() => {
+        // The child props selector needs the store reference as an input.
+        // Re-create this selector whenever the store changes.
+        return defaultSelectorFactory(store.dispatch, selectorFactoryOptions)
+      }, [store])
+
+      const [subscription, notifyNestedSubs] = useMemo(() => {
+        if (!shouldHandleStateChanges) return NO_SUBSCRIPTION_ARRAY
+
+        // This Subscription's source should match where store came from: props vs. context. A component
+        // connected to the store via props shouldn't use subscription from context, or vice versa.
+        const subscription = createSubscription(
           store,
           didStoreComeFromProps ? undefined : contextValue!.subscription
         )
@@ -524,301 +778,4 @@ function connectAdvanced<S, TProps, TOwnProps, TFactoryOptions = {}>(
   return wrapWithConnect
 }
 
-function match<T>(
-  arg: unknown,
-  factories: ((value: unknown) => T)[],
-  name: string
-): T {
-  for (let i = factories.length - 1; i >= 0; i--) {
-    const result = factories[i](arg)
-    if (result) return result
-  }
-
-  return ((dispatch: Dispatch, options: { wrappedComponentName: string }) => {
-    throw new Error(
-      `Invalid value of type ${typeof arg} for ${name} argument when connecting component ${
-        options.wrappedComponentName
-      }.`
-    )
-  }) as any
-}
-
-function strictEqual(a: unknown, b: unknown) {
-  return a === b
-}
-
-/**
- * Infers the type of props that a connector will inject into a component.
- */
-export type ConnectedProps<TConnector> =
-  TConnector extends InferableComponentEnhancerWithProps<
-    infer TInjectedProps,
-    any
-  >
-    ? unknown extends TInjectedProps
-      ? TConnector extends InferableComponentEnhancer<infer TInjectedProps>
-        ? TInjectedProps
-        : never
-      : TInjectedProps
-    : never
-
-export interface ConnectOptions<
-  State = DefaultRootState,
-  TStateProps = {},
-  TOwnProps = {},
-  TMergedProps = {}
-> extends ConnectAdvancedOptions {
-  pure?: boolean
-  areStatesEqual?: (nextState: State, prevState: State) => boolean
-
-  areOwnPropsEqual?: (
-    nextOwnProps: TOwnProps,
-    prevOwnProps: TOwnProps
-  ) => boolean
-
-  areStatePropsEqual?: (
-    nextStateProps: TStateProps,
-    prevStateProps: TStateProps
-  ) => boolean
-  areMergedPropsEqual?: (
-    nextMergedProps: TMergedProps,
-    prevMergedProps: TMergedProps
-  ) => boolean
-  forwardRef?: boolean
-}
-
-/* @public */
-function connect(): InferableComponentEnhancer<DispatchProp>
-
-/* @public */
-function connect<
-  TStateProps = {},
-  no_dispatch = {},
-  TOwnProps = {},
-  State = DefaultRootState
->(
-  mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>
-): InferableComponentEnhancerWithProps<TStateProps & DispatchProp, TOwnProps>
-
-/* @public */
-function connect<no_state = {}, TDispatchProps = {}, TOwnProps = {}>(
-  mapStateToProps: null | undefined,
-  mapDispatchToProps: MapDispatchToPropsNonObject<TDispatchProps, TOwnProps>
-): InferableComponentEnhancerWithProps<TDispatchProps, TOwnProps>
-
-/* @public */
-function connect<no_state = {}, TDispatchProps = {}, TOwnProps = {}>(
-  mapStateToProps: null | undefined,
-  mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>
-): InferableComponentEnhancerWithProps<ResolveThunks<TDispatchProps>, TOwnProps>
-
-/* @public */
-function connect<
-  TStateProps = {},
-  TDispatchProps = {},
-  TOwnProps = {},
-  State = DefaultRootState
->(
-  mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>,
-  mapDispatchToProps: MapDispatchToPropsNonObject<TDispatchProps, TOwnProps>
-): InferableComponentEnhancerWithProps<TStateProps & TDispatchProps, TOwnProps>
-
-/* @public */
-function connect<
-  TStateProps = {},
-  TDispatchProps = {},
-  TOwnProps = {},
-  State = DefaultRootState
->(
-  mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>,
-  mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>
-): InferableComponentEnhancerWithProps<
-  TStateProps & ResolveThunks<TDispatchProps>,
-  TOwnProps
->
-
-/* @public */
-function connect<
-  no_state = {},
-  no_dispatch = {},
-  TOwnProps = {},
-  TMergedProps = {}
->(
-  mapStateToProps: null | undefined,
-  mapDispatchToProps: null | undefined,
-  mergeProps: MergeProps<undefined, undefined, TOwnProps, TMergedProps>
-): InferableComponentEnhancerWithProps<TMergedProps, TOwnProps>
-
-/* @public */
-function connect<
-  TStateProps = {},
-  no_dispatch = {},
-  TOwnProps = {},
-  TMergedProps = {},
-  State = DefaultRootState
->(
-  mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>,
-  mapDispatchToProps: null | undefined,
-  mergeProps: MergeProps<TStateProps, undefined, TOwnProps, TMergedProps>
-): InferableComponentEnhancerWithProps<TMergedProps, TOwnProps>
-
-/* @public */
-function connect<
-  no_state = {},
-  TDispatchProps = {},
-  TOwnProps = {},
-  TMergedProps = {}
->(
-  mapStateToProps: null | undefined,
-  mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>,
-  mergeProps: MergeProps<undefined, TDispatchProps, TOwnProps, TMergedProps>
-): InferableComponentEnhancerWithProps<TMergedProps, TOwnProps>
-
-/* @public */
-// @ts-ignore
-function connect<
-  TStateProps = {},
-  no_dispatch = {},
-  TOwnProps = {},
-  State = DefaultRootState
->(
-  mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>,
-  mapDispatchToProps: null | undefined,
-  mergeProps: null | undefined,
-  options: ConnectOptions<State, TStateProps, TOwnProps>
-): InferableComponentEnhancerWithProps<DispatchProp & TStateProps, TOwnProps>
-
-/* @public */
-function connect<TStateProps = {}, TDispatchProps = {}, TOwnProps = {}>(
-  mapStateToProps: null | undefined,
-  mapDispatchToProps: MapDispatchToPropsNonObject<TDispatchProps, TOwnProps>,
-  mergeProps: null | undefined,
-  options: ConnectOptions<{}, TStateProps, TOwnProps>
-): InferableComponentEnhancerWithProps<TDispatchProps, TOwnProps>
-
-/* @public */
-function connect<TStateProps = {}, TDispatchProps = {}, TOwnProps = {}>(
-  mapStateToProps: null | undefined,
-  mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>,
-  mergeProps: null | undefined,
-  options: ConnectOptions<{}, TStateProps, TOwnProps>
-): InferableComponentEnhancerWithProps<ResolveThunks<TDispatchProps>, TOwnProps>
-
-/* @public */
-function connect<
-  TStateProps = {},
-  TDispatchProps = {},
-  TOwnProps = {},
-  State = DefaultRootState
->(
-  mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>,
-  mapDispatchToProps: MapDispatchToPropsNonObject<TDispatchProps, TOwnProps>,
-  mergeProps: null | undefined,
-  options: ConnectOptions<State, TStateProps, TOwnProps>
-): InferableComponentEnhancerWithProps<TStateProps & TDispatchProps, TOwnProps>
-
-/* @public */
-function connect<
-  TStateProps = {},
-  TDispatchProps = {},
-  TOwnProps = {},
-  State = DefaultRootState
->(
-  mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>,
-  mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>,
-  mergeProps: null | undefined,
-  options: ConnectOptions<State, TStateProps, TOwnProps>
-): InferableComponentEnhancerWithProps<
-  TStateProps & ResolveThunks<TDispatchProps>,
-  TOwnProps
->
-
-/* @public */
-function connect<
-  TStateProps = {},
-  TDispatchProps = {},
-  TOwnProps = {},
-  TMergedProps = {},
-  State = DefaultRootState
->(
-  mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>,
-  mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>,
-  mergeProps: MergeProps<TStateProps, TDispatchProps, TOwnProps, TMergedProps>,
-  options?: ConnectOptions<State, TStateProps, TOwnProps, TMergedProps>
-): InferableComponentEnhancerWithProps<TMergedProps, TOwnProps>
-
-/**
- * Connects a React component to a Redux store.
- *
- * - Without arguments, just wraps the component, without changing the behavior / props
- *
- * - 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
- *
- * - 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 mapStateToProps A function that extracts values from state
- * @param mapDispatchToProps Setup for dispatching actions
- * @param mergeProps Optional callback to merge state and dispatch props together
- * @param options Options for configuring the connection
- *
- */
-function connect(
-  mapStateToProps?: unknown,
-  mapDispatchToProps?: unknown,
-  mergeProps?: unknown,
-  {
-    pure = true,
-    areStatesEqual = strictEqual,
-    areOwnPropsEqual = shallowEqual,
-    areStatePropsEqual = shallowEqual,
-    areMergedPropsEqual = shallowEqual,
-    ...extraOptions
-  }: ConnectOptions<unknown, unknown, unknown, unknown> = {}
-): unknown {
-  const initMapStateToProps = match(
-    mapStateToProps,
-    // @ts-ignore
-    defaultMapStateToPropsFactories,
-    'mapStateToProps'
-  )
-  const initMapDispatchToProps = match(
-    mapDispatchToProps,
-    // @ts-ignore
-    defaultMapDispatchToPropsFactories,
-    'mapDispatchToProps'
-  )
-  const initMergeProps = match(
-    mergeProps,
-    // @ts-ignore
-    defaultMergePropsFactories,
-    'mergeProps'
-  )
-
-  return connectAdvanced(
-    defaultSelectorFactory as SelectorFactory<any, any, any, any>,
-    {
-      // if mapStateToProps is falsy, the Connect component doesn't subscribe to store state changes
-      shouldHandleStateChanges: Boolean(mapStateToProps),
-
-      // passed through to selectorFactory
-      initMapStateToProps,
-      initMapDispatchToProps,
-      initMergeProps,
-      pure,
-      areStatesEqual,
-      areOwnPropsEqual,
-      areStatePropsEqual,
-      areMergedPropsEqual,
-
-      // any extra options args can override defaults of connect or connectAdvanced
-      ...extraOptions,
-    }
-  )
-}
-
 export default connect

src/connect/selectorFactory.ts

@@ -96,6 +96,7 @@ interface PureSelectorFactoryComparisonOptions<
   areStatesEqual: EqualityFn<State>
   areOwnPropsEqual: EqualityFn<TOwnProps>
   areStatePropsEqual: EqualityFn<unknown>
+  displayName: string
   pure?: boolean
 }
 
@@ -222,7 +223,7 @@ export interface SelectorFactoryOptions<
 // TODO: Add more comments
 
 // If pure is true, the selector returned by selectorFactory will memoize its results,
-// allowing connectAdvanced's shouldComponentUpdate to return false if final
+// allowing connect's shouldComponentUpdate to return false if final
 // props have not changed. If false, the selector will always return a new
 // object and shouldComponentUpdate will always return true.