https://axis-fe.up.railway.app/node_modules/.vite/deps/@reduxjs_toolkit_query_react.js?v=bf763330

1import __buffer_polyfill from "/node_modules/.vite/deps/vite-plugin-node-polyfills_shims_buffer.js?v=bf763330";
2globalThis.Buffer = globalThis.Buffer || __buffer_polyfill;
3import __global_polyfill from "/node_modules/.vite/deps/vite-plugin-node-polyfills_shims_global.js?v=bf763330";
4globalThis.global = globalThis.global || __global_polyfill;
5import __process_polyfill from "/node_modules/.vite/deps/vite-plugin-node-polyfills_shims_process.js?v=bf763330";
6globalThis.process = globalThis.process || __process_polyfill;
7import {
8  Provider_default,
9  ReactReduxContext,
10  batch,
11  shallowEqual,
12  useDispatch,
13  useSelector,
14  useStore
15} from "/node_modules/.vite/deps/chunk-4X6NLOIN.js?v=bf763330";
16import {
17  NamedSchemaError,
18  QueryStatus,
19  _NEVER,
20  buildCreateApi,
21  copyWithStructuralSharing,
22  coreModule,
23  coreModuleName,
24  defaultSerializeQueryArgs,
25  fakeBaseQuery,
26  fetchBaseQuery,
27  retry,
28  setupListeners,
29  skipToken
30} from "/node_modules/.vite/deps/chunk-WO3AQFYS.js?v=bf763330";
31import {
32  configureStore,
33  createSelector,
34  formatProdErrorMessage
35} from "/node_modules/.vite/deps/chunk-2ICND253.js?v=bf763330";
36import {
37  require_react
38} from "/node_modules/.vite/deps/chunk-OLCRR3H2.js?v=bf763330";
39import {
40  __toESM,
41  require_dist,
42  require_dist2,
43  require_dist3
44} from "/node_modules/.vite/deps/chunk-CURNFZRR.js?v=bf763330";
45var import_dist = __toESM(require_dist(), 1);
46var import_dist2 = __toESM(require_dist2(), 1);
47var import_dist3 = __toESM(require_dist3(), 1);
48var import_react = __toESM(require_react(), 1);
49var React = __toESM(require_react(), 1);
50function capitalize(str) {
51  return str.replace(str[0], str[0].toUpperCase());
52}
53function countObjectKeys(obj) {
54  let count = 0;
55  for (const _key in obj) {
56    count++;
57  }
58  return count;
59}
60var ENDPOINT_QUERY = "query";
61var ENDPOINT_MUTATION = "mutation";
62var ENDPOINT_INFINITEQUERY = "infinitequery";
63function isQueryDefinition(e) {
64  return e.type === ENDPOINT_QUERY;
65}
66function isMutationDefinition(e) {
67  return e.type === ENDPOINT_MUTATION;
68}
69function isInfiniteQueryDefinition(e) {
70  return e.type === ENDPOINT_INFINITEQUERY;
71}
72function safeAssign(target, ...args) {
73  return Object.assign(target, ...args);
74}
75var UNINITIALIZED_VALUE = Symbol();
76function useStableQueryArgs(queryArgs) {
77  const cache = (0, import_react.useRef)(queryArgs);
78  const copy = (0, import_react.useMemo)(() => copyWithStructuralSharing(cache.current, queryArgs), [queryArgs]);
79  (0, import_react.useEffect)(() => {
80    if (cache.current !== copy) {
81      cache.current = copy;
82    }
83  }, [copy]);
84  return copy;
85}
86function useShallowStableValue(value) {
87  const cache = (0, import_react.useRef)(value);
88  (0, import_react.useEffect)(() => {
89    if (!shallowEqual(cache.current, value)) {
90      cache.current = value;
91    }
92  }, [value]);
93  return shallowEqual(cache.current, value) ? cache.current : value;
94}
95var canUseDOM = () => !!(typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined");
96var isDOM = canUseDOM();
97var isRunningInReactNative = () => typeof navigator !== "undefined" && navigator.product === "ReactNative";
98var isReactNative = isRunningInReactNative();
99var getUseIsomorphicLayoutEffect = () => isDOM || isReactNative ? import_react.useLayoutEffect : import_react.useEffect;
100var useIsomorphicLayoutEffect = getUseIsomorphicLayoutEffect();
101var noPendingQueryStateSelector = (selected) => {
102  if (selected.isUninitialized) {
103    return {
104      ...selected,
105      isUninitialized: false,
106      isFetching: true,
107      isLoading: selected.data !== void 0 ? false : true,
108      // This is the one place where we still have to use `QueryStatus` as an enum,
109      // since it's the only reference in the React package and not in the core.
110      status: QueryStatus.pending
111    };
112  }
113  return selected;
114};
115function pick(obj, ...keys) {
116  const ret = {};
117  keys.forEach((key) => {
118    ret[key] = obj[key];
119  });
120  return ret;
121}
122var COMMON_HOOK_DEBUG_FIELDS = ["data", "status", "isLoading", "isSuccess", "isError", "error"];
123function buildHooks({
124  api,
125  moduleOptions: {
126    batch: batch2,
127    hooks: {
128      useDispatch: useDispatch2,
129      useSelector: useSelector2,
130      useStore: useStore2
131    },
132    unstable__sideEffectsInRender,
133    createSelector: createSelector2
134  },
135  serializeQueryArgs,
136  context
137}) {
138  const usePossiblyImmediateEffect = unstable__sideEffectsInRender ? (cb) => cb() : import_react.useEffect;
139  const unsubscribePromiseRef = (ref) => {
140    var _a, _b;
141    return (_b = (_a = ref.current) == null ? void 0 : _a.unsubscribe) == null ? void 0 : _b.call(_a);
142  };
143  const endpointDefinitions = context.endpointDefinitions;
144  return {
145    buildQueryHooks,
146    buildInfiniteQueryHooks,
147    buildMutationHook,
148    usePrefetch
149  };
150  function queryStatePreSelector(currentState, lastResult, queryArgs) {
151    if ((lastResult == null ? void 0 : lastResult.endpointName) && currentState.isUninitialized) {
152      const {
153        endpointName
154      } = lastResult;
155      const endpointDefinition = endpointDefinitions[endpointName];
156      if (queryArgs !== skipToken && serializeQueryArgs({
157        queryArgs: lastResult.originalArgs,
158        endpointDefinition,
159        endpointName
160      }) === serializeQueryArgs({
161        queryArgs,
162        endpointDefinition,
163        endpointName
164      })) lastResult = void 0;
165    }
166    let data = currentState.isSuccess ? currentState.data : lastResult == null ? void 0 : lastResult.data;
167    if (data === void 0) data = currentState.data;
168    const hasData = data !== void 0;
169    const isFetching = currentState.isLoading;
170    const isLoading = (!lastResult || lastResult.isLoading || lastResult.isUninitialized) && !hasData && isFetching;
171    const isSuccess = currentState.isSuccess || hasData && (isFetching && !(lastResult == null ? void 0 : lastResult.isError) || currentState.isUninitialized);
172    return {
173      ...currentState,
174      data,
175      currentData: currentState.data,
176      isFetching,
177      isLoading,
178      isSuccess
179    };
180  }
181  function infiniteQueryStatePreSelector(currentState, lastResult, queryArgs) {
182    if ((lastResult == null ? void 0 : lastResult.endpointName) && currentState.isUninitialized) {
183      const {
184        endpointName
185      } = lastResult;
186      const endpointDefinition = endpointDefinitions[endpointName];
187      if (queryArgs !== skipToken && serializeQueryArgs({
188        queryArgs: lastResult.originalArgs,
189        endpointDefinition,
190        endpointName
191      }) === serializeQueryArgs({
192        queryArgs,
193        endpointDefinition,
194        endpointName
195      })) lastResult = void 0;
196    }
197    let data = currentState.isSuccess ? currentState.data : lastResult == null ? void 0 : lastResult.data;
198    if (data === void 0) data = currentState.data;
199    const hasData = data !== void 0;
200    const isFetching = currentState.isLoading;
201    const isLoading = (!lastResult || lastResult.isLoading || lastResult.isUninitialized) && !hasData && isFetching;
202    const isSuccess = currentState.isSuccess || isFetching && hasData;
203    return {
204      ...currentState,
205      data,
206      currentData: currentState.data,
207      isFetching,
208      isLoading,
209      isSuccess
210    };
211  }
212  function usePrefetch(endpointName, defaultOptions) {
213    const dispatch = useDispatch2();
214    const stableDefaultOptions = useShallowStableValue(defaultOptions);
215    return (0, import_react.useCallback)((arg, options) => dispatch(api.util.prefetch(endpointName, arg, {
216      ...stableDefaultOptions,
217      ...options
218    })), [endpointName, dispatch, stableDefaultOptions]);
219  }
220  function useQuerySubscriptionCommonImpl(endpointName, arg, {
221    refetchOnReconnect,
222    refetchOnFocus,
223    refetchOnMountOrArgChange,
224    skip = false,
225    pollingInterval = 0,
226    skipPollingIfUnfocused = false,
227    ...rest
228  } = {}) {
229    const {
230      initiate
231    } = api.endpoints[endpointName];
232    const dispatch = useDispatch2();
233    const subscriptionSelectorsRef = (0, import_react.useRef)(void 0);
234    if (!subscriptionSelectorsRef.current) {
235      const returnedValue = dispatch(api.internalActions.internal_getRTKQSubscriptions());
236      if (true) {
237        if (typeof returnedValue !== "object" || typeof (returnedValue == null ? void 0 : returnedValue.type) === "string") {
238          throw new Error(false ? formatProdErrorMessage(37) : `Warning: Middleware for RTK-Query API at reducerPath "${api.reducerPath}" has not been added to the store.
239    You must add the middleware for RTK-Query to function correctly!`);
240        }
241      }
242      subscriptionSelectorsRef.current = returnedValue;
243    }
244    const stableArg = useStableQueryArgs(skip ? skipToken : arg);
245    const stableSubscriptionOptions = useShallowStableValue({
246      refetchOnReconnect,
247      refetchOnFocus,
248      pollingInterval,
249      skipPollingIfUnfocused
250    });
251    const initialPageParam = rest.initialPageParam;
252    const stableInitialPageParam = useShallowStableValue(initialPageParam);
253    const refetchCachedPages = rest.refetchCachedPages;
254    const stableRefetchCachedPages = useShallowStableValue(refetchCachedPages);
255    const promiseRef = (0, import_react.useRef)(void 0);
256    let {
257      queryCacheKey,
258      requestId
259    } = promiseRef.current || {};

260    let currentRenderHasSubscription = false;
261    if (queryCacheKey && requestId) {
262      currentRenderHasSubscription = subscriptionSelectorsRef.current.isRequestSubscribed(queryCacheKey, requestId);
263    }
264    const subscriptionRemoved = !currentRenderHasSubscription && promiseRef.current !== void 0;
265    usePossiblyImmediateEffect(() => {
266      if (subscriptionRemoved) {
267        promiseRef.current = void 0;
268      }
269    }, [subscriptionRemoved]);
270    usePossiblyImmediateEffect(() => {
271      var _a;
272      const lastPromise = promiseRef.current;
273      if (typeof process !== "undefined" && false) {
274        console.log(subscriptionRemoved);
275      }
276      if (stableArg === skipToken) {
277        lastPromise == null ? void 0 : lastPromise.unsubscribe();
278        promiseRef.current = void 0;
279        return;
280      }
281      const lastSubscriptionOptions = (_a = promiseRef.current) == null ? void 0 : _a.subscriptionOptions;
282      if (!lastPromise || lastPromise.arg !== stableArg) {
283        lastPromise == null ? void 0 : lastPromise.unsubscribe();
284        const promise = dispatch(initiate(stableArg, {
285          subscriptionOptions: stableSubscriptionOptions,
286          forceRefetch: refetchOnMountOrArgChange,
287          ...isInfiniteQueryDefinition(endpointDefinitions[endpointName]) ? {
288            initialPageParam: stableInitialPageParam,
289            refetchCachedPages: stableRefetchCachedPages
290          } : {}
291        }));
292        promiseRef.current = promise;
293      } else if (stableSubscriptionOptions !== lastSubscriptionOptions) {
294        lastPromise.updateSubscriptionOptions(stableSubscriptionOptions);
295      }
296    }, [dispatch, initiate, refetchOnMountOrArgChange, stableArg, stableSubscriptionOptions, subscriptionRemoved, stableInitialPageParam, stableRefetchCachedPages, endpointName]);
297    return [promiseRef, dispatch, initiate, stableSubscriptionOptions];
298  }
299  function buildUseQueryState(endpointName, preSelector) {
300    const useQueryState = (arg, {
301      skip = false,
302      selectFromResult
303    } = {}) => {
304      const {
305        select
306      } = api.endpoints[endpointName];
307      const stableArg = useStableQueryArgs(skip ? skipToken : arg);
308      const lastValue = (0, import_react.useRef)(void 0);
309      const selectDefaultResult = (0, import_react.useMemo)(() => (
310        // Normally ts-ignores are bad and should be avoided, but we're
311        // already casting this selector to be `Selector<any>` anyway,
312        // so the inconsistencies don't matter here
313        // @ts-ignore
314        createSelector2([
315          // @ts-ignore
316          select(stableArg),
317          (_, lastResult) => lastResult,
318          (_) => stableArg
319        ], preSelector, {
320          memoizeOptions: {
321            resultEqualityCheck: shallowEqual
322          }
323        })
324      ), [select, stableArg]);
325      const querySelector = (0, import_react.useMemo)(() => selectFromResult ? createSelector2([selectDefaultResult], selectFromResult, {
326        devModeChecks: {
327          identityFunctionCheck: "never"
328        }
329      }) : selectDefaultResult, [selectDefaultResult, selectFromResult]);
330      const currentState = useSelector2((state) => querySelector(state, lastValue.current), shallowEqual);
331      const store = useStore2();
332      const newLastValue = selectDefaultResult(store.getState(), lastValue.current);
333      useIsomorphicLayoutEffect(() => {
334        lastValue.current = newLastValue;
335      }, [newLastValue]);
336      return currentState;
337    };
338    return useQueryState;
339  }
340  function usePromiseRefUnsubscribeOnUnmount(promiseRef) {
341    (0, import_react.useEffect)(() => {
342      return () => {
343        unsubscribePromiseRef(promiseRef);
344        promiseRef.current = void 0;
345      };
346    }, [promiseRef]);
347  }
348  function refetchOrErrorIfUnmounted(promiseRef) {
349    if (!promiseRef.current) throw new Error(false ? formatProdErrorMessage(38) : "Cannot refetch a query that has not been started yet.");
350    return promiseRef.current.refetch();
351  }
352  function buildQueryHooks(endpointName) {
353    const useQuerySubscription = (arg, options = {}) => {
354      const [promiseRef] = useQuerySubscriptionCommonImpl(endpointName, arg, options);
355      usePromiseRefUnsubscribeOnUnmount(promiseRef);
356      return (0, import_react.useMemo)(() => ({
357        /**
358         * A method to manually refetch data for the query
359         */
360        refetch: () => refetchOrErrorIfUnmounted(promiseRef)
361      }), [promiseRef]);
362    };
363    const useLazyQuerySubscription = ({
364      refetchOnReconnect,
365      refetchOnFocus,
366      pollingInterval = 0,
367      skipPollingIfUnfocused = false
368    } = {}) => {
369      const {
370        initiate
371      } = api.endpoints[endpointName];
372      const dispatch = useDispatch2();
373      const [arg, setArg] = (0, import_react.useState)(UNINITIALIZED_VALUE);
374      const promiseRef = (0, import_react.useRef)(void 0);
375      const stableSubscriptionOptions = useShallowStableValue({
376        refetchOnReconnect,
377        refetchOnFocus,
378        pollingInterval,
379        skipPollingIfUnfocused
380      });
381      usePossiblyImmediateEffect(() => {
382        var _a, _b;
383        const lastSubscriptionOptions = (_a = promiseRef.current) == null ? void 0 : _a.subscriptionOptions;
384        if (stableSubscriptionOptions !== lastSubscriptionOptions) {
385          (_b = promiseRef.current) == null ? void 0 : _b.updateSubscriptionOptions(stableSubscriptionOptions);
386        }
387      }, [stableSubscriptionOptions]);
388      const subscriptionOptionsRef = (0, import_react.useRef)(stableSubscriptionOptions);
389      usePossiblyImmediateEffect(() => {
390        subscriptionOptionsRef.current = stableSubscriptionOptions;
391      }, [stableSubscriptionOptions]);
392      const trigger = (0, import_react.useCallback)(function(arg2, preferCacheValue = false) {
393        let promise;
394        batch2(() => {
395          unsubscribePromiseRef(promiseRef);
396          promiseRef.current = promise = dispatch(initiate(arg2, {
397            subscriptionOptions: subscriptionOptionsRef.current,
398            forceRefetch: !preferCacheValue
399          }));
400          setArg(arg2);
401        });
402        return promise;
403      }

403, [dispatch, initiate]);
404      const reset = (0, import_react.useCallback)(() => {
405        var _a, _b;
406        if ((_a = promiseRef.current) == null ? void 0 : _a.queryCacheKey) {
407          dispatch(api.internalActions.removeQueryResult({
408            queryCacheKey: (_b = promiseRef.current) == null ? void 0 : _b.queryCacheKey
409          }));
410        }
411      }, [dispatch]);
412      (0, import_react.useEffect)(() => {
413        return () => {
414          unsubscribePromiseRef(promiseRef);
415        };
416      }, []);
417      (0, import_react.useEffect)(() => {
418        if (arg !== UNINITIALIZED_VALUE && !promiseRef.current) {
419          trigger(arg, true);
420        }
421      }, [arg, trigger]);
422      return (0, import_react.useMemo)(() => [trigger, arg, {
423        reset
424      }], [trigger, arg, reset]);
425    };
426    const useQueryState = buildUseQueryState(endpointName, queryStatePreSelector);
427    return {
428      useQueryState,
429      useQuerySubscription,
430      useLazyQuerySubscription,
431      useLazyQuery(options) {
432        const [trigger, arg, {
433          reset
434        }] = useLazyQuerySubscription(options);
435        const queryStateResults = useQueryState(arg, {
436          ...options,
437          skip: arg === UNINITIALIZED_VALUE
438        });
439        const info = (0, import_react.useMemo)(() => ({
440          lastArg: arg
441        }), [arg]);
442        return (0, import_react.useMemo)(() => [trigger, {
443          ...queryStateResults,
444          reset
445        }, info], [trigger, queryStateResults, reset, info]);
446      },
447      useQuery(arg, options) {
448        const querySubscriptionResults = useQuerySubscription(arg, options);
449        const queryStateResults = useQueryState(arg, {
450          selectFromResult: arg === skipToken || (options == null ? void 0 : options.skip) ? void 0 : noPendingQueryStateSelector,
451          ...options
452        });
453        const debugValue = pick(queryStateResults, ...COMMON_HOOK_DEBUG_FIELDS);
454        (0, import_react.useDebugValue)(debugValue);
455        return (0, import_react.useMemo)(() => ({
456          ...queryStateResults,
457          ...querySubscriptionResults
458        }), [queryStateResults, querySubscriptionResults]);
459      }
460    };
461  }
462  function buildInfiniteQueryHooks(endpointName) {
463    const useInfiniteQuerySubscription = (arg, options = {}) => {
464      const [promiseRef, dispatch, initiate, stableSubscriptionOptions] = useQuerySubscriptionCommonImpl(endpointName, arg, options);
465      const subscriptionOptionsRef = (0, import_react.useRef)(stableSubscriptionOptions);
466      usePossiblyImmediateEffect(() => {
467        subscriptionOptionsRef.current = stableSubscriptionOptions;
468      }, [stableSubscriptionOptions]);
469      const hookRefetchCachedPages = options.refetchCachedPages;
470      const stableHookRefetchCachedPages = useShallowStableValue(hookRefetchCachedPages);
471      const trigger = (0, import_react.useCallback)(function(arg2, direction) {
472        let promise;
473        batch2(() => {
474          unsubscribePromiseRef(promiseRef);
475          promiseRef.current = promise = dispatch(initiate(arg2, {
476            subscriptionOptions: subscriptionOptionsRef.current,
477            direction
478          }));
479        });
480        return promise;
481      }, [promiseRef, dispatch, initiate]);
482      usePromiseRefUnsubscribeOnUnmount(promiseRef);
483      const stableArg = useStableQueryArgs(options.skip ? skipToken : arg);
484      const refetch = (0, import_react.useCallback)((options2) => {
485        if (!promiseRef.current) throw new Error(false ? formatProdErrorMessage(38) : "Cannot refetch a query that has not been started yet.");
486        const mergedOptions = {
487          refetchCachedPages: (options2 == null ? void 0 : options2.refetchCachedPages) ?? stableHookRefetchCachedPages
488        };
489        return promiseRef.current.refetch(mergedOptions);
490      }, [promiseRef, stableHookRefetchCachedPages]);
491      return (0, import_react.useMemo)(() => {
492        const fetchNextPage = () => {
493          return trigger(stableArg, "forward");
494        };
495        const fetchPreviousPage = () => {
496          return trigger(stableArg, "backward");
497        };
498        return {
499          trigger,
500          /**
501           * A method to manually refetch data for the query
502           */
503          refetch,
504          fetchNextPage,
505          fetchPreviousPage
506        };
507      }, [refetch, trigger, stableArg]);
508    };
509    const useInfiniteQueryState = buildUseQueryState(endpointName, infiniteQueryStatePreSelector);
510    return {
511      useInfiniteQueryState,
512      useInfiniteQuerySubscription,
513      useInfiniteQuery(arg, options) {
514        const {
515          refetch,
516          fetchNextPage,
517          fetchPreviousPage
518        } = useInfiniteQuerySubscription(arg, options);
519        const queryStateResults = useInfiniteQueryState(arg, {
520          selectFromResult: arg === skipToken || (options == null ? void 0 : options.skip) ? void 0 : noPendingQueryStateSelector,
521          ...options
522        });
523        const debugValue = pick(queryStateResults, ...COMMON_HOOK_DEBUG_FIELDS, "hasNextPage", "hasPreviousPage");
524        (0, import_react.useDebugValue)(debugValue);
525        return (0, import_react.useMemo)(() => ({
526          ...queryStateResults,
527          fetchNextPage,
528          fetchPreviousPage,
529          refetch
530        }), [queryStateResults, fetchNextPage, fetchPreviousPage, refetch]);
531      }
532    };
533  }
534  function buildMutationHook(name) {
535    return ({
536      selectFromResult,
537      fixedCacheKey
538    } = {}) => {
539      const {
540        select,
541        initiate
542      } = api.endpoints[name];
543      const dispatch = useDispatch2();
544      const [promise, setPromise] = (0, import_react.useState)();
545      (0, import_react.useEffect)(() => () => {
546        if (!(promise == null ? void 0 : promise.arg.fixedCacheKey)) {
547          promise == null ? void 0 : promise.reset();
548        }
549      }, [promise]);
550      const triggerMutation = (0, import_react.useCallback)(function(arg) {
551        const promise2 = dispatch(initiate(arg, {
552          fixedCacheKey
553        }));
554        setPromise(promise2);
555        return promise2;
556      }

556, [dispatch, initiate, fixedCacheKey]);
557      const {
558        requestId
559      } = promise || {};
560      const selectDefaultResult = (0, import_react.useMemo)(() => select({
561        fixedCacheKey,
562        requestId: promise == null ? void 0 : promise.requestId
563      }), [fixedCacheKey, promise, select]);
564      const mutationSelector = (0, import_react.useMemo)(() => selectFromResult ? createSelector2([selectDefaultResult], selectFromResult) : selectDefaultResult, [selectFromResult, selectDefaultResult]);
565      const currentState = useSelector2(mutationSelector, shallowEqual);
566      const originalArgs = fixedCacheKey == null ? promise == null ? void 0 : promise.arg.originalArgs : void 0;
567      const reset = (0, import_react.useCallback)(() => {
568        batch2(() => {
569          if (promise) {
570            setPromise(void 0);
571          }
572          if (fixedCacheKey) {
573            dispatch(api.internalActions.removeMutationResult({
574              requestId,
575              fixedCacheKey
576            }));
577          }
578        });
579      }, [dispatch, fixedCacheKey, promise, requestId]);
580      const debugValue = pick(currentState, ...COMMON_HOOK_DEBUG_FIELDS, "endpointName");
581      (0, import_react.useDebugValue)(debugValue);
582      const finalState = (0, import_react.useMemo)(() => ({
583        ...currentState,
584        originalArgs,
585        reset
586      }), [currentState, originalArgs, reset]);
587      return (0, import_react.useMemo)(() => [triggerMutation, finalState], [triggerMutation, finalState]);
588    };
589  }
590}
591var reactHooksModuleName = Symbol();
592var reactHooksModule = ({
593  batch: batch2 = batch,
594  hooks = {
595    useDispatch,
596    useSelector,
597    useStore
598  },
599  createSelector: createSelector2 = createSelector,
600  unstable__sideEffectsInRender = false,
601  ...rest
602} = {}) => {
603  if (true) {
604    const hookNames = ["useDispatch", "useSelector", "useStore"];
605    let warned = false;
606    for (const hookName of hookNames) {
607      if (countObjectKeys(rest) > 0) {
608        if (rest[hookName]) {
609          if (!warned) {
610            console.warn("As of RTK 2.0, the hooks now need to be specified as one object, provided under a `hooks` key:\n`reactHooksModule({ hooks: { useDispatch, useSelector, useStore } })`");
611            warned = true;
612          }
613        }
614        hooks[hookName] = rest[hookName];
615      }
616      if (typeof hooks[hookName] !== "function") {
617        throw new Error(false ? formatProdErrorMessage(36) : `When using custom hooks for context, all ${hookNames.length} hooks need to be provided: ${hookNames.join(", ")}.
618Hook ${hookName} was either not provided or not a function.`);
619      }
620    }
621  }
622  return {
623    name: reactHooksModuleName,
624    init(api, {
625      serializeQueryArgs
626    }, context) {
627      const anyApi = api;
628      const {
629        buildQueryHooks,
630        buildInfiniteQueryHooks,
631        buildMutationHook,
632        usePrefetch
633      } = buildHooks({
634        api,
635        moduleOptions: {
636          batch: batch2,
637          hooks,
638          unstable__sideEffectsInRender,
639          createSelector: createSelector2
640        },
641        serializeQueryArgs,
642        context
643      });
644      safeAssign(anyApi, {
645        usePrefetch
646      });
647      safeAssign(context, {
648        batch: batch2
649      });
650      return {
651        injectEndpoint(endpointName, definition) {
652          if (isQueryDefinition(definition)) {
653            const {
654              useQuery,
655              useLazyQuery,
656              useLazyQuerySubscription,
657              useQueryState,
658              useQuerySubscription
659            } = buildQueryHooks(endpointName);
660            safeAssign(anyApi.endpoints[endpointName], {
661              useQuery,
662              useLazyQuery,
663              useLazyQuerySubscription,
664              useQueryState,
665              useQuerySubscription
666            });
667            api[`use${capitalize(endpointName)}Query`] = useQuery;
668            api[`useLazy${capitalize(endpointName)}Query`] = useLazyQuery;
669          }
670          if (isMutationDefinition(definition)) {
671            const useMutation = buildMutationHook(endpointName);
672            safeAssign(anyApi.endpoints[endpointName], {
673              useMutation
674            });
675            api[`use${capitalize(endpointName)}Mutation`] = useMutation;
676          } else if (isInfiniteQueryDefinition(definition)) {
677            const {
678              useInfiniteQuery,
679              useInfiniteQuerySubscription,
680              useInfiniteQueryState
681            } = buildInfiniteQueryHooks(endpointName);
682            safeAssign(anyApi.endpoints[endpointName], {
683              useInfiniteQuery,
684              useInfiniteQuerySubscription,
685              useInfiniteQueryState
686            });
687            api[`use${capitalize(endpointName)}InfiniteQuery`] = useInfiniteQuery;
688          }
689        }
690      };
691    }
692  };
693};
694function ApiProvider(props) {
695  const context = props.context || ReactReduxContext;
696  const existingContext = (0, import_react.useContext)(context);
697  if (existingContext) {
698    throw new Error(false ? formatProdErrorMessage(35) : "Existing Redux context detected. If you already have a store set up, please use the traditional Redux setup.");
699  }
700  const [store] = React.useState(() => configureStore({
701    reducer: {
702      [props.api.reducerPath]: props.api.reducer
703    },
704    middleware: (gDM) => gDM().concat(props.api.middleware)
705  }));
706  (0, import_react.useEffect)(() => props.setupListeners === false ? void 0 : setupListeners(store.dispatch, props.setupListeners), [props.setupListeners, store.dispatch]);
707  return React.createElement(Provider_default, { store, context }, props.children);
708}

709var createApi = buildCreateApi(coreModule(), reactHooksModule());
710export {
711  ApiProvider,
712  NamedSchemaError,
713  QueryStatus,
714  UNINITIALIZED_VALUE,
715  _NEVER,
716  buildCreateApi,
717  copyWithStructuralSharing,
718  coreModule,
719  coreModuleName,
720  createApi,
721  defaultSerializeQueryArgs,
722  fakeBaseQuery,
723  fetchBaseQuery,
724  reactHooksModule,
725  reactHooksModuleName,
726  retry,
727  setupListeners,
728  skipToken
729};
730
731//# sourceMappingURL=data:application/json;base64,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

731HJldHVybiAoMCwgaW1wb3J0X3JlYWN0LnVzZU1lbW8pKCgpID0+ICh7XG4gICAgICAgICAgLi4ucXVlcnlTdGF0ZVJlc3VsdHMsXG4gICAgICAgICAgLi4ucXVlcnlTdWJzY3JpcHRpb25SZXN1bHRzXG4gICAgICAgIH0pLCBbcXVlcnlTdGF0ZVJlc3VsdHMsIHF1ZXJ5U3Vic2NyaXB0aW9uUmVzdWx0c10pO1xuICAgICAgfVxuICAgIH07XG4gIH1cbiAgZnVuY3Rpb24gYnVpbGRJbmZpbml0ZVF1ZXJ5SG9va3MoZW5kcG9pbnROYW1lKSB7XG4gICAgY29uc3QgdXNlSW5maW5pdGVRdWVyeVN1YnNjcmlwdGlvbiA9IChhcmcsIG9wdGlvbnMgPSB7fSkgPT4ge1xuICAgICAgY29uc3QgW3Byb21pc2VSZWYsIGRpc3BhdGNoLCBpbml0aWF0ZSwgc3RhYmxlU3Vic2NyaXB0aW9uT3B0aW9uc10gPSB1c2VRdWVyeVN1YnNjcmlwdGlvbkNvbW1vbkltcGwoZW5kcG9pbnROYW1lLCBhcmcsIG9wdGlvbnMpO1xuICAgICAgY29uc3Qgc3Vic2NyaXB0aW9uT3B0aW9uc1JlZiA9ICgwLCBpbXBvcnRfcmVhY3QudXNlUmVmKShzdGFibGVTdWJzY3JpcHRpb25PcHRpb25zKTtcbiAgICAgIHVzZVBvc3NpYmx5SW1tZWRpYXRlRWZmZWN0KCgpID0+IHtcbiAgICAgICAgc3Vic2NyaXB0aW9uT3B0aW9uc1JlZi5jdXJyZW50ID0gc3RhYmxlU3Vic2NyaXB0aW9uT3B0aW9ucztcbiAgICAgIH0sIFtzdGFibGVTdWJzY3JpcHRpb25PcHRpb25zXSk7XG4gICAgICBjb25zdCBob29rUmVmZXRjaENhY2hlZFBhZ2VzID0gb3B0aW9ucy5yZWZldGNoQ2FjaGVkUGFnZXM7XG4gICAgICBjb25zdCBzdGFibGVIb29rUmVmZXRjaENhY2hlZFBhZ2VzID0gdXNlU2hhbGxvd1N0YWJsZVZhbHVlKGhvb2tSZWZldGNoQ2FjaGVkUGFnZXMpO1xuICAgICAgY29uc3QgdHJpZ2dlciA9ICgwLCBpb

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

731H0pO1xuICAgICAgICAgICAgYXBpW2B1c2Uke2NhcGl0YWxpemUoZW5kcG9pbnROYW1lKX1NdXRhdGlvbmBdID0gdXNlTXV0YXRpb247XG4gICAgICAgICAgfSBlbHNlIGlmIChpc0luZmluaXRlUXVlcnlEZWZpbml0aW9uKGRlZmluaXRpb24pKSB7XG4gICAgICAgICAgICBjb25zdCB7XG4gICAgICAgICAgICAgIHVzZUluZmluaXRlUXVlcnksXG4gICAgICAgICAgICAgIHVzZUluZmluaXRlUXVlcnlTdWJzY3JpcHRpb24sXG4gICAgICAgICAgICAgIHVzZUluZmluaXRlUXVlcnlTdGF0ZVxuICAgICAgICAgICAgfSA9IGJ1aWxkSW5maW5pdGVRdWVyeUhvb2tzKGVuZHBvaW50TmFtZSk7XG4gICAgICAgICAgICBzYWZlQXNzaWduKGFueUFwaS5lbmRwb2ludHNbZW5kcG9pbnROYW1lXSwge1xuICAgICAgICAgICAgICB1c2VJbmZpbml0ZVF1ZXJ5LFxuICAgICAgICAgICAgICB1c2VJbmZpbml0ZVF1ZXJ5U3Vic2NyaXB0aW9uLFxuICAgICAgICAgICAgICB1c2VJbmZpbml0ZVF1ZXJ5U3RhdGVcbiAgICAgICAgICAgIH0pO1xuICAgICAgICAgICAgYXBpW2B1c2Uke2NhcGl0YWxpemUoZW5kcG9pbnROYW1lKX1JbmZpbml0ZVF1ZXJ5YF0gPSB1c2VJbmZpbml0ZVF1ZXJ5O1xuICAgICAgICAgIH1cbiAgICAgICAgfVxuICAgICAgfTtcbiAgICB9XG4gIH07XG59O1xuZnVuY3Rpb24gQXBpUHJvdmlkZXIocHJvcHMpIHtcbiAgY29uc3QgY29udGV4dCA9IHByb3BzLmNvbnRleHQgfHwgUmVhY3RSZWR1eENvbnRleHQ7XG4gIGNvbnN0IGV4aXN0aW5nQ29udGV4dCA9ICgwLCBpb

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

731FZO0FBQzdGLElBQUksZ0JBQWdCLHVCQUF1QjtBQUMzQyxJQUFJLCtCQUErQixNQUFNLFNBQVMsZ0JBQWdCLGFBQWEsa0JBQWtCLGFBQWE7QUFDOUcsSUFBSSw0QkFBNEIsNkJBQTZCO0FBQzdELElBQUksOEJBQThCLENBQUMsYUFBYTtBQUM5QyxNQUFJLFNBQVMsaUJBQWlCO0FBQzVCLFdBQU87QUFBQSxNQUNMLEdBQUc7QUFBQSxNQUNILGlCQUFpQjtBQUFBLE1BQ2pCLFlBQVk7QUFBQSxNQUNaLFdBQVcsU0FBUyxTQUFTLFNBQVMsUUFBUTtBQUFBO0FBQUE7QUFBQSxNQUc5QyxRQUFRLFlBQVk7QUFBQSxJQUN0QjtBQUFBLEVBQ0Y7QUFDQSxTQUFPO0FBQ1Q7QUFDQSxTQUFTLEtBQUssUUFBUSxNQUFNO0FBQzFCLFFBQU0sTUFBTSxDQUFDO0FBQ2IsT0FBSyxRQUFRLENBQUMsUUFBUTtBQUNwQixRQUFJLEdBQUcsSUFBSSxJQUFJLEdBQUc7QUFBQSxFQUNwQixDQUFDO0FBQ0QsU0FBTztBQUNUO0FBQ0EsSUFBSSwyQkFBMkIsQ0FBQyxRQUFRLFVBQVUsYUFBYSxhQUFhLFdBQVcsT0FBTztBQUM5RixTQUFTLFdBQVc7QUFBQSxFQUNsQjtBQUFBLEVBQ0EsZUFBZTtBQUFBLElBQ2IsT0FBTztBQUFBLElBQ1AsT0FBTztBQUFBLE1BQ0wsYUFBYTtBQUFBLE1BQ2IsYUFBYTtBQUFBLE1BQ2IsVUFBVTtBQUFBLElBQ1o7QUFBQSxJQUNBO0FBQUEsSUFDQSxnQkFBZ0I7QUFBQSxFQUNsQjtBQUFBLEVBQ0E7QUFBQSxFQUNBO0FBQ0YsR0FBRztBQUNELFFBQU0sNkJBQTZCLGdDQUFnQyxDQUFDLE9BQU8sR0FBRyxJQUFJLGFBQWE7QUFDL0YsUUFBTSx3QkFBd0IsQ0FBQyxRQUFRO0FBQ3JDLFFBQUksSUFBSTtBQUNSLFlBQVEsTUFBTSxLQUFLLElBQUksWUFBWSxPQUFPLFNBQVMsR0FBRyxnQkFBZ0IsT0FBTyxTQUFTLEdBQUcsS0FBSyxFQUFFO0FBQUEsRUFDbEc7QUFDQSxRQUFNLHNCQUFzQixRQUFRO0FBQ3BDLFNBQU87QUFBQSxJQUNMO0FBQUEsSUFDQTtBQUFBLElBQ0E7QUFBQSxJQUNBO0FBQUEsRUFDRjtBQUNBLFdBQVMsc0JBQXNCLGNBQWMsWUFBWSxXQUFXO0FBQ2xFLFNBQUssY0FBYyxPQUFPLFNBQVMsV0FBVyxpQkFBaUIsYUFBYSxpQkFBaUI7QUFDM0YsWUFBTTtBQUFBLFFBQ0o7QUFBQSxNQUNGLElBQUk7QUFDSixZQUFNLHFCQUFxQixvQkFBb0IsWUFBWTtBQUMzRCxVQUFJLGNBQWMsYUFBYSxtQkFBbUI7QUFBQSxRQUNoRCxXQUFXLFdBQVc7QUFBQSxRQUN0QjtBQUFBLFFBQ0E7QUFBQSxNQUNGLENBQUMsTUFBTSxtQkFBbUI7QUFBQSxRQUN4QjtBQUFBLFFBQ0E7QUFBQSxRQUNBO0FBQUEsTUFDRixDQUFDLEVBQUcsY0FBYTtBQUFBLElBQ25CO0FBQ0EsUUFBSSxPQUFPLGFBQWEsWUFBWSxhQUFhLE9BQU8sY0FBYyxPQUFPLFNBQVMsV0FBVztBQUNqRyxRQUFJLFNBQVMsT0FBUSxRQUFPLGFBQWE7QUFDekMsVUFBTSxVQUFVLFNBQVM7QUFDekIsVUFBTSxhQUFhLGFBQWE7QUFDaEMsVUFBTSxhQUFhLENBQUMsY0FBYyxXQUFXLGFBQWEsV0FBVyxvQkFBb0IsQ0FBQyxXQUFXO0FBQ3JHLFVBQU0sWUFBWSxhQUFhLGFBQWEsWUFBWSxjQUFjLEVBQUUsY0FBYyxPQUFPLFNBQVMsV0FBVyxZQUFZLGFBQWE7QUFDMUksV0FBTztBQUFBLE1BQ0wsR0FBRztBQUFBLE1BQ0g7QUFBQSxNQUNBLGFBQWEsYUFBYTtBQUFBLE1BQzFCO0FBQUEsTUFDQTtBQUFBLE1BQ0E7QUFBQSxJQUNGO0FBQUEsRUFDRjtBQUNBLFdBQVMsOEJBQThCLGNBQWMsWUFBWSxXQUFXO0FBQzFFLFNBQUssY0FBYyxPQUFPLFNBQVMsV0FBVyxpQkFBaUIsYUFBYSxpQkFBaUI7QUFDM0YsWUFBTTtBQUFBLFFBQ0o7QUFBQSxNQUNGLElBQUk7QUFDSixZQUFNLHFCQUFxQixvQkFBb0IsWUFBWTtBQUMzRCxVQUFJLGNBQWMsYUFBYSxtQkFBbUI7QUFBQSxRQUNoRCxXQUFXLFdBQVc7QUFBQSxRQUN0QjtBQUFBLFFBQ0E7QUFBQSxNQUNGLENBQUMsTUFBTSxtQkFBbUI7QUFBQSxRQUN4QjtBQUFBLFFBQ0E7QUFBQSxRQUNBO0FBQUEsTUFDRixDQUFDLEVBQUcsY0FBYTtBQUFBLElBQ25CO0FBQ0EsUUFBSSxPQUFPLGFBQWEsWUFBWSxhQUFhLE9BQU8sY0FBYyxPQUFPLFNBQVMsV0FBVztBQUNqRyxRQUFJLFNBQVMsT0FBUSxRQUFPLGFBQWE7QUFDekMsVUFBTSxVQUFVLFNBQVM7QUFDekIsVUFBTSxhQUFhLGFBQWE7QUFDaEMsVUFBTSxhQUFhLENBQUMsY0FBYyxXQUFXLGFBQWEsV0FBVyxvQkFBb0IsQ0FBQyxXQUFXO0FBQ3JHLFVBQU0sWUFBWSxhQUFhLGFBQWEsY0FBYztBQUMxRCxXQUFPO0FBQUEsTUFDTCxHQUFHO0FBQUEsTUFDSDtBQUFBLE1BQ0EsYUFBYSxhQUFhO0FBQUEsTUFDMUI7QUFBQSxNQUNBO0FBQUEsTUFDQTtBQUFBLElBQ0Y7QUFBQSxFQUNGO0FBQ0EsV0FBUyxZQUFZLGNBQWMsZ0JBQWdCO0FBQ2pELFVBQU0sV0FBVyxhQUFhO0FBQzlCLFVBQU0sdUJBQXVCLHNCQUFzQixjQUFjO0FBQ2pFLFlBQVEsR0FBRyxhQUFhLGFBQWEsQ0FBQyxLQUFLLFlBQVksU0FBUyxJQUFJLEtBQUssU0FBUyxjQUFjLEtBQUs7QUFBQSxNQUNuRyxHQUFHO0FBQUEsTUFDSCxHQUFHO0FBQUEsSUFDTCxDQUFDLENBQUMsR0FBRyxDQUFDLGNBQWMsVUFBVSxvQkFBb0IsQ0FBQztBQUFBLEVBQ3JEO0FBQ0EsV0FBUywrQkFBK0IsY0FBYyxLQUFLO0FBQUEsSUFDekQ7QUFBQSxJQUNBO0FBQUEsSUFDQTtBQUFBLElBQ0EsT0FBTztBQUFBLElBQ1Asa0JBQWtCO0FBQUEsSUFDbEIseUJBQXlCO0FBQUEsSUFDekIsR0FBRztBQUFBLEVBQ0wsSUFBSSxDQUFDLEdBQUc7QUFDTixVQUFNO0FBQUEsTUFDSjtBQUFBLElBQ0YsSUFBSSxJQUFJLFVBQVUsWUFBWTtBQUM5QixVQUFNLFdBQVcsYUFBYTtBQUM5QixVQUFNLDRCQUE0QixHQUFHLGFBQWEsUUFBUSxNQUFNO0FBQ2hFLFFBQUksQ0FBQyx5QkFBeUIsU0FBUztBQUNyQyxZQUFNLGdCQUFnQixTQUFTLElBQUksZ0JBQWdCLDhCQUE4QixDQUFDO0FBQ2xGLFVBQUksTUFBdUM7QUFDekMsWUFBSSxPQUFPLGtCQUFrQixZQUFZLFFBQVEsaUJBQWlCLE9BQU8sU0FBUyxjQUFjLFVBQVUsVUFBVTtBQUNsSCxnQkFBTSxJQUFJLE1BQU0sUUFBd0MsdUJBQXVCLEVBQUUsSUFBSSx5REFBeUQsSUFBSSxXQUFXO0FBQUEscUVBQ2xHO0FBQUEsUUFDN0Q7QUFBQSxNQUNGO0FBQ0EsK0JBQXlCLFVBQVU7QUFBQSxJQUNyQztBQUNBLFVBQU0sWUFBWSxtQkFBbUIsT0FBTyxZQUFZLEd

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