651 lines
23 KiB
JavaScript
651 lines
23 KiB
JavaScript
"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
|