@reduxjs/toolkit
Version:
The official, opinionated, batteries-included toolset for efficient Redux development
995 lines • 113 kB
JavaScript
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
var __spreadArray = (this && this.__spreadArray) || function (to, from) {
for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
to[j] = from[i];
return to;
};
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = function (obj, key, value) { return key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value: value }) : obj[key] = value; };
var __spreadValues = function (a, b) {
for (var prop in b || (b = {}))
if (__hasOwnProp.call(b, prop))
__defNormalProp(a, prop, b[prop]);
if (__getOwnPropSymbols)
for (var _j = 0, _k = __getOwnPropSymbols(b); _j < _k.length; _j++) {
var prop = _k[_j];
if (__propIsEnum.call(b, prop))
__defNormalProp(a, prop, b[prop]);
}
return a;
};
var __spreadProps = function (a, b) { return __defProps(a, __getOwnPropDescs(b)); };
var __objRest = function (source, exclude) {
var target = {};
for (var prop in source)
if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
target[prop] = source[prop];
if (source != null && __getOwnPropSymbols)
for (var _j = 0, _k = __getOwnPropSymbols(source); _j < _k.length; _j++) {
var prop = _k[_j];
if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
target[prop] = source[prop];
}
return target;
};
var __async = function (__this, __arguments, generator) {
return new Promise(function (resolve, reject) {
var fulfilled = function (value) {
try {
step(generator.next(value));
}
catch (e) {
reject(e);
}
};
var rejected = function (value) {
try {
step(generator.throw(value));
}
catch (e) {
reject(e);
}
};
var step = function (x) { return x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected); };
step((generator = generator.apply(__this, __arguments)).next());
});
};
// src/query/core/apiState.ts
var QueryStatus;
(function (QueryStatus2) {
QueryStatus2["uninitialized"] = "uninitialized";
QueryStatus2["pending"] = "pending";
QueryStatus2["fulfilled"] = "fulfilled";
QueryStatus2["rejected"] = "rejected";
})(QueryStatus || (QueryStatus = {}));
function getRequestStatusFlags(status) {
return {
status: status,
isUninitialized: status === QueryStatus.uninitialized,
isLoading: status === QueryStatus.pending,
isSuccess: status === QueryStatus.fulfilled,
isError: status === QueryStatus.rejected
};
}
// src/query/utils/isAbsoluteUrl.ts
function isAbsoluteUrl(url) {
return new RegExp("(^|:)//").test(url);
}
// src/query/utils/joinUrls.ts
var withoutTrailingSlash = function (url) { return url.replace(/\/$/, ""); };
var withoutLeadingSlash = function (url) { return url.replace(/^\//, ""); };
function joinUrls(base, url) {
if (!base) {
return url;
}
if (!url) {
return base;
}
if (isAbsoluteUrl(url)) {
return url;
}
var delimiter = base.endsWith("/") || !url.startsWith("?") ? "/" : "";
base = withoutTrailingSlash(base);
url = withoutLeadingSlash(url);
return "" + base + delimiter + url;
}
// src/query/utils/flatten.ts
var flatten = function (arr) { return [].concat.apply([], arr); };
// src/query/utils/isOnline.ts
function isOnline() {
return typeof navigator === "undefined" ? true : navigator.onLine === void 0 ? true : navigator.onLine;
}
// src/query/utils/isDocumentVisible.ts
function isDocumentVisible() {
if (typeof document === "undefined") {
return true;
}
return document.visibilityState !== "hidden";
}
// src/query/utils/copyWithStructuralSharing.ts
import { isPlainObject as _iPO } from "@reduxjs/toolkit";
var isPlainObject = _iPO;
function copyWithStructuralSharing(oldObj, newObj) {
if (oldObj === newObj || !(isPlainObject(oldObj) && isPlainObject(newObj) || Array.isArray(oldObj) && Array.isArray(newObj))) {
return newObj;
}
var newKeys = Object.keys(newObj);
var oldKeys = Object.keys(oldObj);
var isSameObject = newKeys.length === oldKeys.length;
var mergeObj = Array.isArray(newObj) ? [] : {};
for (var _j = 0, newKeys_1 = newKeys; _j < newKeys_1.length; _j++) {
var key = newKeys_1[_j];
mergeObj[key] = copyWithStructuralSharing(oldObj[key], newObj[key]);
if (isSameObject)
isSameObject = oldObj[key] === mergeObj[key];
}
return isSameObject ? oldObj : mergeObj;
}
// src/query/fetchBaseQuery.ts
import { isPlainObject as isPlainObject2 } from "@reduxjs/toolkit";
var defaultFetchFn = function () {
var args = [];
for (var _j = 0; _j < arguments.length; _j++) {
args[_j] = arguments[_j];
}
return fetch.apply(void 0, args);
};
var defaultValidateStatus = function (response) { return response.status >= 200 && response.status <= 299; };
var defaultIsJsonContentType = function (headers) { return /ion\/(vnd\.api\+)?json/.test(headers.get("content-type") || ""); };
function stripUndefined(obj) {
if (!isPlainObject2(obj)) {
return obj;
}
var copy = __spreadValues({}, obj);
for (var _j = 0, _k = Object.entries(copy); _j < _k.length; _j++) {
var _l = _k[_j], k = _l[0], v = _l[1];
if (v === void 0)
delete copy[k];
}
return copy;
}
function fetchBaseQuery(_a) {
var _this = this;
if (_a === void 0) { _a = {}; }
var _b = _a, baseUrl = _b.baseUrl, _j = _b.prepareHeaders, prepareHeaders = _j === void 0 ? function (x) { return x; } : _j, _k = _b.fetchFn, fetchFn = _k === void 0 ? defaultFetchFn : _k, paramsSerializer = _b.paramsSerializer, _l = _b.isJsonContentType, isJsonContentType = _l === void 0 ? defaultIsJsonContentType : _l, _m = _b.jsonContentType, jsonContentType = _m === void 0 ? "application/json" : _m, jsonReplacer = _b.jsonReplacer, defaultTimeout = _b.timeout, globalResponseHandler = _b.responseHandler, globalValidateStatus = _b.validateStatus, baseFetchOptions = __objRest(_b, [
"baseUrl",
"prepareHeaders",
"fetchFn",
"paramsSerializer",
"isJsonContentType",
"jsonContentType",
"jsonReplacer",
"timeout",
"responseHandler",
"validateStatus"
]);
if (typeof fetch === "undefined" && fetchFn === defaultFetchFn) {
console.warn("Warning: `fetch` is not available. Please supply a custom `fetchFn` property to use `fetchBaseQuery` on SSR environments.");
}
return function (arg, api) { return __async(_this, null, function () {
var signal, getState, extra, endpoint, forced, type, meta, _a2, url, _j, headers, _k, params, _l, responseHandler, _m, validateStatus, _o, timeout, rest, config, _p, isJsonifiable, divider, query, request, requestClone, response, timedOut, timeoutId, e_1, responseClone, resultData, responseText, handleResponseError_1, e_2;
return __generator(this, function (_q) {
switch (_q.label) {
case 0:
signal = api.signal, getState = api.getState, extra = api.extra, endpoint = api.endpoint, forced = api.forced, type = api.type;
_a2 = typeof arg == "string" ? { url: arg } : arg, url = _a2.url, _j = _a2.headers, headers = _j === void 0 ? new Headers(baseFetchOptions.headers) : _j, _k = _a2.params, params = _k === void 0 ? void 0 : _k, _l = _a2.responseHandler, responseHandler = _l === void 0 ? globalResponseHandler != null ? globalResponseHandler : "json" : _l, _m = _a2.validateStatus, validateStatus = _m === void 0 ? globalValidateStatus != null ? globalValidateStatus : defaultValidateStatus : _m, _o = _a2.timeout, timeout = _o === void 0 ? defaultTimeout : _o, rest = __objRest(_a2, [
"url",
"headers",
"params",
"responseHandler",
"validateStatus",
"timeout"
]);
config = __spreadValues(__spreadProps(__spreadValues({}, baseFetchOptions), {
signal: signal
}), rest);
headers = new Headers(stripUndefined(headers));
_p = config;
return [4 /*yield*/, prepareHeaders(headers, {
getState: getState,
extra: extra,
endpoint: endpoint,
forced: forced,
type: type
})];
case 1:
_p.headers = (_q.sent()) || headers;
isJsonifiable = function (body) { return typeof body === "object" && (isPlainObject2(body) || Array.isArray(body) || typeof body.toJSON === "function"); };
if (!config.headers.has("content-type") && isJsonifiable(config.body)) {
config.headers.set("content-type", jsonContentType);
}
if (isJsonifiable(config.body) && isJsonContentType(config.headers)) {
config.body = JSON.stringify(config.body, jsonReplacer);
}
if (params) {
divider = ~url.indexOf("?") ? "&" : "?";
query = paramsSerializer ? paramsSerializer(params) : new URLSearchParams(stripUndefined(params));
url += divider + query;
}
url = joinUrls(baseUrl, url);
request = new Request(url, config);
requestClone = new Request(url, config);
meta = { request: requestClone };
timedOut = false, timeoutId = timeout && setTimeout(function () {
timedOut = true;
api.abort();
}, timeout);
_q.label = 2;
case 2:
_q.trys.push([2, 4, 5, 6]);
return [4 /*yield*/, fetchFn(request)];
case 3:
response = _q.sent();
return [3 /*break*/, 6];
case 4:
e_1 = _q.sent();
return [2 /*return*/, {
error: {
status: timedOut ? "TIMEOUT_ERROR" : "FETCH_ERROR",
error: String(e_1)
},
meta: meta
}];
case 5:
if (timeoutId)
clearTimeout(timeoutId);
return [7 /*endfinally*/];
case 6:
responseClone = response.clone();
meta.response = responseClone;
responseText = "";
_q.label = 7;
case 7:
_q.trys.push([7, 9, , 10]);
return [4 /*yield*/, Promise.all([
handleResponse(response, responseHandler).then(function (r) { return resultData = r; }, function (e) { return handleResponseError_1 = e; }),
responseClone.text().then(function (r) { return responseText = r; }, function () {
})
])];
case 8:
_q.sent();
if (handleResponseError_1)
throw handleResponseError_1;
return [3 /*break*/, 10];
case 9:
e_2 = _q.sent();
return [2 /*return*/, {
error: {
status: "PARSING_ERROR",
originalStatus: response.status,
data: responseText,
error: String(e_2)
},
meta: meta
}];
case 10: return [2 /*return*/, validateStatus(response, resultData) ? {
data: resultData,
meta: meta
} : {
error: {
status: response.status,
data: resultData
},
meta: meta
}];
}
});
}); };
function handleResponse(response, responseHandler) {
return __async(this, null, function () {
var text;
return __generator(this, function (_j) {
switch (_j.label) {
case 0:
if (typeof responseHandler === "function") {
return [2 /*return*/, responseHandler(response)];
}
if (responseHandler === "content-type") {
responseHandler = isJsonContentType(response.headers) ? "json" : "text";
}
if (!(responseHandler === "json")) return [3 /*break*/, 2];
return [4 /*yield*/, response.text()];
case 1:
text = _j.sent();
return [2 /*return*/, text.length ? JSON.parse(text) : null];
case 2: return [2 /*return*/, response.text()];
}
});
});
}
}
// src/query/HandledError.ts
var HandledError = /** @class */ (function () {
function HandledError(value, meta) {
if (meta === void 0) { meta = void 0; }
this.value = value;
this.meta = meta;
}
return HandledError;
}());
// src/query/retry.ts
function defaultBackoff(attempt, maxRetries) {
if (attempt === void 0) { attempt = 0; }
if (maxRetries === void 0) { maxRetries = 5; }
return __async(this, null, function () {
var attempts, timeout;
return __generator(this, function (_j) {
switch (_j.label) {
case 0:
attempts = Math.min(attempt, maxRetries);
timeout = ~~((Math.random() + 0.4) * (300 << attempts));
return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(function (res) { return resolve(res); }, timeout); })];
case 1:
_j.sent();
return [2 /*return*/];
}
});
});
}
function fail(e) {
throw Object.assign(new HandledError({ error: e }), {
throwImmediately: true
});
}
var EMPTY_OPTIONS = {};
var retryWithBackoff = function (baseQuery, defaultOptions) { return function (args, api, extraOptions) { return __async(void 0, null, function () {
var possibleMaxRetries, maxRetries, defaultRetryCondition, options, retry2, result, e_3;
return __generator(this, function (_j) {
switch (_j.label) {
case 0:
possibleMaxRetries = [
5,
(defaultOptions || EMPTY_OPTIONS).maxRetries,
(extraOptions || EMPTY_OPTIONS).maxRetries
].filter(function (x) { return x !== void 0; });
maxRetries = possibleMaxRetries.slice(-1)[0];
defaultRetryCondition = function (_, __, _j) {
var attempt = _j.attempt;
return attempt <= maxRetries;
};
options = __spreadValues(__spreadValues({
maxRetries: maxRetries,
backoff: defaultBackoff,
retryCondition: defaultRetryCondition
}, defaultOptions), extraOptions);
retry2 = 0;
_j.label = 1;
case 1:
if (!true) return [3 /*break*/, 7];
_j.label = 2;
case 2:
_j.trys.push([2, 4, , 6]);
return [4 /*yield*/, baseQuery(args, api, extraOptions)];
case 3:
result = _j.sent();
if (result.error) {
throw new HandledError(result);
}
return [2 /*return*/, result];
case 4:
e_3 = _j.sent();
retry2++;
if (e_3.throwImmediately) {
if (e_3 instanceof HandledError) {
return [2 /*return*/, e_3.value];
}
throw e_3;
}
if (e_3 instanceof HandledError && !options.retryCondition(e_3.value.error, args, {
attempt: retry2,
baseQueryApi: api,
extraOptions: extraOptions
})) {
return [2 /*return*/, e_3.value];
}
return [4 /*yield*/, options.backoff(retry2, options.maxRetries)];
case 5:
_j.sent();
return [3 /*break*/, 6];
case 6: return [3 /*break*/, 1];
case 7: return [2 /*return*/];
}
});
}); }; };
var retry = /* @__PURE__ */ Object.assign(retryWithBackoff, { fail: fail });
// src/query/core/setupListeners.ts
import { createAction } from "@reduxjs/toolkit";
var onFocus = /* @__PURE__ */ createAction("__rtkq/focused");
var onFocusLost = /* @__PURE__ */ createAction("__rtkq/unfocused");
var onOnline = /* @__PURE__ */ createAction("__rtkq/online");
var onOffline = /* @__PURE__ */ createAction("__rtkq/offline");
var initialized = false;
function setupListeners(dispatch, customHandler) {
function defaultHandler() {
var handleFocus = function () { return dispatch(onFocus()); };
var handleFocusLost = function () { return dispatch(onFocusLost()); };
var handleOnline = function () { return dispatch(onOnline()); };
var handleOffline = function () { return dispatch(onOffline()); };
var handleVisibilityChange = function () {
if (window.document.visibilityState === "visible") {
handleFocus();
}
else {
handleFocusLost();
}
};
if (!initialized) {
if (typeof window !== "undefined" && window.addEventListener) {
window.addEventListener("visibilitychange", handleVisibilityChange, false);
window.addEventListener("focus", handleFocus, false);
window.addEventListener("online", handleOnline, false);
window.addEventListener("offline", handleOffline, false);
initialized = true;
}
}
var unsubscribe = function () {
window.removeEventListener("focus", handleFocus);
window.removeEventListener("visibilitychange", handleVisibilityChange);
window.removeEventListener("online", handleOnline);
window.removeEventListener("offline", handleOffline);
initialized = false;
};
return unsubscribe;
}
return customHandler ? customHandler(dispatch, { onFocus: onFocus, onFocusLost: onFocusLost, onOffline: onOffline, onOnline: onOnline }) : defaultHandler();
}
// src/query/core/buildSelectors.ts
import { createNextState as createNextState2, createSelector } from "@reduxjs/toolkit";
// src/query/endpointDefinitions.ts
var DefinitionType;
(function (DefinitionType2) {
DefinitionType2["query"] = "query";
DefinitionType2["mutation"] = "mutation";
})(DefinitionType || (DefinitionType = {}));
function isQueryDefinition(e) {
return e.type === DefinitionType.query;
}
function isMutationDefinition(e) {
return e.type === DefinitionType.mutation;
}
function calculateProvidedBy(description, result, error, queryArg, meta, assertTagTypes) {
if (isFunction(description)) {
return description(result, error, queryArg, meta).map(expandTagDescription).map(assertTagTypes);
}
if (Array.isArray(description)) {
return description.map(expandTagDescription).map(assertTagTypes);
}
return [];
}
function isFunction(t) {
return typeof t === "function";
}
function expandTagDescription(description) {
return typeof description === "string" ? { type: description } : description;
}
// src/query/core/buildSlice.ts
import { combineReducers, createAction as createAction2, createSlice, isAnyOf, isFulfilled as isFulfilled2, isRejectedWithValue as isRejectedWithValue2, createNextState, prepareAutoBatched } from "@reduxjs/toolkit";
// src/query/utils/isNotNullish.ts
function isNotNullish(v) {
return v != null;
}
// src/query/core/buildInitiate.ts
var forceQueryFnSymbol = Symbol("forceQueryFn");
var isUpsertQuery = function (arg) { return typeof arg[forceQueryFnSymbol] === "function"; };
function buildInitiate(_j) {
var serializeQueryArgs = _j.serializeQueryArgs, queryThunk = _j.queryThunk, mutationThunk = _j.mutationThunk, api = _j.api, context = _j.context;
var runningQueries = new Map();
var runningMutations = new Map();
var _k = api.internalActions, unsubscribeQueryResult = _k.unsubscribeQueryResult, removeMutationResult = _k.removeMutationResult, updateSubscriptionOptions = _k.updateSubscriptionOptions;
return {
buildInitiateQuery: buildInitiateQuery,
buildInitiateMutation: buildInitiateMutation,
getRunningQueryThunk: getRunningQueryThunk,
getRunningMutationThunk: getRunningMutationThunk,
getRunningQueriesThunk: getRunningQueriesThunk,
getRunningMutationsThunk: getRunningMutationsThunk,
getRunningOperationPromises: getRunningOperationPromises,
removalWarning: removalWarning
};
function removalWarning() {
throw new Error("This method had to be removed due to a conceptual bug in RTK.\n Please see https://github.com/reduxjs/redux-toolkit/pull/2481 for details.\n See https://redux-toolkit.js.org/rtk-query/usage/server-side-rendering for new guidance on SSR.");
}
function getRunningOperationPromises() {
if (typeof process !== "undefined" && process.env.NODE_ENV === "development") {
removalWarning();
}
else {
var extract = function (v) { return Array.from(v.values()).flatMap(function (queriesForStore) { return queriesForStore ? Object.values(queriesForStore) : []; }); };
return __spreadArray(__spreadArray([], extract(runningQueries)), extract(runningMutations)).filter(isNotNullish);
}
}
function getRunningQueryThunk(endpointName, queryArgs) {
return function (dispatch) {
var _a;
var endpointDefinition = context.endpointDefinitions[endpointName];
var queryCacheKey = serializeQueryArgs({
queryArgs: queryArgs,
endpointDefinition: endpointDefinition,
endpointName: endpointName
});
return (_a = runningQueries.get(dispatch)) == null ? void 0 : _a[queryCacheKey];
};
}
function getRunningMutationThunk(_endpointName, fixedCacheKeyOrRequestId) {
return function (dispatch) {
var _a;
return (_a = runningMutations.get(dispatch)) == null ? void 0 : _a[fixedCacheKeyOrRequestId];
};
}
function getRunningQueriesThunk() {
return function (dispatch) { return Object.values(runningQueries.get(dispatch) || {}).filter(isNotNullish); };
}
function getRunningMutationsThunk() {
return function (dispatch) { return Object.values(runningMutations.get(dispatch) || {}).filter(isNotNullish); };
}
function middlewareWarning(dispatch) {
if (process.env.NODE_ENV !== "production") {
if (middlewareWarning.triggered)
return;
var registered = dispatch(api.internalActions.internal_probeSubscription({
queryCacheKey: "DOES_NOT_EXIST",
requestId: "DUMMY_REQUEST_ID"
}));
middlewareWarning.triggered = true;
if (typeof registered !== "boolean") {
throw new Error("Warning: Middleware for RTK-Query API at reducerPath \"" + api.reducerPath + "\" has not been added to the store.\nYou must add the middleware for RTK-Query to function correctly!");
}
}
}
function buildInitiateQuery(endpointName, endpointDefinition) {
var queryAction = function (arg, _j) {
var _k = _j === void 0 ? {} : _j, _l = _k.subscribe, subscribe = _l === void 0 ? true : _l, forceRefetch = _k.forceRefetch, subscriptionOptions = _k.subscriptionOptions, _m = forceQueryFnSymbol, forceQueryFn = _k[_m];
return function (dispatch, getState) {
var _j;
var _a;
var queryCacheKey = serializeQueryArgs({
queryArgs: arg,
endpointDefinition: endpointDefinition,
endpointName: endpointName
});
var thunk = queryThunk((_j = {
type: "query",
subscribe: subscribe,
forceRefetch: forceRefetch,
subscriptionOptions: subscriptionOptions,
endpointName: endpointName,
originalArgs: arg,
queryCacheKey: queryCacheKey
},
_j[forceQueryFnSymbol] = forceQueryFn,
_j));
var selector = api.endpoints[endpointName].select(arg);
var thunkResult = dispatch(thunk);
var stateAfter = selector(getState());
middlewareWarning(dispatch);
var requestId = thunkResult.requestId, abort = thunkResult.abort;
var skippedSynchronously = stateAfter.requestId !== requestId;
var runningQuery = (_a = runningQueries.get(dispatch)) == null ? void 0 : _a[queryCacheKey];
var selectFromState = function () { return selector(getState()); };
var statePromise = Object.assign(forceQueryFn ? thunkResult.then(selectFromState) : skippedSynchronously && !runningQuery ? Promise.resolve(stateAfter) : Promise.all([runningQuery, thunkResult]).then(selectFromState), {
arg: arg,
requestId: requestId,
subscriptionOptions: subscriptionOptions,
queryCacheKey: queryCacheKey,
abort: abort,
unwrap: function () {
return __async(this, null, function () {
var result;
return __generator(this, function (_j) {
switch (_j.label) {
case 0: return [4 /*yield*/, statePromise];
case 1:
result = _j.sent();
if (result.isError) {
throw result.error;
}
return [2 /*return*/, result.data];
}
});
});
},
refetch: function () { return dispatch(queryAction(arg, { subscribe: false, forceRefetch: true })); },
unsubscribe: function () {
if (subscribe)
dispatch(unsubscribeQueryResult({
queryCacheKey: queryCacheKey,
requestId: requestId
}));
},
updateSubscriptionOptions: function (options) {
statePromise.subscriptionOptions = options;
dispatch(updateSubscriptionOptions({
endpointName: endpointName,
requestId: requestId,
queryCacheKey: queryCacheKey,
options: options
}));
}
});
if (!runningQuery && !skippedSynchronously && !forceQueryFn) {
var running_1 = runningQueries.get(dispatch) || {};
running_1[queryCacheKey] = statePromise;
runningQueries.set(dispatch, running_1);
statePromise.then(function () {
delete running_1[queryCacheKey];
if (!Object.keys(running_1).length) {
runningQueries.delete(dispatch);
}
});
}
return statePromise;
};
};
return queryAction;
}
function buildInitiateMutation(endpointName) {
return function (arg, _j) {
var _k = _j === void 0 ? {} : _j, _l = _k.track, track = _l === void 0 ? true : _l, fixedCacheKey = _k.fixedCacheKey;
return function (dispatch, getState) {
var thunk = mutationThunk({
type: "mutation",
endpointName: endpointName,
originalArgs: arg,
track: track,
fixedCacheKey: fixedCacheKey
});
var thunkResult = dispatch(thunk);
middlewareWarning(dispatch);
var requestId = thunkResult.requestId, abort = thunkResult.abort, unwrap = thunkResult.unwrap;
var returnValuePromise = thunkResult.unwrap().then(function (data) { return ({ data: data }); }).catch(function (error) { return ({ error: error }); });
var reset = function () {
dispatch(removeMutationResult({ requestId: requestId, fixedCacheKey: fixedCacheKey }));
};
var ret = Object.assign(returnValuePromise, {
arg: thunkResult.arg,
requestId: requestId,
abort: abort,
unwrap: unwrap,
unsubscribe: reset,
reset: reset
});
var running = runningMutations.get(dispatch) || {};
runningMutations.set(dispatch, running);
running[requestId] = ret;
ret.then(function () {
delete running[requestId];
if (!Object.keys(running).length) {
runningMutations.delete(dispatch);
}
});
if (fixedCacheKey) {
running[fixedCacheKey] = ret;
ret.then(function () {
if (running[fixedCacheKey] === ret) {
delete running[fixedCacheKey];
if (!Object.keys(running).length) {
runningMutations.delete(dispatch);
}
}
});
}
return ret;
};
};
}
}
// src/query/core/buildThunks.ts
import { isAllOf, isFulfilled, isPending, isRejected, isRejectedWithValue } from "@reduxjs/toolkit";
import { isDraftable, produceWithPatches } from "immer";
import { createAsyncThunk, SHOULD_AUTOBATCH } from "@reduxjs/toolkit";
function defaultTransformResponse(baseQueryReturnValue) {
return baseQueryReturnValue;
}
function buildThunks(_j) {
var _this = this;
var reducerPath = _j.reducerPath, baseQuery = _j.baseQuery, endpointDefinitions = _j.context.endpointDefinitions, serializeQueryArgs = _j.serializeQueryArgs, api = _j.api, assertTagType = _j.assertTagType;
var patchQueryData = function (endpointName, args, patches, updateProvided) { return function (dispatch, getState) {
var endpointDefinition = endpointDefinitions[endpointName];
var queryCacheKey = serializeQueryArgs({
queryArgs: args,
endpointDefinition: endpointDefinition,
endpointName: endpointName
});
dispatch(api.internalActions.queryResultPatched({ queryCacheKey: queryCacheKey, patches: patches }));
if (!updateProvided) {
return;
}
var newValue = api.endpoints[endpointName].select(args)(getState());
var providedTags = calculateProvidedBy(endpointDefinition.providesTags, newValue.data, void 0, args, {}, assertTagType);
dispatch(api.internalActions.updateProvidedBy({ queryCacheKey: queryCacheKey, providedTags: providedTags }));
}; };
var updateQueryData = function (endpointName, args, updateRecipe, updateProvided) {
if (updateProvided === void 0) { updateProvided = true; }
return function (dispatch, getState) {
var _j, _k;
var endpointDefinition = api.endpoints[endpointName];
var currentState = endpointDefinition.select(args)(getState());
var ret = {
patches: [],
inversePatches: [],
undo: function () { return dispatch(api.util.patchQueryData(endpointName, args, ret.inversePatches, updateProvided)); }
};
if (currentState.status === QueryStatus.uninitialized) {
return ret;
}
var newValue;
if ("data" in currentState) {
if (isDraftable(currentState.data)) {
var _l = produceWithPatches(currentState.data, updateRecipe), value = _l[0], patches = _l[1], inversePatches = _l[2];
(_j = ret.patches).push.apply(_j, patches);
(_k = ret.inversePatches).push.apply(_k, inversePatches);
newValue = value;
}
else {
newValue = updateRecipe(currentState.data);
ret.patches.push({ op: "replace", path: [], value: newValue });
ret.inversePatches.push({
op: "replace",
path: [],
value: currentState.data
});
}
}
dispatch(api.util.patchQueryData(endpointName, args, ret.patches, updateProvided));
return ret;
};
};
var upsertQueryData = function (endpointName, args, value) { return function (dispatch) {
var _j;
return dispatch(api.endpoints[endpointName].initiate(args, (_j = {
subscribe: false,
forceRefetch: true
},
_j[forceQueryFnSymbol] = function () { return ({
data: value
}); },
_j)));
}; };
var executeEndpoint = function (_0, _1) { return __async(_this, [_0, _1], function (arg, _j) {
var endpointDefinition, transformResponse, result, baseQueryApi_1, forceQueryFn, what, err, _k, _l, key, _m, error_1, catchedError, transformErrorResponse, _o, e_4;
var _p, _q;
var signal = _j.signal, abort = _j.abort, rejectWithValue = _j.rejectWithValue, fulfillWithValue = _j.fulfillWithValue, dispatch = _j.dispatch, getState = _j.getState, extra = _j.extra;
return __generator(this, function (_r) {
switch (_r.label) {
case 0:
endpointDefinition = endpointDefinitions[arg.endpointName];
_r.label = 1;
case 1:
_r.trys.push([1, 8, , 13]);
transformResponse = defaultTransformResponse;
result = void 0;
baseQueryApi_1 = {
signal: signal,
abort: abort,
dispatch: dispatch,
getState: getState,
extra: extra,
endpoint: arg.endpointName,
type: arg.type,
forced: arg.type === "query" ? isForcedQuery(arg, getState()) : void 0
};
forceQueryFn = arg.type === "query" ? arg[forceQueryFnSymbol] : void 0;
if (!forceQueryFn) return [3 /*break*/, 2];
result = forceQueryFn();
return [3 /*break*/, 6];
case 2:
if (!endpointDefinition.query) return [3 /*break*/, 4];
return [4 /*yield*/, baseQuery(endpointDefinition.query(arg.originalArgs), baseQueryApi_1, endpointDefinition.extraOptions)];
case 3:
result = _r.sent();
if (endpointDefinition.transformResponse) {
transformResponse = endpointDefinition.transformResponse;
}
return [3 /*break*/, 6];
case 4: return [4 /*yield*/, endpointDefinition.queryFn(arg.originalArgs, baseQueryApi_1, endpointDefinition.extraOptions, function (arg2) { return baseQuery(arg2, baseQueryApi_1, endpointDefinition.extraOptions); })];
case 5:
result = _r.sent();
_r.label = 6;
case 6:
if (typeof process !== "undefined" && process.env.NODE_ENV === "development") {
what = endpointDefinition.query ? "`baseQuery`" : "`queryFn`";
err = void 0;
if (!result) {
err = what + " did not return anything.";
}
else if (typeof result !== "object") {
err = what + " did not return an object.";
}
else if (result.error && result.data) {
err = what + " returned an object containing both `error` and `result`.";
}
else if (result.error === void 0 && result.data === void 0) {
err = what + " returned an object containing neither a valid `error` and `result`. At least one of them should not be `undefined`";
}
else {
for (_k = 0, _l = Object.keys(result); _k < _l.length; _k++) {
key = _l[_k];
if (key !== "error" && key !== "data" && key !== "meta") {
err = "The object returned by " + what + " has the unknown property " + key + ".";
break;
}
}
}
if (err) {
console.error("Error encountered handling the endpoint " + arg.endpointName + ".\n " + err + "\n It needs to return an object with either the shape `{ data: <value> }` or `{ error: <value> }` that may contain an optional `meta` property.\n Object returned was:", result);
}
}
if (result.error)
throw new HandledError(result.error, result.meta);
_m = fulfillWithValue;
return [4 /*yield*/, transformResponse(result.data, result.meta, arg.originalArgs)];
case 7: return [2 /*return*/, _m.apply(void 0, [_r.sent(), (_p = {
fulfilledTimeStamp: Date.now(),
baseQueryMeta: result.meta
},
_p[SHOULD_AUTOBATCH] = true,
_p)])];
case 8:
error_1 = _r.sent();
catchedError = error_1;
if (!(catchedError instanceof HandledError)) return [3 /*break*/, 12];
transformErrorResponse = defaultTransformResponse;
if (endpointDefinition.query && endpointDefinition.transformErrorResponse) {
transformErrorResponse = endpointDefinition.transformErrorResponse;
}
_r.label = 9;
case 9:
_r.trys.push([9, 11, , 12]);
_o = rejectWithValue;
return [4 /*yield*/, transformErrorResponse(catchedError.value, catchedError.meta, arg.originalArgs)];
case 10: return [2 /*return*/, _o.apply(void 0, [_r.sent(), (_q = { baseQueryMeta: catchedError.meta }, _q[SHOULD_AUTOBATCH] = true, _q)])];
case 11:
e_4 = _r.sent();
catchedError = e_4;
return [3 /*break*/, 12];
case 12:
if (typeof process !== "undefined" && process.env.NODE_ENV !== "production") {
console.error("An unhandled error occurred processing a request for the endpoint \"" + arg.endpointName + "\".\nIn the case of an unhandled error, no tags will be \"provided\" or \"invalidated\".", catchedError);
}
else {
console.error(catchedError);
}
throw catchedError;
case 13: return [2 /*return*/];
}
});
}); };
function isForcedQuery(arg, state) {
var _a, _b, _c, _d;
var requestState = (_b = (_a = state[reducerPath]) == null ? void 0 : _a.queries) == null ? void 0 : _b[arg.queryCacheKey];
var baseFetchOnMountOrArgChange = (_c = state[reducerPath]) == null ? void 0 : _c.config.refetchOnMountOrArgChange;
var fulfilledVal = requestState == null ? void 0 : requestState.fulfilledTimeStamp;
var refetchVal = (_d = arg.forceRefetch) != null ? _d : arg.subscribe && baseFetchOnMountOrArgChange;
if (refetchVal) {
return refetchVal === true || (Number(new Date()) - Number(fulfilledVal)) / 1e3 >= refetchVal;
}
return false;
}
var queryThunk = createAsyncThunk(reducerPath + "/executeQuery", executeEndpoint, {
getPendingMeta: function () {
var _j;
return _j = { startedTimeStamp: Date.now() }, _j[SHOULD_AUTOBATCH] = true, _j;
},
condition: function (queryThunkArgs, _j) {
var getState = _j.getState;
var _a, _b, _c;
var state = getState();
var requestState = (_b = (_a = state[reducerPath]) == null ? void 0 : _a.queries) == null ? void 0 : _b[queryThunkArgs.queryCacheKey];
var fulfilledVal = requestState == null ? void 0 : requestState.fulfilledTimeStamp;
var currentArg = queryThunkArgs.originalArgs;
var previousArg = requestState == null ? void 0 : requestState.originalArgs;
var endpointDefinition = endpointDefinitions[queryThunkArgs.endpointName];
if (isUpsertQuery(queryThunkArgs)) {
return true;
}
if ((requestState == null ? void 0 : requestState.status) === "pending") {
return false;
}
if (isForcedQuery(queryThunkArgs, state)) {
return true;
}
if (isQueryDefinition(endpointDefinition) && ((_c = endpointDefinition == null ? void 0 : endpointDefinition.forceRefetch) == null ? void 0 : _c.call(endpointDefinition, {
currentArg: currentArg,
previousArg: previousArg,
endpointState: requestState,
state: state
}))) {
return true;
}
if (fulfilledVal) {
return false;
}
return true;
},
dispatchConditionRejection: true
});
var mutationThunk = createAsyncThunk(reducerPath + "/executeMutation", executeEndpoint, {
getPendingMeta: function () {
var _j;
return _j = { startedTimeStamp: Date.now() }, _j[SHOULD_AUTOBATCH] = true, _j;
}
});
var hasTheForce = function (options) { return "force" in options; };
var hasMaxAge = function (options) { return "ifOlderThan" in options; };
var prefetch = function (endpointName, arg, options) { return function (dispatch, getState) {
var force = hasTheForce(options) && options.force;
var maxAge = hasMaxAge(options) && options.ifOlderThan;
var queryAction = function (force2) {
if (force2 === void 0) { force2 = true; }
return api.endpoints[endpointName].initiate(arg, { forceRefetch: force2 });
};
var latestStateValue = api.endpoints[endpointName].select(arg)(getState());
if (force) {
dispatch(queryAction());
}
else if (maxAge) {
var lastFulfilledTs = latestStateValue == null ? void 0 : latestStateValue.fulfilledTimeStamp;
if (!lastFulfilledTs) {
dispatch(queryAction());
return;
}
var shouldRetrigger = (Number(new Date()) - Number(new Date(lastFulfilledTs))) / 1e3 >= maxAge;
if (shouldRetrigger) {
dispatch(queryAction());
}
}
else {
dispatch(queryAction(false));
}
}; };
function matchesEndpoint(endpointName) {
return function (action) {
var _a, _b;
return ((_b = (_a = action == null ? void 0 : action.meta) == null ? void 0 : _a.arg) == null ? void 0 : _b.endpointName) === endpointName;
};
}
function buildMatchThunkActions(thunk, endpointName) {
return {
matchPending: isAllOf(isPending(thunk), matchesEndpoint(endpointName)),
matchFulfilled: isAllOf(isFulfilled(thunk), matchesEndpoint(endpointName)),
matchRejected: isAllOf(isRejected(thunk), matchesEndpoint(endpointName))
};
}
return {
queryThunk: queryThunk,
mutationThunk: mutationThunk,
prefetch: prefetch,
updateQueryData: updateQueryData,
upsertQueryData: upsertQueryData,
patchQueryData: patchQueryData,
buildMatchThunkActions: buildMatchThunkActions
};
}
function calculateProvidedByThunk(action, type, endpointDefinitions, assertTagType) {
return calculateProvidedBy(endpointDefinitions[action.meta.arg.endpointName][type], isFulfilled(action) ?