@depup/reduxjs__toolkit 2.12.0-depup.29 → 2.13.0-depup.0

package/src/combineSlices.ts

@@ -62,9 +62,8 @@ export type InjectConfig = {
 export interface CombinedSliceReducer<
   InitialState,
   DeclaredState extends InitialState = InitialState,
-  PreloadedState extends Partial<
-    Record<keyof PreloadedState, any>
-  > = Partial<DeclaredState>,
+  PreloadedState extends Partial<Record<keyof PreloadedState, any>> =
+    Partial<DeclaredState>,
 > extends Reducer<DeclaredState, UnknownAction, PreloadedState> {
   /**
    * Provide a type for slices that will be injected lazily.
@@ -354,9 +353,8 @@ const ORIGINAL_STATE = Symbol.for('rtk-state-proxy-original')
 
 const isStateProxy = (value: any) => !!value && !!value[ORIGINAL_STATE]
 
-const stateProxyMap = new WeakMap<object, object>()
-
 const createStateProxy = <State extends object>(
+  stateProxyMap: WeakMap<object, object>,
   state: State,
   reducerMap: Partial<Record<PropertyKey, Reducer>>,
   initialStateCache: Record<PropertyKey, unknown>,
@@ -411,6 +409,7 @@ export function combineSlices<Slices extends Array<AnySliceLike | ReducerMap>>(
   Id<InitialState<Slices>>,
   Partial<Id<InitialPreloadedState<Slices>>>
 > {
+  const stateProxyMap = new WeakMap<object, object>()
   const reducerMap = Object.fromEntries(getReducers(slices))
 
   const getReducer = () =>
@@ -472,6 +471,7 @@ export function combineSlices<Slices extends Array<AnySliceLike | ReducerMap>>(
       return function selector(state: State, ...args: Args) {
         return selectorFn(
           createStateProxy(
+            stateProxyMap,
             selectState ? selectState(state as any, ...args) : state,
             reducerMap,
             initialStateCache,

package/src/createAction.ts

@@ -122,8 +122,10 @@ export interface ActionCreatorWithPreparedPayload<
  *
  * @public
  */
-export interface ActionCreatorWithOptionalPayload<P, T extends string = string>
-  extends BaseActionCreator<P, T> {
+export interface ActionCreatorWithOptionalPayload<
+  P,
+  T extends string = string,
+> extends BaseActionCreator<P, T> {
   /**
    * Calling this {@link redux#ActionCreator} with an argument will
    * return a {@link PayloadAction} of type `T` with a payload of `P`.
@@ -139,8 +141,9 @@ export interface ActionCreatorWithOptionalPayload<P, T extends string = string>
  *
  * @public
  */
-export interface ActionCreatorWithoutPayload<T extends string = string>
-  extends BaseActionCreator<undefined, T> {
+export interface ActionCreatorWithoutPayload<
+  T extends string = string,
+> extends BaseActionCreator<undefined, T> {
   /**
    * Calling this {@link redux#ActionCreator} will
    * return a {@link PayloadAction} of type `T` with a payload of `undefined`
@@ -155,8 +158,10 @@ export interface ActionCreatorWithoutPayload<T extends string = string>
  *
  * @public
  */
-export interface ActionCreatorWithPayload<P, T extends string = string>
-  extends BaseActionCreator<P, T> {
+export interface ActionCreatorWithPayload<
+  P,
+  T extends string = string,
+> extends BaseActionCreator<P, T> {
   /**
    * Calling this {@link redux#ActionCreator} with an argument will
    * return a {@link PayloadAction} of type `T` with a payload of `P`

package/src/createAsyncThunk.ts

@@ -590,7 +590,7 @@ export const createAsyncThunk = /* @__PURE__ */ (() => {
             ...((meta as any) || {}),
             arg,
             requestId,
-            rejectedWithValue: !!payload,
+            rejectedWithValue: payload !== undefined,
             requestStatus: 'rejected' as const,
             aborted: error?.name === 'AbortError',
             condition: error?.name === 'ConditionError',
@@ -636,13 +636,25 @@ export const createAsyncThunk = /* @__PURE__ */ (() => {
               conditionResult = await conditionResult
             }
 
-            if (conditionResult === false || abortController.signal.aborted) {
+            if (conditionResult === false) {
               // eslint-disable-next-line no-throw-literal
               throw {
                 name: 'ConditionError',
                 message: 'Aborted due to condition callback returning false.',
               }
             }
+            if (abortController.signal.aborted) {
+              // The request was aborted (e.g. via an already-aborted external
+              // signal, or `abort()` called during an async `condition`) before
+              // the `pending` action was dispatched. Treat this as an abort
+              // rather than a condition rejection, so the reason is preserved
+              // and the `rejected` action is not silently swallowed.
+              // eslint-disable-next-line no-throw-literal
+              throw {
+                name: 'AbortError',
+                message: abortReason || 'Aborted',
+              }
+            }
 
             const abortedPromise = new Promise<never>((_, reject) => {
               abortHandler = () => {

package/src/createReducer.ts

@@ -191,7 +191,7 @@ export function createReducer<S extends NotFunction<any>>(
             if (previousState === null) {
               return previousState
             }
-            throw Error(
+            throw new Error(
               'A case reducer on a non-draftable value must not return undefined',
             )
           }

package/src/createSlice.ts

@@ -298,7 +298,9 @@ export type CaseReducerWithPrepare<State, Action extends PayloadAction> = {
 export interface CaseReducerWithPrepareDefinition<
   State,
   Action extends PayloadAction,
-> extends CaseReducerWithPrepare<State, Action>,
+>
+  extends
+    CaseReducerWithPrepare<State, Action>,
     ReducerDefinition<ReducerType.reducerWithPrepare> {}
 
 type AsyncThunkSliceReducerConfig<
@@ -331,8 +333,8 @@ type PreventCircular<ThunkApiConfig> = {
 
 interface AsyncThunkCreator<
   State,
-  CurriedThunkApiConfig extends
-    PreventCircular<AsyncThunkConfig> = PreventCircular<AsyncThunkConfig>,
+  CurriedThunkApiConfig extends PreventCircular<AsyncThunkConfig> =
+    PreventCircular<AsyncThunkConfig>,
 > {
   <Returned, ThunkArg = void>(
     payloadCreator: AsyncThunkPayloadCreator<
@@ -807,7 +809,10 @@ export function buildCreateSlice({ creators }: BuildCreateSliceConfig = {}) {
       caseReducers: context.sliceCaseReducersByName as any,
       getInitialState,
       ...makeSelectorProps(reducerPath),
-      injectInto(injectable, { reducerPath: pathOpt, ...config } = {}) {
+      injectInto(
+        injectable,
+        { reducerPath: pathOpt, ...config }: InjectIntoConfig<string> = {},
+      ) {
         const newReducerPath = pathOpt ?? reducerPath
         injectable.inject({ reducerPath: newReducerPath, reducer }, config)
         return {

package/src/dynamicMiddleware/index.ts

@@ -41,6 +41,7 @@ export const createDynamicMiddleware = <
     Middleware<any, State, DispatchType>,
     MiddlewareEntry<State, DispatchType>
   >()
+  let middlewareVersion = 0
 
   const withMiddleware = Object.assign(
     createAction(
@@ -59,9 +60,13 @@ export const createDynamicMiddleware = <
     function addMiddleware(
       ...middlewares: Middleware<any, State, DispatchType>[]
     ) {
+      const previousSize = middlewareMap.size
       middlewares.forEach((middleware) => {
         getOrInsertComputed(middlewareMap, middleware, createMiddlewareEntry)
       })
+      if (middlewareMap.size !== previousSize) {
+        middlewareVersion++
+      }
     },
     { withTypes: () => addMiddleware },
   ) as AddMiddleware<State, DispatchType>
@@ -76,12 +81,23 @@ export const createDynamicMiddleware = <
   const isWithMiddleware = isAllOf(withMiddleware, matchInstance(instanceId))
 
   const middleware: DynamicMiddleware<State, DispatchType> =
-    (api) => (next) => (action) => {
-      if (isWithMiddleware(action)) {
-        addMiddleware(...action.payload)
-        return api.dispatch
+    (api) => (next) => {
+      let appliedVersion = -1
+      let dispatch = next
+
+      return (action) => {
+        if (isWithMiddleware(action)) {
+          addMiddleware(...action.payload)
+          return api.dispatch
+        }
+
+        if (appliedVersion !== middlewareVersion) {
+          dispatch = getFinalMiddleware(api)(next)
+          appliedVersion = middlewareVersion
+        }
+
+        return dispatch(action)
       }
-      return getFinalMiddleware(api)(next)(action)
     }
 
   return {

package/src/entities/models.ts

@@ -184,7 +184,8 @@ export interface EntityStateFactory<T, Id extends EntityId> {
  * @public
  */
 export interface EntityAdapter<T, Id extends EntityId>
-  extends EntityStateAdapter<T, Id>,
+  extends
+    EntityStateAdapter<T, Id>,
     EntityStateFactory<T, Id>,
     Required<EntityAdapterOptions<T, Id>> {
   getSelectors(

package/src/entities/sorted_state_adapter.ts

@@ -70,15 +70,13 @@ export function createSortedStateAdapter<T, Id extends EntityId>(
     newEntities = ensureEntitiesArray(newEntities)
 
     const existingKeys = new Set<Id>(existingIds ?? getCurrent(state.ids))
-    const addedKeys = new Set<Id>();
-    const models = newEntities.filter(
-      (model) => {
-          const modelId = selectIdValue(model, selectId);
-          const notAdded = !addedKeys.has(modelId);
-          if (notAdded) addedKeys.add(modelId);
-          return !existingKeys.has(modelId) && notAdded;
-      }
-    )
+    const addedKeys = new Set<Id>()
+    const models = newEntities.filter((model) => {
+      const modelId = selectIdValue(model, selectId)
+      const notAdded = !addedKeys.has(modelId)
+      if (notAdded) addedKeys.add(modelId)
+      return !existingKeys.has(modelId) && notAdded
+    })
 
     if (models.length !== 0) {
       mergeFunction(state, models)
@@ -93,16 +91,16 @@ export function createSortedStateAdapter<T, Id extends EntityId>(
     newEntities: readonly T[] | Record<Id, T>,
     state: R,
   ): void {
-    let deduplicatedEntities = {} as Record<Id, T>;
+    let deduplicatedEntities = {} as Record<Id, T>
     newEntities = ensureEntitiesArray(newEntities)
     if (newEntities.length !== 0) {
       for (const item of newEntities) {
-        const entityId = selectId(item);
+        const entityId = selectId(item)
         // For multiple items with the same ID, we should keep the last one.
-        deduplicatedEntities[entityId] = item;
+        deduplicatedEntities[entityId] = item
         delete (state.entities as Record<Id, T>)[entityId]
       }
-      newEntities = ensureEntitiesArray(deduplicatedEntities);
+      newEntities = ensureEntitiesArray(deduplicatedEntities)
       mergeFunction(state, newEntities)
     }
   }
@@ -115,7 +113,7 @@ export function createSortedStateAdapter<T, Id extends EntityId>(
     state.entities = {} as Record<Id, T>
     state.ids = []
 
-    addManyMutably(newEntities, state, [])
+    setManyMutably(newEntities, state)
   }
 
   function updateOneMutably(update: Update<T, Id>, state: R): void {
@@ -129,7 +127,27 @@ export function createSortedStateAdapter<T, Id extends EntityId>(
     let appliedUpdates = false
     let replacedIds = false
 
-    for (let update of updates) {
+    // Pre-merge all updates that target the same entity ID so that later
+    // changes always win for every field—including `id`.  Without this step,
+    // the first rename moves the entity to a new key; a subsequent update that
+    // still targets the original key finds nothing and is silently dropped,
+    // producing results inconsistent with the unsorted adapter.
+    const updatesPerEntity: { [id: string]: Update<T, Id> } = {}
+    for (const update of updates) {
+      // Only collect updates for entities that currently exist (same guard
+      // used by the unsorted adapter).
+      if (update.id in (state.entities as Record<Id, T>)) {
+        updatesPerEntity[update.id] = {
+          id: update.id,
+          changes: {
+            ...updatesPerEntity[update.id]?.changes,
+            ...update.changes,
+          },
+        }
+      }
+    }
+
+    for (const update of Object.values(updatesPerEntity) as Update<T, Id>[]) {
       const entity: T | undefined = (state.entities as Record<Id, T>)[update.id]
       if (!entity) {
         continue
@@ -192,19 +210,12 @@ export function createSortedStateAdapter<T, Id extends EntityId>(
     return true
   }
 
-  type MergeFunction = (
+  function mergeFunction(
     state: R,
     addedItems: readonly T[],
     appliedUpdates?: boolean,
     replacedIds?: boolean,
-  ) => void
-
-  const mergeFunction: MergeFunction = (
-    state,
-    addedItems,
-    appliedUpdates,
-    replacedIds,
-  ) => {
+  ): void {
     const currentEntities = getCurrent(state.entities)
     const currentIds = getCurrent(state.ids)
 

package/src/entities/unsorted_state_adapter.ts

@@ -70,7 +70,7 @@ export function createUnsortedStateAdapter<T, Id extends EntityId>(
     state.ids = []
     state.entities = {} as Record<Id, T>
 
-    addManyMutably(newEntities, state)
+    setManyMutably(newEntities, state)
   }
 
   function removeOneMutably(key: Id, state: R): void {

package/src/immutableStateInvariantMiddleware.ts

@@ -36,13 +36,20 @@ function trackProperties(
   ignoredPaths: IgnoredPaths = [],
   obj: Record<string, any>,
   path: string = '',
-  checkedObjects: Set<Record<string, any>> = new Set(),
+  inProgress: Map<Record<string, any>, TrackedProperty> = new Map(),
 ) {
   const tracked: Partial<TrackedProperty> = { value: obj }
 
-  if (!isImmutable(obj) && !checkedObjects.has(obj)) {
-    checkedObjects.add(obj)
+  if (!isImmutable(obj)) {
+    // An object already being tracked further up the stack contains itself
+    const alreadyInProgress = inProgress.get(obj)
+    if (alreadyInProgress) {
+      return alreadyInProgress
+    }
+
     tracked.children = {}
+    // Registered before walking children, so a circular reference finds it
+    inProgress.set(obj, tracked as TrackedProperty)
 
     const hasIgnoredPaths = ignoredPaths.length > 0
 
@@ -66,8 +73,11 @@ function trackProperties(
         ignoredPaths,
         obj[key],
         nestedPath,
+        inProgress,
       )
     }
+
+    inProgress.delete(obj)
   }
   return tracked as TrackedProperty
 }
@@ -79,6 +89,7 @@ function detectMutations(
   obj: any,
   sameParentRef: boolean = false,
   path: string = '',
+  seen: Map<TrackedProperty, Set<unknown>> = new Map(),
 ): { wasMutated: boolean; path?: string } {
   const prevObj = trackedProperty ? trackedProperty.value : undefined
 
@@ -92,6 +103,18 @@ function detectMutations(
     return { wasMutated: false }
   }
 
+  // Compare each (tracked node, value) pair once, so cycles terminate
+  let seenValues = seen.get(trackedProperty)
+
+  if (!seenValues) {
+    seenValues = new Set()
+    seen.set(trackedProperty, seenValues)
+  } else if (seenValues.has(obj)) {
+    return { wasMutated: false }
+  }
+
+  seenValues.add(obj)
+
   // Gather all keys from prev (tracked) and after objs
   const keysToDetect: Record<string, boolean> = {}
   for (let key in trackedProperty.children) {
@@ -125,6 +148,7 @@ function detectMutations(
       obj[key],
       sameRef,
       nestedPath,
+      seen,
     )
 
     if (result.wasMutated) {
@@ -201,8 +225,13 @@ export function createImmutableStateInvariantMiddleware(
       return function (this: any, key: string, value: any) {
         if (stack.length > 0) {
           var thisPos = stack.indexOf(this)
-          ~thisPos ? stack.splice(thisPos + 1) : stack.push(this)
-          ~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key)
+          if (~thisPos) {
+            stack.splice(thisPos + 1)
+            keys.splice(thisPos, Infinity, key)
+          } else {
+            stack.push(this)
+            keys.push(key)
+          }
           if (~stack.indexOf(value)) value = decycler!.call(this, key, value)
         } else stack.push(value)
 

package/src/listenerMiddleware/types.ts

@@ -36,7 +36,6 @@ export type ListenerPredicate<ActionType extends Action, State> = (
 
 /** @public */
 export interface ConditionFunction<State> {
-  (predicate: AnyListenerPredicate<State>, timeout?: number): Promise<boolean>
   (predicate: AnyListenerPredicate<State>, timeout?: number): Promise<boolean>
   (predicate: () => boolean, timeout?: number): Promise<boolean>
 }
@@ -157,7 +156,7 @@ export interface ListenerEffectAPI<
    *
    *     setTimeout(getOriginalState, 0); // async: throws Error
    *
-   *     await Promise().resolve();
+   *     await Promise.resolve();
    *
    *     getOriginalState(); // async: throws Error
    *   },
@@ -324,11 +323,8 @@ export type ListenerMiddleware<
 /** @public */
 export interface ListenerMiddlewareInstance<
   StateType = unknown,
-  DispatchType extends ThunkDispatch<
-    StateType,
-    unknown,
-    Action
-  > = ThunkDispatch<StateType, unknown, UnknownAction>,
+  DispatchType extends ThunkDispatch<StateType, unknown, Action> =
+    ThunkDispatch<StateType, unknown, UnknownAction>,
   ExtraArgument = unknown,
 > {
   middleware: ListenerMiddleware<StateType, DispatchType, ExtraArgument>
@@ -833,7 +829,7 @@ export type TypedCreateListenerEntry<
       UnknownAction
     >,
     OverrideExtraArgument = unknown,
-  >() => TypedStopListening<
+  >() => TypedCreateListenerEntry<
     OverrideStateType,
     OverrideDispatchType,
     OverrideExtraArgument
@@ -870,14 +866,18 @@ export type FallbackAddListenerOptions = {
   type?: string
   matcher?: MatchFunction<any>
   predicate?: ListenerPredicate<any, any>
-} & { effect: ListenerEffect<any, any, any> }
+  effect: ListenerEffect<any, any, any>
+}
 
 /**
  * Utility Types
  */
 
 /** @public */
-export type GuardedType<T> = T extends (x: any, ...args: any[]) => x is infer T
+export type GuardedType<T> = T extends ((
+  x: any,
+  ...args: any[]
+) => x is infer T)
   ? T
   : never
 

package/src/mapBuilders.ts

@@ -200,7 +200,7 @@ export function executeReducerBuilderCallback<S>(
   const actionsMap: CaseReducers<S, any> = {}
   const actionMatchers: ActionMatcherDescriptionCollection<S> = []
   let defaultCaseReducer: CaseReducer<S, Action> | undefined
-  const builder = {
+  const builder: ActionReducerMapBuilder<S> = {
     addCase(
       typeOrActionCreator: string | TypedActionCreator<any>,
       reducer: CaseReducer<S>,
@@ -269,10 +269,7 @@ export function executeReducerBuilderCallback<S>(
         })
       return builder
     },
-    addMatcher<A>(
-      matcher: TypeGuard<A>,
-      reducer: CaseReducer<S, A extends Action ? A : A & Action>,
-    ) {
+    addMatcher(matcher: TypeGuard<any>, reducer: CaseReducer<S, any>) {
       if (process.env.NODE_ENV !== 'production') {
         if (defaultCaseReducer) {
           throw new Error(

package/src/matchers.ts

@@ -361,5 +361,11 @@ export function isAsyncThunkAction<
     return isAsyncThunkAction()(asyncThunks[0])
   }
 
-  return isAnyOf(...asyncThunks.flatMap(asyncThunk => [asyncThunk.pending, asyncThunk.rejected, asyncThunk.fulfilled]))
+  return isAnyOf(
+    ...asyncThunks.flatMap((asyncThunk) => [
+      asyncThunk.pending,
+      asyncThunk.rejected,
+      asyncThunk.fulfilled,
+    ]),
+  )
 }

package/src/query/core/apiState.ts

@@ -354,7 +354,7 @@ export type SubscriptionState = {
   [queryCacheKey: string]: Subscribers | undefined
 }
 
-export type ConfigState<ReducerPath> = RefetchConfigOptions & {
+export type ConfigState<ReducerPath> = {
   reducerPath: ReducerPath
   online: boolean
   focused: boolean

package/src/query/core/buildInitiate.ts

@@ -13,7 +13,6 @@ import type { InternalSerializeQueryArgs } from '../defaultSerializeQueryArgs'
 import {
   ENDPOINT_QUERY,
   isQueryDefinition,
-  type EndpointDefinition,
   type EndpointDefinitions,
   type InfiniteQueryArgFrom,
   type InfiniteQueryDefinition,
@@ -96,7 +95,7 @@ export type StartInfiniteQueryActionCreatorOptions<
     >
   >
 
-type AnyQueryActionCreator<D extends EndpointDefinition<any, any, any, any>> = (
+type AnyQueryActionCreator = (
   arg: any,
   options?: StartQueryActionCreatorOptions,
 ) => ThunkAction<AnyActionCreatorResult, any, any, UnknownAction>
@@ -154,20 +153,22 @@ export type InfiniteQueryActionCreatorResult<
     ): InfiniteQueryActionCreatorResult<D>
   }
 
+type StartMutationActionCreatorOptions = {
+  /**
+   * If this mutation should be tracked in the store.
+   * If you just want to manually trigger this mutation using `dispatch` and don't care about the
+   * result, state & potential errors being held in store, you can set this to false.
+   * (defaults to `true`)
+   */
+  track?: boolean
+  fixedCacheKey?: string
+}
+
 type StartMutationActionCreator<
   D extends MutationDefinition<any, any, any, any>,
 > = (
   arg: QueryArgFrom<D>,
-  options?: {
-    /**
-     * If this mutation should be tracked in the store.
-     * If you just want to manually trigger this mutation using `dispatch` and don't care about the
-     * result, state & potential errors being held in store, you can set this to false.
-     * (defaults to `true`)
-     */
-    track?: boolean
-    fixedCacheKey?: string
-  },
+  options?: StartMutationActionCreatorOptions,
 ) => ThunkAction<MutationActionCreatorResult<D>, any, any, UnknownAction>
 
 export type MutationActionCreatorResult<
@@ -381,7 +382,7 @@ You must add the middleware for RTK-Query to function correctly!`,
       | QueryDefinition<any, any, any, any>
       | InfiniteQueryDefinition<any, any, any, any, any>,
   ) {
-    const queryAction: AnyQueryActionCreator<any> =
+    const queryAction: AnyQueryActionCreator =
       (
         arg,
         {
@@ -390,7 +391,7 @@ You must add the middleware for RTK-Query to function correctly!`,
           subscriptionOptions,
           [forceQueryFnSymbol]: forceQueryFn,
           ...rest
-        } = {},
+        }: StartQueryActionCreatorOptions = {},
       ) =>
       (dispatch, getState) => {
         const queryCacheKey = serializeQueryArgs({
@@ -546,7 +547,10 @@ You must add the middleware for RTK-Query to function correctly!`,
   function buildInitiateMutation(
     endpointName: string,
   ): StartMutationActionCreator<any> {
-    return (arg, { track = true, fixedCacheKey } = {}) =>
+    return (
+      arg,
+      { track = true, fixedCacheKey }: StartMutationActionCreatorOptions = {},
+    ) =>
       (dispatch, getState) => {
         const thunk = mutationThunk({
           type: 'mutation',

package/src/query/core/buildMiddleware/cacheLifecycle.ts

@@ -129,7 +129,9 @@ export interface QueryCacheLifecycleApi<
   BaseQuery extends BaseQueryFn,
   ResultType,
   ReducerPath extends string = string,
-> extends QueryBaseLifecycleApi<QueryArg, BaseQuery, ResultType, ReducerPath>,
+>
+  extends
+    QueryBaseLifecycleApi<QueryArg, BaseQuery, ResultType, ReducerPath>,
     CacheLifecyclePromises<ResultType, BaseQueryMeta<BaseQuery>> {}
 
 export type MutationCacheLifecycleApi<

package/src/query/core/buildMiddleware/index.ts

@@ -118,7 +118,7 @@ export function buildMiddleware<
           res = internalProbeResult
         }
 
-        if (!!mwApi.getState()[reducerPath]) {
+        if (mwApi.getState()[reducerPath]) {
           // Only run these checks if the middleware is registered okay
 
           // This looks for actions that aren't specific to the API slice

package/src/query/core/buildMiddleware/invalidationByTags.ts

@@ -53,7 +53,10 @@ export const buildInvalidationByTagsHandler: InternalHandlerBuilder = ({
       pendingRequestCount++
     }
 
-    if (isQueryEnd(action)) {
+    if (
+      isQueryEnd(action) &&
+      !(queryThunk.rejected.match(action) && action.meta.condition)
+    ) {
       pendingRequestCount = Math.max(0, pendingRequestCount - 1)
     }
 

package/src/query/core/buildMiddleware/polling.ts

@@ -102,8 +102,17 @@ export const buildPollingHandler: InternalHandlerBuilder = ({
       nextPollTimestamp,
       pollingInterval: lowestPollingInterval,
       timeout: setTimeout(() => {
-        if (state.config.focused || !skipPollingIfUnfocused) {
-          api.dispatch(refetchQuery(querySubState))
+        const currentState = api.getState()[reducerPath]
+        const currentQuerySubState = currentState.queries[queryCacheKey]
+        if (
+          !currentQuerySubState ||
+          currentQuerySubState.status === STATUS_UNINITIALIZED
+        ) {
+          cleanupPollForKey(queryCacheKey)
+          return
+        }
+        if (currentState.config.focused || !skipPollingIfUnfocused) {
+          api.dispatch(refetchQuery(currentQuerySubState))
         }
         startNextPoll({ queryCacheKey }, api)
       }, lowestPollingInterval),
@@ -167,7 +176,7 @@ export const buildPollingHandler: InternalHandlerBuilder = ({
     let lowestPollingInterval = Number.POSITIVE_INFINITY
 
     for (const entry of subscribers.values()) {
-      if (!!entry.pollingInterval) {
+      if (entry.pollingInterval) {
         lowestPollingInterval = Math.min(
           entry.pollingInterval!,
           lowestPollingInterval,