Version 1.0.2 mit node_modules Verzeichnis

node_modules/@reduxjs/toolkit/dist/query/react/cjs/index.js

@@ -0,0 +1,6 @@
+'use strict'
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./rtk-query-react.production.min.cjs')
+} else {
+  module.exports = require('./rtk-query-react.development.cjs')
+}

node_modules/@reduxjs/toolkit/dist/query/react/cjs/rtk-query-react.development.cjs

@@ -0,0 +1,651 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/query/react/index.ts
+var react_exports = {};
+__export(react_exports, {
+  ApiProvider: () => ApiProvider,
+  UNINITIALIZED_VALUE: () => UNINITIALIZED_VALUE,
+  createApi: () => createApi,
+  reactHooksModule: () => reactHooksModule,
+  reactHooksModuleName: () => reactHooksModuleName
+});
+module.exports = __toCommonJS(react_exports);
+var import_query3 = require("@reduxjs/toolkit/query");
+
+// src/query/react/module.ts
+var import_toolkit3 = require("@reduxjs/toolkit");
+var import_react_redux3 = require("react-redux");
+var import_reselect = require("reselect");
+
+// src/query/endpointDefinitions.ts
+function isQueryDefinition(e) {
+  return e.type === "query" /* query */;
+}
+function isMutationDefinition(e) {
+  return e.type === "mutation" /* mutation */;
+}
+
+// src/query/tsHelpers.ts
+function safeAssign(target, ...args) {
+  return Object.assign(target, ...args);
+}
+
+// src/query/utils/capitalize.ts
+function capitalize(str) {
+  return str.replace(str[0], str[0].toUpperCase());
+}
+
+// src/query/core/rtkImports.ts
+var import_toolkit = require("@reduxjs/toolkit");
+
+// src/query/utils/countObjectKeys.ts
+function countObjectKeys(obj) {
+  let count = 0;
+  for (const _key in obj) {
+    count++;
+  }
+  return count;
+}
+
+// src/query/react/buildHooks.ts
+var import_toolkit2 = require("@reduxjs/toolkit");
+var import_query = require("@reduxjs/toolkit/query");
+var import_react3 = require("react");
+var import_react_redux2 = require("react-redux");
+
+// src/query/defaultSerializeQueryArgs.ts
+var cache = WeakMap ? /* @__PURE__ */ new WeakMap() : void 0;
+var defaultSerializeQueryArgs = ({
+  endpointName,
+  queryArgs
+}) => {
+  let serialized = "";
+  const cached = cache?.get(queryArgs);
+  if (typeof cached === "string") {
+    serialized = cached;
+  } else {
+    const stringified = JSON.stringify(queryArgs, (key, value) => {
+      value = typeof value === "bigint" ? {
+        $bigint: value.toString()
+      } : value;
+      value = (0, import_toolkit.isPlainObject)(value) ? Object.keys(value).sort().reduce((acc, key2) => {
+        acc[key2] = value[key2];
+        return acc;
+      }, {}) : value;
+      return value;
+    });
+    if ((0, import_toolkit.isPlainObject)(queryArgs)) {
+      cache?.set(queryArgs, stringified);
+    }
+    serialized = stringified;
+  }
+  return `${endpointName}(${serialized})`;
+};
+
+// src/query/react/constants.ts
+var UNINITIALIZED_VALUE = Symbol();
+
+// src/query/react/useSerializedStableValue.ts
+var import_react = require("react");
+function useStableQueryArgs(queryArgs, serialize, endpointDefinition, endpointName) {
+  const incoming = (0, import_react.useMemo)(() => ({
+    queryArgs,
+    serialized: typeof queryArgs == "object" ? serialize({
+      queryArgs,
+      endpointDefinition,
+      endpointName
+    }) : queryArgs
+  }), [queryArgs, serialize, endpointDefinition, endpointName]);
+  const cache2 = (0, import_react.useRef)(incoming);
+  (0, import_react.useEffect)(() => {
+    if (cache2.current.serialized !== incoming.serialized) {
+      cache2.current = incoming;
+    }
+  }, [incoming]);
+  return cache2.current.serialized === incoming.serialized ? cache2.current.queryArgs : queryArgs;
+}
+
+// src/query/react/useShallowStableValue.ts
+var import_react2 = require("react");
+var import_react_redux = require("react-redux");
+function useShallowStableValue(value) {
+  const cache2 = (0, import_react2.useRef)(value);
+  (0, import_react2.useEffect)(() => {
+    if (!(0, import_react_redux.shallowEqual)(cache2.current, value)) {
+      cache2.current = value;
+    }
+  }, [value]);
+  return (0, import_react_redux.shallowEqual)(cache2.current, value) ? cache2.current : value;
+}
+
+// src/query/react/buildHooks.ts
+var canUseDOM = () => !!(typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined");
+var isDOM = /* @__PURE__ */ canUseDOM();
+var isRunningInReactNative = () => typeof navigator !== "undefined" && navigator.product === "ReactNative";
+var isReactNative = /* @__PURE__ */ isRunningInReactNative();
+var getUseIsomorphicLayoutEffect = () => isDOM || isReactNative ? import_react3.useLayoutEffect : import_react3.useEffect;
+var useIsomorphicLayoutEffect = /* @__PURE__ */ getUseIsomorphicLayoutEffect();
+var noPendingQueryStateSelector = (selected) => {
+  if (selected.isUninitialized) {
+    return {
+      ...selected,
+      isUninitialized: false,
+      isFetching: true,
+      isLoading: selected.data !== void 0 ? false : true,
+      status: import_query.QueryStatus.pending
+    };
+  }
+  return selected;
+};
+function buildHooks({
+  api,
+  moduleOptions: {
+    batch,
+    hooks: {
+      useDispatch,
+      useSelector,
+      useStore
+    },
+    unstable__sideEffectsInRender,
+    createSelector: createSelector2
+  },
+  serializeQueryArgs,
+  context
+}) {
+  const usePossiblyImmediateEffect = unstable__sideEffectsInRender ? (cb) => cb() : import_react3.useEffect;
+  return {
+    buildQueryHooks,
+    buildMutationHook,
+    usePrefetch
+  };
+  function queryStatePreSelector(currentState, lastResult, queryArgs) {
+    if (lastResult?.endpointName && currentState.isUninitialized) {
+      const {
+        endpointName
+      } = lastResult;
+      const endpointDefinition = context.endpointDefinitions[endpointName];
+      if (serializeQueryArgs({
+        queryArgs: lastResult.originalArgs,
+        endpointDefinition,
+        endpointName
+      }) === serializeQueryArgs({
+        queryArgs,
+        endpointDefinition,
+        endpointName
+      })) lastResult = void 0;
+    }
+    let data = currentState.isSuccess ? currentState.data : lastResult?.data;
+    if (data === void 0) data = currentState.data;
+    const hasData = data !== void 0;
+    const isFetching = currentState.isLoading;
+    const isLoading = (!lastResult || lastResult.isLoading || lastResult.isUninitialized) && !hasData && isFetching;
+    const isSuccess = currentState.isSuccess || isFetching && hasData;
+    return {
+      ...currentState,
+      data,
+      currentData: currentState.data,
+      isFetching,
+      isLoading,
+      isSuccess
+    };
+  }
+  function usePrefetch(endpointName, defaultOptions) {
+    const dispatch = useDispatch();
+    const stableDefaultOptions = useShallowStableValue(defaultOptions);
+    return (0, import_react3.useCallback)((arg, options) => dispatch(api.util.prefetch(endpointName, arg, {
+      ...stableDefaultOptions,
+      ...options
+    })), [endpointName, dispatch, stableDefaultOptions]);
+  }
+  function buildQueryHooks(name) {
+    const useQuerySubscription = (arg, {
+      refetchOnReconnect,
+      refetchOnFocus,
+      refetchOnMountOrArgChange,
+      skip = false,
+      pollingInterval = 0,
+      skipPollingIfUnfocused = false
+    } = {}) => {
+      const {
+        initiate
+      } = api.endpoints[name];
+      const dispatch = useDispatch();
+      const subscriptionSelectorsRef = (0, import_react3.useRef)(void 0);
+      if (!subscriptionSelectorsRef.current) {
+        const returnedValue = dispatch(api.internalActions.internal_getRTKQSubscriptions());
+        if (true) {
+          if (typeof returnedValue !== "object" || typeof returnedValue?.type === "string") {
+            throw new Error(false ? _formatProdErrorMessage(37) : `Warning: Middleware for RTK-Query API at reducerPath "${api.reducerPath}" has not been added to the store.
+    You must add the middleware for RTK-Query to function correctly!`);
+          }
+        }
+        subscriptionSelectorsRef.current = returnedValue;
+      }
+      const stableArg = useStableQueryArgs(
+        skip ? import_query.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[name],
+        name
+      );
+      const stableSubscriptionOptions = useShallowStableValue({
+        refetchOnReconnect,
+        refetchOnFocus,
+        pollingInterval,
+        skipPollingIfUnfocused
+      });
+      const lastRenderHadSubscription = (0, import_react3.useRef)(false);
+      const promiseRef = (0, import_react3.useRef)(void 0);
+      let {
+        queryCacheKey,
+        requestId
+      } = promiseRef.current || {};
+      let currentRenderHasSubscription = false;
+      if (queryCacheKey && requestId) {
+        currentRenderHasSubscription = subscriptionSelectorsRef.current.isRequestSubscribed(queryCacheKey, requestId);
+      }
+      const subscriptionRemoved = !currentRenderHasSubscription && lastRenderHadSubscription.current;
+      usePossiblyImmediateEffect(() => {
+        lastRenderHadSubscription.current = currentRenderHasSubscription;
+      });
+      usePossiblyImmediateEffect(() => {
+        if (subscriptionRemoved) {
+          promiseRef.current = void 0;
+        }
+      }, [subscriptionRemoved]);
+      usePossiblyImmediateEffect(() => {
+        const lastPromise = promiseRef.current;
+        if (typeof process !== "undefined" && false) {
+          console.log(subscriptionRemoved);
+        }
+        if (stableArg === import_query.skipToken) {
+          lastPromise?.unsubscribe();
+          promiseRef.current = void 0;
+          return;
+        }
+        const lastSubscriptionOptions = promiseRef.current?.subscriptionOptions;
+        if (!lastPromise || lastPromise.arg !== stableArg) {
+          lastPromise?.unsubscribe();
+          const promise = dispatch(initiate(stableArg, {
+            subscriptionOptions: stableSubscriptionOptions,
+            forceRefetch: refetchOnMountOrArgChange
+          }));
+          promiseRef.current = promise;
+        } else if (stableSubscriptionOptions !== lastSubscriptionOptions) {
+          lastPromise.updateSubscriptionOptions(stableSubscriptionOptions);
+        }
+      }, [dispatch, initiate, refetchOnMountOrArgChange, stableArg, stableSubscriptionOptions, subscriptionRemoved]);
+      (0, import_react3.useEffect)(() => {
+        return () => {
+          promiseRef.current?.unsubscribe();
+          promiseRef.current = void 0;
+        };
+      }, []);
+      return (0, import_react3.useMemo)(() => ({
+        /**
+         * A method to manually refetch data for the query
+         */
+        refetch: () => {
+          if (!promiseRef.current) throw new Error(false ? _formatProdErrorMessage2(38) : "Cannot refetch a query that has not been started yet.");
+          return promiseRef.current?.refetch();
+        }
+      }), []);
+    };
+    const useLazyQuerySubscription = ({
+      refetchOnReconnect,
+      refetchOnFocus,
+      pollingInterval = 0,
+      skipPollingIfUnfocused = false
+    } = {}) => {
+      const {
+        initiate
+      } = api.endpoints[name];
+      const dispatch = useDispatch();
+      const [arg, setArg] = (0, import_react3.useState)(UNINITIALIZED_VALUE);
+      const promiseRef = (0, import_react3.useRef)(void 0);
+      const stableSubscriptionOptions = useShallowStableValue({
+        refetchOnReconnect,
+        refetchOnFocus,
+        pollingInterval,
+        skipPollingIfUnfocused
+      });
+      usePossiblyImmediateEffect(() => {
+        const lastSubscriptionOptions = promiseRef.current?.subscriptionOptions;
+        if (stableSubscriptionOptions !== lastSubscriptionOptions) {
+          promiseRef.current?.updateSubscriptionOptions(stableSubscriptionOptions);
+        }
+      }, [stableSubscriptionOptions]);
+      const subscriptionOptionsRef = (0, import_react3.useRef)(stableSubscriptionOptions);
+      usePossiblyImmediateEffect(() => {
+        subscriptionOptionsRef.current = stableSubscriptionOptions;
+      }, [stableSubscriptionOptions]);
+      const trigger = (0, import_react3.useCallback)(function(arg2, preferCacheValue = false) {
+        let promise;
+        batch(() => {
+          promiseRef.current?.unsubscribe();
+          promiseRef.current = promise = dispatch(initiate(arg2, {
+            subscriptionOptions: subscriptionOptionsRef.current,
+            forceRefetch: !preferCacheValue
+          }));
+          setArg(arg2);
+        });
+        return promise;
+      }, [dispatch, initiate]);
+      (0, import_react3.useEffect)(() => {
+        return () => {
+          promiseRef?.current?.unsubscribe();
+        };
+      }, []);
+      (0, import_react3.useEffect)(() => {
+        if (arg !== UNINITIALIZED_VALUE && !promiseRef.current) {
+          trigger(arg, true);
+        }
+      }, [arg, trigger]);
+      return (0, import_react3.useMemo)(() => [trigger, arg], [trigger, arg]);
+    };
+    const useQueryState = (arg, {
+      skip = false,
+      selectFromResult
+    } = {}) => {
+      const {
+        select
+      } = api.endpoints[name];
+      const stableArg = useStableQueryArgs(skip ? import_query.skipToken : arg, serializeQueryArgs, context.endpointDefinitions[name], name);
+      const lastValue = (0, import_react3.useRef)(void 0);
+      const selectDefaultResult = (0, import_react3.useMemo)(() => createSelector2([select(stableArg), (_, lastResult) => lastResult, (_) => stableArg], queryStatePreSelector, {
+        memoizeOptions: {
+          resultEqualityCheck: import_react_redux2.shallowEqual
+        }
+      }), [select, stableArg]);
+      const querySelector = (0, import_react3.useMemo)(() => selectFromResult ? createSelector2([selectDefaultResult], selectFromResult, {
+        devModeChecks: {
+          identityFunctionCheck: "never"
+        }
+      }) : selectDefaultResult, [selectDefaultResult, selectFromResult]);
+      const currentState = useSelector((state) => querySelector(state, lastValue.current), import_react_redux2.shallowEqual);
+      const store = useStore();
+      const newLastValue = selectDefaultResult(store.getState(), lastValue.current);
+      useIsomorphicLayoutEffect(() => {
+        lastValue.current = newLastValue;
+      }, [newLastValue]);
+      return currentState;
+    };
+    return {
+      useQueryState,
+      useQuerySubscription,
+      useLazyQuerySubscription,
+      useLazyQuery(options) {
+        const [trigger, arg] = useLazyQuerySubscription(options);
+        const queryStateResults = useQueryState(arg, {
+          ...options,
+          skip: arg === UNINITIALIZED_VALUE
+        });
+        const info = (0, import_react3.useMemo)(() => ({
+          lastArg: arg
+        }), [arg]);
+        return (0, import_react3.useMemo)(() => [trigger, queryStateResults, info], [trigger, queryStateResults, info]);
+      },
+      useQuery(arg, options) {
+        const querySubscriptionResults = useQuerySubscription(arg, options);
+        const queryStateResults = useQueryState(arg, {
+          selectFromResult: arg === import_query.skipToken || options?.skip ? void 0 : noPendingQueryStateSelector,
+          ...options
+        });
+        const {
+          data,
+          status,
+          isLoading,
+          isSuccess,
+          isError,
+          error
+        } = queryStateResults;
+        (0, import_react3.useDebugValue)({
+          data,
+          status,
+          isLoading,
+          isSuccess,
+          isError,
+          error
+        });
+        return (0, import_react3.useMemo)(() => ({
+          ...queryStateResults,
+          ...querySubscriptionResults
+        }), [queryStateResults, querySubscriptionResults]);
+      }
+    };
+  }
+  function buildMutationHook(name) {
+    return ({
+      selectFromResult,
+      fixedCacheKey
+    } = {}) => {
+      const {
+        select,
+        initiate
+      } = api.endpoints[name];
+      const dispatch = useDispatch();
+      const [promise, setPromise] = (0, import_react3.useState)();
+      (0, import_react3.useEffect)(() => () => {
+        if (!promise?.arg.fixedCacheKey) {
+          promise?.reset();
+        }
+      }, [promise]);
+      const triggerMutation = (0, import_react3.useCallback)(function(arg) {
+        const promise2 = dispatch(initiate(arg, {
+          fixedCacheKey
+        }));
+        setPromise(promise2);
+        return promise2;
+      }, [dispatch, initiate, fixedCacheKey]);
+      const {
+        requestId
+      } = promise || {};
+      const selectDefaultResult = (0, import_react3.useMemo)(() => select({
+        fixedCacheKey,
+        requestId: promise?.requestId
+      }), [fixedCacheKey, promise, select]);
+      const mutationSelector = (0, import_react3.useMemo)(() => selectFromResult ? createSelector2([selectDefaultResult], selectFromResult) : selectDefaultResult, [selectFromResult, selectDefaultResult]);
+      const currentState = useSelector(mutationSelector, import_react_redux2.shallowEqual);
+      const originalArgs = fixedCacheKey == null ? promise?.arg.originalArgs : void 0;
+      const reset = (0, import_react3.useCallback)(() => {
+        batch(() => {
+          if (promise) {
+            setPromise(void 0);
+          }
+          if (fixedCacheKey) {
+            dispatch(api.internalActions.removeMutationResult({
+              requestId,
+              fixedCacheKey
+            }));
+          }
+        });
+      }, [dispatch, fixedCacheKey, promise, requestId]);
+      const {
+        endpointName,
+        data,
+        status,
+        isLoading,
+        isSuccess,
+        isError,
+        error
+      } = currentState;
+      (0, import_react3.useDebugValue)({
+        endpointName,
+        data,
+        status,
+        isLoading,
+        isSuccess,
+        isError,
+        error
+      });
+      const finalState = (0, import_react3.useMemo)(() => ({
+        ...currentState,
+        originalArgs,
+        reset
+      }), [currentState, originalArgs, reset]);
+      return (0, import_react3.useMemo)(() => [triggerMutation, finalState], [triggerMutation, finalState]);
+    };
+  }
+}
+
+// src/query/react/module.ts
+var reactHooksModuleName = /* @__PURE__ */ Symbol();
+var reactHooksModule = ({
+  batch = import_react_redux3.batch,
+  hooks = {
+    useDispatch: import_react_redux3.useDispatch,
+    useSelector: import_react_redux3.useSelector,
+    useStore: import_react_redux3.useStore
+  },
+  createSelector: createSelector2 = import_reselect.createSelector,
+  unstable__sideEffectsInRender = false,
+  ...rest
+} = {}) => {
+  if (true) {
+    const hookNames = ["useDispatch", "useSelector", "useStore"];
+    let warned = false;
+    for (const hookName of hookNames) {
+      if (countObjectKeys(rest) > 0) {
+        if (rest[hookName]) {
+          if (!warned) {
+            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 } })`");
+            warned = true;
+          }
+        }
+        hooks[hookName] = rest[hookName];
+      }
+      if (typeof hooks[hookName] !== "function") {
+        throw new Error(false ? _formatProdErrorMessage3(36) : `When using custom hooks for context, all ${hookNames.length} hooks need to be provided: ${hookNames.join(", ")}.
+Hook ${hookName} was either not provided or not a function.`);
+      }
+    }
+  }
+  return {
+    name: reactHooksModuleName,
+    init(api, {
+      serializeQueryArgs
+    }, context) {
+      const anyApi = api;
+      const {
+        buildQueryHooks,
+        buildMutationHook,
+        usePrefetch
+      } = buildHooks({
+        api,
+        moduleOptions: {
+          batch,
+          hooks,
+          unstable__sideEffectsInRender,
+          createSelector: createSelector2
+        },
+        serializeQueryArgs,
+        context
+      });
+      safeAssign(anyApi, {
+        usePrefetch
+      });
+      safeAssign(context, {
+        batch
+      });
+      return {
+        injectEndpoint(endpointName, definition) {
+          if (isQueryDefinition(definition)) {
+            const {
+              useQuery,
+              useLazyQuery,
+              useLazyQuerySubscription,
+              useQueryState,
+              useQuerySubscription
+            } = buildQueryHooks(endpointName);
+            safeAssign(anyApi.endpoints[endpointName], {
+              useQuery,
+              useLazyQuery,
+              useLazyQuerySubscription,
+              useQueryState,
+              useQuerySubscription
+            });
+            api[`use${capitalize(endpointName)}Query`] = useQuery;
+            api[`useLazy${capitalize(endpointName)}Query`] = useLazyQuery;
+          } else if (isMutationDefinition(definition)) {
+            const useMutation = buildMutationHook(endpointName);
+            safeAssign(anyApi.endpoints[endpointName], {
+              useMutation
+            });
+            api[`use${capitalize(endpointName)}Mutation`] = useMutation;
+          }
+        }
+      };
+    }
+  };
+};
+
+// src/query/react/index.ts
+__reExport(react_exports, require("@reduxjs/toolkit/query"), module.exports);
+
+// src/query/react/ApiProvider.tsx
+var import_toolkit4 = require("@reduxjs/toolkit");
+var import_react4 = require("react");
+var import_react5 = require("react");
+var React = __toESM(require("react"));
+var import_react_redux4 = require("react-redux");
+var import_query2 = require("@reduxjs/toolkit/query");
+function ApiProvider(props) {
+  const context = props.context || import_react_redux4.ReactReduxContext;
+  const existingContext = (0, import_react4.useContext)(context);
+  if (existingContext) {
+    throw new Error(false ? _formatProdErrorMessage4(35) : "Existing Redux context detected. If you already have a store set up, please use the traditional Redux setup.");
+  }
+  const [store] = React.useState(() => (0, import_toolkit4.configureStore)({
+    reducer: {
+      [props.api.reducerPath]: props.api.reducer
+    },
+    middleware: (gDM) => gDM().concat(props.api.middleware)
+  }));
+  (0, import_react5.useEffect)(() => props.setupListeners === false ? void 0 : (0, import_query2.setupListeners)(store.dispatch, props.setupListeners), [props.setupListeners, store.dispatch]);
+  return /* @__PURE__ */ React.createElement(import_react_redux4.Provider, { store, context }, props.children);
+}
+
+// src/query/react/index.ts
+var createApi = /* @__PURE__ */ (0, import_query3.buildCreateApi)((0, import_query3.coreModule)(), reactHooksModule());
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiProvider,
+  UNINITIALIZED_VALUE,
+  createApi,
+  reactHooksModule,
+  reactHooksModuleName,
+  ...require("@reduxjs/toolkit/query")
+});
+//# sourceMappingURL=rtk-query-react.development.cjs.map