@orchestrator-ui/orchestrator-ui-components 5.8.1 → 5.9.0

package/dist/index.js

@@ -26801,7 +26801,7 @@ var PolicyResource = /* @__PURE__ */ ((PolicyResource2) => {
 })(PolicyResource || {});
 
 // src/configuration/version.ts
-var ORCHESTRATOR_UI_LIBRARY_VERSION = "5.8.1";
+var ORCHESTRATOR_UI_LIBRARY_VERSION = "5.9.0";
 
 // src/types/types.ts
 var EngineStatus = /* @__PURE__ */ ((EngineStatus3) => {
@@ -29066,6 +29066,21 @@ function executeReducerBuilderCallback(builderCallback) {
       actionsMap[type] = reducer;
       return builder;
     },
+    addAsyncThunk(asyncThunk, reducers) {
+      if (process.env.NODE_ENV !== "production") {
+        if (defaultCaseReducer) {
+          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage2(43) : "`builder.addAsyncThunk` should only be called before calling `builder.addDefaultCase`");
+        }
+      }
+      if (reducers.pending) actionsMap[asyncThunk.pending.type] = reducers.pending;
+      if (reducers.rejected) actionsMap[asyncThunk.rejected.type] = reducers.rejected;
+      if (reducers.fulfilled) actionsMap[asyncThunk.fulfilled.type] = reducers.fulfilled;
+      if (reducers.settled) actionMatchers.push({
+        matcher: asyncThunk.settled,
+        reducer: reducers.settled
+      });
+      return builder;
+    },
     addMatcher(matcher, reducer) {
       if (process.env.NODE_ENV !== "production") {
         if (defaultCaseReducer) {
@@ -29817,6 +29832,11 @@ function getOrInsert(map, key, value) {
   if (map.has(key)) return map.get(key);
   return map.set(key, value).get(key);
 }
+function getOrInsertComputed2(map, key, compute) {
+  if (map.has(key)) return map.get(key);
+  return map.set(key, compute(key)).get(key);
+}
+var createNewMap = () => /* @__PURE__ */ new Map();
 var defaultFetchFn = (...args) => fetch(...args);
 var defaultValidateStatus = (response) => response.status >= 200 && response.status <= 299;
 var defaultIsJsonContentType = (headers) => (
@@ -30028,10 +30048,13 @@ function buildInitiate({
   infiniteQueryThunk,
   mutationThunk,
   api,
-  context
+  context,
+  internalState
 }) {
-  const runningQueries = /* @__PURE__ */ new Map();
-  const runningMutations = /* @__PURE__ */ new Map();
+  const {
+    runningQueries,
+    runningMutations
+  } = internalState;
   const {
     unsubscribeQueryResult,
     removeMutationResult,
@@ -30266,6 +30289,7 @@ var NamedSchemaError = class extends SchemaError {
     this._bqMeta = _bqMeta;
   }
 };
+var shouldSkip = (skipSchemaValidation, schemaName) => Array.isArray(skipSchemaValidation) ? skipSchemaValidation.includes(schemaName) : !!skipSchemaValidation;
 async function parseWithSchema(schema, data, schemaName, bqMeta) {
   const result = await schema["~standard"].validate(data);
   if (result.issues) {
@@ -30397,7 +30421,7 @@ function buildThunks({
       skipSchemaValidation = globalSkipSchemaValidation
     } = endpointDefinition;
     try {
-      let transformResponse = getTransformCallbackForEndpoint(endpointDefinition, "transformResponse");
+      let transformResponse = defaultTransformResponse;
       const baseQueryApi = {
         signal,
         abort,
@@ -30439,7 +30463,7 @@ function buildThunks({
           rawResponseSchema,
           responseSchema
         } = endpointDefinition;
-        if (argSchema && !skipSchemaValidation) {
+        if (argSchema && !shouldSkip(skipSchemaValidation, "arg")) {
           finalQueryArg = await parseWithSchema(
             argSchema,
             finalQueryArg,
@@ -30451,6 +30475,7 @@ function buildThunks({
         if (forceQueryFn) {
           result = forceQueryFn();
         } else if (endpointDefinition.query) {
+          transformResponse = getTransformCallbackForEndpoint(endpointDefinition, "transformResponse");
           result = await baseQuery(endpointDefinition.query(finalQueryArg), baseQueryApi, extraOptions);
         } else {
           result = await endpointDefinition.queryFn(finalQueryArg, baseQueryApi, extraOptions, (arg2) => baseQuery(arg2, baseQueryApi, extraOptions));
@@ -30485,11 +30510,11 @@ function buildThunks({
         let {
           data
         } = result;
-        if (rawResponseSchema && !skipSchemaValidation) {
+        if (rawResponseSchema && !shouldSkip(skipSchemaValidation, "rawResponse")) {
           data = await parseWithSchema(rawResponseSchema, result.data, "rawResponseSchema", result.meta);
         }
         let transformedResponse = await transformResponse(data, result.meta, finalQueryArg);
-        if (responseSchema && !skipSchemaValidation) {
+        if (responseSchema && !shouldSkip(skipSchemaValidation, "response")) {
           transformedResponse = await parseWithSchema(responseSchema, transformedResponse, "responseSchema", result.meta);
         }
         return {
@@ -30518,7 +30543,7 @@ function buildThunks({
         if ("direction" in arg && arg.direction && existingData.pages.length) {
           const previous = arg.direction === "backward";
           const pageParamFn = previous ? getPreviousPageParam : getNextPageParam;
-          const param = pageParamFn(infiniteQueryOptions, existingData);
+          const param = pageParamFn(infiniteQueryOptions, existingData, arg.originalArgs);
           result = await fetchPage(existingData, param, maxPages, previous);
         } else {
           const {
@@ -30534,7 +30559,7 @@ function buildThunks({
             };
           }
           for (let i = 1; i < totalPages; i++) {
-            const param = getNextPageParam(infiniteQueryOptions, result.data);
+            const param = getNextPageParam(infiniteQueryOptions, result.data, arg.originalArgs);
             result = await fetchPage(result.data, param, maxPages);
           }
         }
@@ -30542,7 +30567,7 @@ function buildThunks({
       } else {
         finalQueryReturnValue = await executeRequest(arg.originalArgs);
       }
-      if (metaSchema && !skipSchemaValidation && finalQueryReturnValue.meta) {
+      if (metaSchema && !shouldSkip(skipSchemaValidation, "meta") && finalQueryReturnValue.meta) {
         finalQueryReturnValue.meta = await parseWithSchema(metaSchema, finalQueryReturnValue.meta, "metaSchema", finalQueryReturnValue.meta);
       }
       return fulfillWithValue(finalQueryReturnValue.data, addShouldAutoBatch({
@@ -30562,14 +30587,14 @@ function buildThunks({
           meta
         } = caughtError;
         try {
-          if (rawErrorResponseSchema && !skipSchemaValidation) {
+          if (rawErrorResponseSchema && !shouldSkip(skipSchemaValidation, "rawErrorResponse")) {
             value = await parseWithSchema(rawErrorResponseSchema, value, "rawErrorResponseSchema", meta);
           }
-          if (metaSchema && !skipSchemaValidation) {
+          if (metaSchema && !shouldSkip(skipSchemaValidation, "meta")) {
             meta = await parseWithSchema(metaSchema, meta, "metaSchema", meta);
           }
           let transformedErrorResponse = await transformErrorResponse(value, meta, arg.originalArgs);
-          if (errorResponseSchema && !skipSchemaValidation) {
+          if (errorResponseSchema && !shouldSkip(skipSchemaValidation, "errorResponse")) {
             transformedErrorResponse = await parseWithSchema(errorResponseSchema, transformedErrorResponse, "errorResponseSchema", meta);
           }
           return rejectWithValue(transformedErrorResponse, addShouldAutoBatch({
@@ -30731,15 +30756,15 @@ In the case of an unhandled error, no tags will be "provided" or "invalidated".`
 function getNextPageParam(options, {
   pages,
   pageParams
-}) {
+}, queryArg) {
   const lastIndex = pages.length - 1;
-  return options.getNextPageParam(pages[lastIndex], pages, pageParams[lastIndex], pageParams);
+  return options.getNextPageParam(pages[lastIndex], pages, pageParams[lastIndex], pageParams, queryArg);
 }
 function getPreviousPageParam(options, {
   pages,
   pageParams
-}) {
-  return options.getPreviousPageParam?.(pages[0], pages, pageParams[0], pageParams);
+}, queryArg) {
+  return options.getPreviousPageParam?.(pages[0], pages, pageParams[0], pageParams, queryArg);
 }
 function calculateProvidedByThunk(action, type, endpointDefinitions, assertTagType) {
   return calculateProvidedBy(endpointDefinitions[action.meta.arg.endpointName][type], isFulfilled(action) ? action.payload : void 0, isRejectedWithValue(action) ? action.payload : void 0, action.meta.arg.originalArgs, "baseQueryMeta" in action.meta ? action.meta.baseQueryMeta : void 0, assertTagType);
@@ -31084,7 +31109,7 @@ function buildSlice({
         const {
           provided
         } = extractRehydrationInfo(action);
-        for (const [type, incomingTags] of Object.entries(provided)) {
+        for (const [type, incomingTags] of Object.entries(provided.tags ?? {})) {
           for (const [id, cacheKeys] of Object.entries(incomingTags)) {
             const subscribedQueries = (_b = (_a = draft.tags)[type] ?? (_a[type] = {}))[_c = id || "__internal_without_id"] ?? (_b[_c] = []);
             for (const queryCacheKey of cacheKeys) {
@@ -31092,6 +31117,7 @@ function buildSlice({
               if (!alreadySubscribed) {
                 subscribedQueries.push(queryCacheKey);
               }
+              draft.keys[queryCacheKey] = provided.keys[queryCacheKey];
             }
           }
         }
@@ -31308,8 +31334,8 @@ function buildSelectors({
       const isBackward = direction === "backward";
       return {
         ...stateWithRequestFlags,
-        hasNextPage: getHasNextPage(infiniteQueryOptions, stateWithRequestFlags.data),
-        hasPreviousPage: getHasPreviousPage(infiniteQueryOptions, stateWithRequestFlags.data),
+        hasNextPage: getHasNextPage(infiniteQueryOptions, stateWithRequestFlags.data, stateWithRequestFlags.originalArgs),
+        hasPreviousPage: getHasPreviousPage(infiniteQueryOptions, stateWithRequestFlags.data, stateWithRequestFlags.originalArgs),
         isFetchingNextPage: isLoading && isForward,
         isFetchingPreviousPage: isLoading && isBackward,
         isFetchNextPageError: isError2 && isForward,
@@ -31365,13 +31391,13 @@ function buildSelectors({
       /* uninitialized */
     ).map((entry) => entry.originalArgs);
   }
-  function getHasNextPage(options, data) {
+  function getHasNextPage(options, data, queryArg) {
     if (!data) return false;
-    return getNextPageParam(options, data) != null;
+    return getNextPageParam(options, data, queryArg) != null;
   }
-  function getHasPreviousPage(options, data) {
+  function getHasPreviousPage(options, data, queryArg) {
     if (!data || !options.getPreviousPageParam) return false;
-    return getPreviousPageParam(options, data) != null;
+    return getPreviousPageParam(options, data, queryArg) != null;
   }
 }
 var cache = WeakMap ? /* @__PURE__ */ new WeakMap() : void 0;
@@ -31539,7 +31565,8 @@ function safeAssign(target, ...args) {
 var buildBatchedActionsHandler = ({
   api,
   queryThunk,
-  internalState
+  internalState,
+  mwApi
 }) => {
   const subscriptionsPrefix = `${api.reducerPath}/subscriptions`;
   let previousSubscriptions = null;
@@ -31548,16 +31575,16 @@ var buildBatchedActionsHandler = ({
     updateSubscriptionOptions,
     unsubscribeQueryResult
   } = api.internalActions;
-  const actuallyMutateSubscriptions = (mutableState, action) => {
-    var _a, _b;
+  const actuallyMutateSubscriptions = (currentSubscriptions, action) => {
     if (updateSubscriptionOptions.match(action)) {
       const {
         queryCacheKey,
         requestId,
         options
       } = action.payload;
-      if (mutableState?.[queryCacheKey]?.[requestId]) {
-        mutableState[queryCacheKey][requestId] = options;
+      const sub = currentSubscriptions.get(queryCacheKey);
+      if (sub?.has(requestId)) {
+        sub.set(requestId, options);
       }
       return true;
     }
@@ -31566,13 +31593,14 @@ var buildBatchedActionsHandler = ({
         queryCacheKey,
         requestId
       } = action.payload;
-      if (mutableState[queryCacheKey]) {
-        delete mutableState[queryCacheKey][requestId];
+      const sub = currentSubscriptions.get(queryCacheKey);
+      if (sub) {
+        sub.delete(requestId);
       }
       return true;
     }
     if (api.internalActions.removeQueryResult.match(action)) {
-      delete mutableState[action.payload.queryCacheKey];
+      currentSubscriptions.delete(action.payload.queryCacheKey);
       return true;
     }
     if (queryThunk.pending.match(action)) {
@@ -31582,20 +31610,13 @@ var buildBatchedActionsHandler = ({
           requestId
         }
       } = action;
-      const substate = mutableState[_a = arg.queryCacheKey] ?? (mutableState[_a] = {});
-      substate[`${requestId}_running`] = {};
+      const substate = getOrInsertComputed2(currentSubscriptions, arg.queryCacheKey, createNewMap);
       if (arg.subscribe) {
-        substate[requestId] = arg.subscriptionOptions ?? substate[requestId] ?? {};
+        substate.set(requestId, arg.subscriptionOptions ?? substate.get(requestId) ?? {});
       }
       return true;
     }
     let mutated = false;
-    if (queryThunk.fulfilled.match(action) || queryThunk.rejected.match(action)) {
-      const state = mutableState[action.meta.arg.queryCacheKey] || {};
-      const key = `${action.meta.requestId}_running`;
-      mutated || (mutated = !!state[key]);
-      delete state[key];
-    }
     if (queryThunk.rejected.match(action)) {
       const {
         meta: {
@@ -31605,8 +31626,8 @@ var buildBatchedActionsHandler = ({
         }
       } = action;
       if (condition && arg.subscribe) {
-        const substate = mutableState[_b = arg.queryCacheKey] ?? (mutableState[_b] = {});
-        substate[requestId] = arg.subscriptionOptions ?? substate[requestId] ?? {};
+        const substate = getOrInsertComputed2(currentSubscriptions, arg.queryCacheKey, createNewMap);
+        substate.set(requestId, arg.subscriptionOptions ?? substate.get(requestId) ?? {});
         mutated = true;
       }
     }
@@ -31615,24 +31636,28 @@ var buildBatchedActionsHandler = ({
   const getSubscriptions = () => internalState.currentSubscriptions;
   const getSubscriptionCount = (queryCacheKey) => {
     const subscriptions = getSubscriptions();
-    const subscriptionsForQueryArg = subscriptions[queryCacheKey] ?? {};
-    return countObjectKeys(subscriptionsForQueryArg);
+    const subscriptionsForQueryArg = subscriptions.get(queryCacheKey);
+    return subscriptionsForQueryArg?.size ?? 0;
   };
   const isRequestSubscribed = (queryCacheKey, requestId) => {
     const subscriptions = getSubscriptions();
-    return !!subscriptions?.[queryCacheKey]?.[requestId];
+    return !!subscriptions?.get(queryCacheKey)?.get(requestId);
   };
   const subscriptionSelectors = {
     getSubscriptions,
     getSubscriptionCount,
     isRequestSubscribed
   };
-  return (action, mwApi) => {
+  function serializeSubscriptions(currentSubscriptions) {
+    return JSON.parse(JSON.stringify(Object.fromEntries([...currentSubscriptions].map(([k, v]) => [k, Object.fromEntries(v)]))));
+  }
+  return (action, mwApi2) => {
     if (!previousSubscriptions) {
-      previousSubscriptions = JSON.parse(JSON.stringify(internalState.currentSubscriptions));
+      previousSubscriptions = serializeSubscriptions(internalState.currentSubscriptions);
     }
     if (api.util.resetApiState.match(action)) {
-      previousSubscriptions = internalState.currentSubscriptions = {};
+      previousSubscriptions = {};
+      internalState.currentSubscriptions.clear();
       updateSyncTimer = null;
       return [true, false];
     }
@@ -31641,12 +31666,15 @@ var buildBatchedActionsHandler = ({
     }
     const didMutate = actuallyMutateSubscriptions(internalState.currentSubscriptions, action);
     let actionShouldContinue = true;
+    if (process.env.NODE_ENV === "test" && typeof action.type === "string" && action.type === `${api.reducerPath}/getPolling`) {
+      return [false, internalState.currentPolls];
+    }
     if (didMutate) {
       if (!updateSyncTimer) {
         updateSyncTimer = setTimeout(() => {
-          const newSubscriptions = JSON.parse(JSON.stringify(internalState.currentSubscriptions));
+          const newSubscriptions = serializeSubscriptions(internalState.currentSubscriptions);
           const [, patches] = produceWithPatches(previousSubscriptions, () => newSubscriptions);
-          mwApi.next(api.internalActions.subscriptionsUpdated(patches));
+          mwApi2.next(api.internalActions.subscriptionsUpdated(patches));
           previousSubscriptions = newSubscriptions;
           updateSyncTimer = null;
         }, 500);
@@ -31658,12 +31686,6 @@ var buildBatchedActionsHandler = ({
     return [actionShouldContinue, false];
   };
 };
-function isObjectEmpty(obj) {
-  for (const k in obj) {
-    return false;
-  }
-  return true;
-}
 var THIRTY_TWO_BIT_MAX_TIMER_SECONDS = 2147483647 / 1e3 - 1;
 var buildCacheCollectionHandler = ({
   reducerPath,
@@ -31674,21 +31696,29 @@ var buildCacheCollectionHandler = ({
   selectors: {
     selectQueryEntry,
     selectConfig
-  }
+  },
+  getRunningQueryThunk,
+  mwApi
 }) => {
   const {
     removeQueryResult,
     unsubscribeQueryResult,
     cacheEntriesUpserted
   } = api.internalActions;
+  const runningQueries = internalState.runningQueries.get(mwApi.dispatch);
   const canTriggerUnsubscribe = isAnyOf(unsubscribeQueryResult.match, queryThunk.fulfilled, queryThunk.rejected, cacheEntriesUpserted.match);
   function anySubscriptionsRemainingForKey(queryCacheKey) {
-    const subscriptions = internalState.currentSubscriptions[queryCacheKey];
-    return !!subscriptions && !isObjectEmpty(subscriptions);
+    const subscriptions = internalState.currentSubscriptions.get(queryCacheKey);
+    if (!subscriptions) {
+      return false;
+    }
+    const hasSubscriptions = subscriptions.size > 0;
+    const isRunning = runningQueries?.[queryCacheKey] !== void 0;
+    return hasSubscriptions || isRunning;
   }
   const currentRemovalTimeouts = {};
-  const handler = (action, mwApi, internalState2) => {
-    const state = mwApi.getState();
+  const handler = (action, mwApi2, internalState2) => {
+    const state = mwApi2.getState();
     const config = selectConfig(state);
     if (canTriggerUnsubscribe(action)) {
       let queryCacheKeys;
@@ -31700,7 +31730,7 @@ var buildCacheCollectionHandler = ({
         } = unsubscribeQueryResult.match(action) ? action.payload : action.meta.arg;
         queryCacheKeys = [queryCacheKey];
       }
-      handleUnsubscribeMany(queryCacheKeys, mwApi, config);
+      handleUnsubscribeMany(queryCacheKeys, mwApi2, config);
     }
     if (api.util.resetApiState.match(action)) {
       for (const [key, timeout] of Object.entries(currentRemovalTimeouts)) {
@@ -31712,14 +31742,16 @@ var buildCacheCollectionHandler = ({
       const {
         queries
       } = context.extractRehydrationInfo(action);
-      handleUnsubscribeMany(Object.keys(queries), mwApi, config);
+      handleUnsubscribeMany(Object.keys(queries), mwApi2, config);
     }
   };
   function handleUnsubscribeMany(cacheKeys, api2, config) {
     const state = api2.getState();
     for (const queryCacheKey of cacheKeys) {
       const entry = selectQueryEntry(state, queryCacheKey);
-      handleUnsubscribe(queryCacheKey, entry?.endpointName, api2, config);
+      if (entry?.endpointName) {
+        handleUnsubscribe(queryCacheKey, entry.endpointName, api2, config);
+      }
     }
   }
   function handleUnsubscribe(queryCacheKey, endpointName, api2, config) {
@@ -31736,6 +31768,11 @@ var buildCacheCollectionHandler = ({
       }
       currentRemovalTimeouts[queryCacheKey] = setTimeout(() => {
         if (!anySubscriptionsRemainingForKey(queryCacheKey)) {
+          const entry = selectQueryEntry(api2.getState(), queryCacheKey);
+          if (entry?.endpointName) {
+            const runningQuery = api2.dispatch(getRunningQueryThunk(entry.endpointName, entry.originalArgs));
+            runningQuery?.abort();
+          }
           api2.dispatch(removeQueryResult({
             queryCacheKey
           }));
@@ -31940,9 +31977,9 @@ var buildInvalidationByTagsHandler = ({
         queryCacheKey
       } of valuesArray) {
         const querySubState = state.queries[queryCacheKey];
-        const subscriptionSubState = internalState.currentSubscriptions[queryCacheKey] ?? {};
+        const subscriptionSubState = getOrInsertComputed2(internalState.currentSubscriptions, queryCacheKey, createNewMap);
         if (querySubState) {
-          if (countObjectKeys(subscriptionSubState) === 0) {
+          if (subscriptionSubState.size === 0) {
             mwApi.dispatch(removeQueryResult({
               queryCacheKey
             }));
@@ -31962,25 +31999,49 @@ var buildPollingHandler = ({
   refetchQuery,
   internalState
 }) => {
-  const currentPolls = {};
+  const {
+    currentPolls,
+    currentSubscriptions
+  } = internalState;
+  const pendingPollingUpdates = /* @__PURE__ */ new Set();
+  let pollingUpdateTimer = null;
   const handler = (action, mwApi) => {
     if (api.internalActions.updateSubscriptionOptions.match(action) || api.internalActions.unsubscribeQueryResult.match(action)) {
-      updatePollingInterval(action.payload, mwApi);
+      schedulePollingUpdate(action.payload.queryCacheKey, mwApi);
     }
     if (queryThunk.pending.match(action) || queryThunk.rejected.match(action) && action.meta.condition) {
-      updatePollingInterval(action.meta.arg, mwApi);
+      schedulePollingUpdate(action.meta.arg.queryCacheKey, mwApi);
     }
     if (queryThunk.fulfilled.match(action) || queryThunk.rejected.match(action) && !action.meta.condition) {
       startNextPoll(action.meta.arg, mwApi);
     }
     if (api.util.resetApiState.match(action)) {
       clearPolls();
+      if (pollingUpdateTimer) {
+        clearTimeout(pollingUpdateTimer);
+        pollingUpdateTimer = null;
+      }
+      pendingPollingUpdates.clear();
     }
   };
+  function schedulePollingUpdate(queryCacheKey, api2) {
+    pendingPollingUpdates.add(queryCacheKey);
+    if (!pollingUpdateTimer) {
+      pollingUpdateTimer = setTimeout(() => {
+        for (const key of pendingPollingUpdates) {
+          updatePollingInterval({
+            queryCacheKey: key
+          }, api2);
+        }
+        pendingPollingUpdates.clear();
+        pollingUpdateTimer = null;
+      }, 0);
+    }
+  }
   function getCacheEntrySubscriptions(queryCacheKey, api2) {
     const state = api2.getState()[reducerPath];
     const querySubState = state.queries[queryCacheKey];
-    const subscriptions = internalState.currentSubscriptions[queryCacheKey];
+    const subscriptions = currentSubscriptions.get(queryCacheKey);
     if (!querySubState || querySubState.status === "uninitialized") return;
     return subscriptions;
   }
@@ -31989,20 +32050,20 @@ var buildPollingHandler = ({
   }, api2) {
     const state = api2.getState()[reducerPath];
     const querySubState = state.queries[queryCacheKey];
-    const subscriptions = internalState.currentSubscriptions[queryCacheKey];
+    const subscriptions = currentSubscriptions.get(queryCacheKey);
     if (!querySubState || querySubState.status === "uninitialized") return;
     const {
       lowestPollingInterval,
       skipPollingIfUnfocused
     } = findLowestPollingInterval(subscriptions);
     if (!Number.isFinite(lowestPollingInterval)) return;
-    const currentPoll = currentPolls[queryCacheKey];
+    const currentPoll = currentPolls.get(queryCacheKey);
     if (currentPoll?.timeout) {
       clearTimeout(currentPoll.timeout);
       currentPoll.timeout = void 0;
     }
     const nextPollTimestamp = Date.now() + lowestPollingInterval;
-    currentPolls[queryCacheKey] = {
+    currentPolls.set(queryCacheKey, {
       nextPollTimestamp,
       pollingInterval: lowestPollingInterval,
       timeout: setTimeout(() => {
@@ -32013,25 +32074,30 @@ var buildPollingHandler = ({
           queryCacheKey
         }, api2);
       }, lowestPollingInterval)
-    };
+    });
   }
   function updatePollingInterval({
     queryCacheKey
   }, api2) {
     const state = api2.getState()[reducerPath];
     const querySubState = state.queries[queryCacheKey];
-    const subscriptions = internalState.currentSubscriptions[queryCacheKey];
+    const subscriptions = currentSubscriptions.get(queryCacheKey);
     if (!querySubState || querySubState.status === "uninitialized") {
       return;
     }
     const {
       lowestPollingInterval
     } = findLowestPollingInterval(subscriptions);
+    if (process.env.NODE_ENV === "test") {
+      const updateCounters = currentPolls.pollUpdateCounters ?? (currentPolls.pollUpdateCounters = {});
+      updateCounters[queryCacheKey] ?? (updateCounters[queryCacheKey] = 0);
+      updateCounters[queryCacheKey]++;
+    }
     if (!Number.isFinite(lowestPollingInterval)) {
       cleanupPollForKey(queryCacheKey);
       return;
     }
-    const currentPoll = currentPolls[queryCacheKey];
+    const currentPoll = currentPolls.get(queryCacheKey);
     const nextPollTimestamp = Date.now() + lowestPollingInterval;
     if (!currentPoll || nextPollTimestamp < currentPoll.nextPollTimestamp) {
       startNextPoll({
@@ -32040,24 +32106,24 @@ var buildPollingHandler = ({
     }
   }
   function cleanupPollForKey(key) {
-    const existingPoll = currentPolls[key];
+    const existingPoll = currentPolls.get(key);
     if (existingPoll?.timeout) {
       clearTimeout(existingPoll.timeout);
     }
-    delete currentPolls[key];
+    currentPolls.delete(key);
   }
   function clearPolls() {
-    for (const key of Object.keys(currentPolls)) {
+    for (const key of currentPolls.keys()) {
       cleanupPollForKey(key);
     }
   }
-  function findLowestPollingInterval(subscribers = {}) {
+  function findLowestPollingInterval(subscribers = /* @__PURE__ */ new Map()) {
     let skipPollingIfUnfocused = false;
     let lowestPollingInterval = Number.POSITIVE_INFINITY;
-    for (let key in subscribers) {
-      if (!!subscribers[key].pollingInterval) {
-        lowestPollingInterval = Math.min(subscribers[key].pollingInterval, lowestPollingInterval);
-        skipPollingIfUnfocused = subscribers[key].skipPollingIfUnfocused || skipPollingIfUnfocused;
+    for (const entry of subscribers.values()) {
+      if (!!entry.pollingInterval) {
+        lowestPollingInterval = Math.min(entry.pollingInterval, lowestPollingInterval);
+        skipPollingIfUnfocused = entry.skipPollingIfUnfocused || skipPollingIfUnfocused;
       }
     }
     return {
@@ -32158,13 +32224,14 @@ var buildWindowEventHandler = ({
     const queries = state.queries;
     const subscriptions = internalState.currentSubscriptions;
     context.batch(() => {
-      for (const queryCacheKey of Object.keys(subscriptions)) {
+      for (const queryCacheKey of subscriptions.keys()) {
         const querySubState = queries[queryCacheKey];
-        const subscriptionSubState = subscriptions[queryCacheKey];
+        const subscriptionSubState = subscriptions.get(queryCacheKey);
         if (!subscriptionSubState || !querySubState) continue;
-        const shouldRefetch = Object.values(subscriptionSubState).some((sub) => sub[type] === true) || Object.values(subscriptionSubState).every((sub) => sub[type] === void 0) && state.config[type];
+        const values = [...subscriptionSubState.values()];
+        const shouldRefetch = values.some((sub) => sub[type] === true) || values.every((sub) => sub[type] === void 0) && state.config[type];
         if (shouldRefetch) {
-          if (countObjectKeys(subscriptionSubState) === 0) {
+          if (subscriptionSubState.size === 0) {
             api2.dispatch(removeQueryResult({
               queryCacheKey
             }));
@@ -32182,7 +32249,8 @@ function buildMiddleware(input) {
     reducerPath,
     queryThunk,
     api,
-    context
+    context,
+    internalState
   } = input;
   const {
     apiUid
@@ -32194,14 +32262,12 @@ function buildMiddleware(input) {
   const handlerBuilders = [buildDevCheckHandler, buildCacheCollectionHandler, buildInvalidationByTagsHandler, buildPollingHandler, buildCacheLifecycleHandler, buildQueryLifecycleHandler];
   const middleware = (mwApi) => {
     let initialized2 = false;
-    const internalState = {
-      currentSubscriptions: {}
-    };
     const builderArgs = {
       ...input,
       internalState,
       refetchQuery,
-      isThisApiSliceAction
+      isThisApiSliceAction,
+      mwApi
     };
     const handlers = handlerBuilders.map((build) => build(builderArgs));
     const batchedActionsHandler = buildBatchedActionsHandler(builderArgs);
@@ -32356,24 +32422,12 @@ var coreModule = ({
       upsertQueryEntries: sliceActions.cacheEntriesUpserted
     });
     safeAssign(api.internalActions, sliceActions);
-    const {
-      middleware,
-      actions: middlewareActions
-    } = buildMiddleware({
-      reducerPath,
-      context,
-      queryThunk,
-      mutationThunk,
-      infiniteQueryThunk,
-      api,
-      assertTagType,
-      selectors
-    });
-    safeAssign(api.util, middlewareActions);
-    safeAssign(api, {
-      reducer,
-      middleware
-    });
+    const internalState = {
+      currentSubscriptions: /* @__PURE__ */ new Map(),
+      currentPolls: /* @__PURE__ */ new Map(),
+      runningQueries: /* @__PURE__ */ new Map(),
+      runningMutations: /* @__PURE__ */ new Map()
+    };
     const {
       buildInitiateQuery,
       buildInitiateInfiniteQuery,
@@ -32388,7 +32442,8 @@ var coreModule = ({
       infiniteQueryThunk,
       api,
       serializeQueryArgs,
-      context
+      context,
+      internalState
     });
     safeAssign(api.util, {
       getRunningMutationThunk,
@@ -32396,6 +32451,26 @@ var coreModule = ({
       getRunningQueryThunk,
       getRunningQueriesThunk
     });
+    const {
+      middleware,
+      actions: middlewareActions
+    } = buildMiddleware({
+      reducerPath,
+      context,
+      queryThunk,
+      mutationThunk,
+      infiniteQueryThunk,
+      api,
+      assertTagType,
+      selectors,
+      getRunningQueryThunk,
+      internalState
+    });
+    safeAssign(api.util, middlewareActions);
+    safeAssign(api, {
+      reducer,
+      middleware
+    });
     return {
       name: coreModuleName,
       injectEndpoint(endpointName, definition) {
@@ -32463,22 +32538,15 @@ function safeAssign2(target, ...args) {
   return Object.assign(target, ...args);
 }
 var UNINITIALIZED_VALUE = Symbol();
-function useStableQueryArgs(queryArgs, serialize, endpointDefinition, endpointName) {
-  const incoming = useMemo(() => ({
-    queryArgs,
-    serialized: typeof queryArgs == "object" ? serialize({
-      queryArgs,
-      endpointDefinition,
-      endpointName
-    }) : queryArgs
-  }), [queryArgs, serialize, endpointDefinition, endpointName]);
-  const cache2 = useRef(incoming);
+function useStableQueryArgs(queryArgs) {
+  const cache2 = useRef(queryArgs);
+  const copy = useMemo(() => copyWithStructuralSharing(cache2.current, queryArgs), [queryArgs]);
   useEffect(() => {
-    if (cache2.current.serialized !== incoming.serialized) {
-      cache2.current = incoming;
+    if (cache2.current !== copy) {
+      cache2.current = copy;
     }
-  }, [incoming]);
-  return cache2.current.serialized === incoming.serialized ? cache2.current.queryArgs : queryArgs;
+  }, [copy]);
+  return copy;
 }
 function useShallowStableValue(value) {
   const cache2 = useRef2(value);
@@ -32631,17 +32699,7 @@ function buildHooks({
       }
       subscriptionSelectorsRef.current = returnedValue;
     }
-    const stableArg = useStableQueryArgs(
-      skip ? skipToken : arg,
-      // Even if the user provided a per-endpoint `serializeQueryArgs` with
-      // a consistent return value, _here_ we want to use the default behavior
-      // so we can tell if _anything_ actually changed. Otherwise, we can end up
-      // with a case where the query args did change but the serialization doesn't,
-      // and then we never try to initiate a refetch.
-      defaultSerializeQueryArgs,
-      context.endpointDefinitions[endpointName],
-      endpointName
-    );
+    const stableArg = useStableQueryArgs(skip ? skipToken : arg);
     const stableSubscriptionOptions = useShallowStableValue({
       refetchOnReconnect,
       refetchOnFocus,
@@ -32700,7 +32758,7 @@ function buildHooks({
       const {
         select
       } = api.endpoints[endpointName];
-      const stableArg = useStableQueryArgs(skip ? skipToken : arg, serializeQueryArgs, context.endpointDefinitions[endpointName], endpointName);
+      const stableArg = useStableQueryArgs(skip ? skipToken : arg);
       const lastValue = useRef3(void 0);
       const selectDefaultResult = useMemo2(() => (
         // Normally ts-ignores are bad and should be avoided, but we're
@@ -32872,17 +32930,7 @@ function buildHooks({
         return promise;
       }, [promiseRef, dispatch, initiate]);
       usePromiseRefUnsubscribeOnUnmount(promiseRef);
-      const stableArg = useStableQueryArgs(
-        options.skip ? skipToken : arg,
-        // Even if the user provided a per-endpoint `serializeQueryArgs` with
-        // a consistent return value, _here_ we want to use the default behavior
-        // so we can tell if _anything_ actually changed. Otherwise, we can end up
-        // with a case where the query args did change but the serialization doesn't,
-        // and then we never try to initiate a refetch.
-        defaultSerializeQueryArgs,
-        context.endpointDefinitions[endpointName],
-        endpointName
-      );
+      const stableArg = useStableQueryArgs(options.skip ? skipToken : arg);
       const refetch = useCallback(() => refetchOrErrorIfUnmounted(promiseRef), [promiseRef]);
       return useMemo2(() => {
         const fetchNextPage = () => {