@reduxjs/toolkit
Version:
The official, opinionated, batteries-included toolset for efficient Redux development
1,100 lines • 92 kB
JavaScript
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
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 __create = Object.create;
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __getProtoOf = Object.getPrototypeOf;
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 _i = 0, _c = __getOwnPropSymbols(b); _i < _c.length; _i++) {
var prop = _c[_i];
if (__propIsEnum.call(b, prop))
__defNormalProp(a, prop, b[prop]);
}
return a;
};
var __spreadProps = function (a, b) { return __defProps(a, __getOwnPropDescs(b)); };
var __markAsModule = function (target) { return __defProp(target, "__esModule", { value: true }); };
var __export = function (target, all) {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __reExport = function (target, module2, desc) {
if (module2 && typeof module2 === "object" || typeof module2 === "function") {
var _loop_1 = function (key) {
if (!__hasOwnProp.call(target, key) && key !== "default")
__defProp(target, key, { get: function () { return module2[key]; }, enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
};
for (var _i = 0, _c = __getOwnPropNames(module2); _i < _c.length; _i++) {
var key = _c[_i];
_loop_1(key);
}
}
return target;
};
var __toModule = function (module2) {
return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: function () { return module2.default; }, enumerable: true } : { value: module2, enumerable: true })), module2);
};
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/index.ts
__markAsModule(exports);
__export(exports, {
EnhancerArray: function () { return EnhancerArray; },
MiddlewareArray: function () { return MiddlewareArray; },
SHOULD_AUTOBATCH: function () { return SHOULD_AUTOBATCH; },
TaskAbortError: function () { return TaskAbortError; },
addListener: function () { return addListener; },
autoBatchEnhancer: function () { return autoBatchEnhancer; },
clearAllListeners: function () { return clearAllListeners; },
configureStore: function () { return configureStore; },
createAction: function () { return createAction; },
createActionCreatorInvariantMiddleware: function () { return createActionCreatorInvariantMiddleware; },
createAsyncThunk: function () { return createAsyncThunk; },
createDraftSafeSelector: function () { return createDraftSafeSelector; },
createEntityAdapter: function () { return createEntityAdapter; },
createImmutableStateInvariantMiddleware: function () { return createImmutableStateInvariantMiddleware; },
createListenerMiddleware: function () { return createListenerMiddleware; },
createNextState: function () { return import_immer6.default; },
createReducer: function () { return createReducer; },
createSelector: function () { return import_reselect2.createSelector; },
createSerializableStateInvariantMiddleware: function () { return createSerializableStateInvariantMiddleware; },
createSlice: function () { return createSlice; },
current: function () { return import_immer6.current; },
findNonSerializableValue: function () { return findNonSerializableValue; },
freeze: function () { return import_immer6.freeze; },
getDefaultMiddleware: function () { return getDefaultMiddleware; },
getType: function () { return getType; },
isAction: function () { return isAction; },
isActionCreator: function () { return isActionCreator; },
isAllOf: function () { return isAllOf; },
isAnyOf: function () { return isAnyOf; },
isAsyncThunkAction: function () { return isAsyncThunkAction; },
isDraft: function () { return import_immer6.isDraft; },
isFluxStandardAction: function () { return isFSA; },
isFulfilled: function () { return isFulfilled; },
isImmutableDefault: function () { return isImmutableDefault; },
isPending: function () { return isPending; },
isPlain: function () { return isPlain; },
isPlainObject: function () { return isPlainObject; },
isRejected: function () { return isRejected; },
isRejectedWithValue: function () { return isRejectedWithValue; },
miniSerializeError: function () { return miniSerializeError; },
nanoid: function () { return nanoid; },
original: function () { return import_immer6.original; },
prepareAutoBatched: function () { return prepareAutoBatched; },
removeListener: function () { return removeListener; },
unwrapResult: function () { return unwrapResult; }
});
var import_immer5 = __toModule(require("immer"));
__reExport(exports, __toModule(require("redux")));
var import_immer6 = __toModule(require("immer"));
var import_reselect2 = __toModule(require("reselect"));
// src/createDraftSafeSelector.ts
var import_immer = __toModule(require("immer"));
var import_reselect = __toModule(require("reselect"));
var createDraftSafeSelector = function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
var selector = (0, import_reselect.createSelector).apply(void 0, args);
var wrappedSelector = function (value) {
var rest = [];
for (var _i = 1; _i < arguments.length; _i++) {
rest[_i - 1] = arguments[_i];
}
return selector.apply(void 0, __spreadArray([(0, import_immer.isDraft)(value) ? (0, import_immer.current)(value) : value], rest));
};
return wrappedSelector;
};
// src/configureStore.ts
var import_redux2 = __toModule(require("redux"));
// src/devtoolsExtension.ts
var import_redux = __toModule(require("redux"));
var composeWithDevTools = typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ ? window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ : function () {
if (arguments.length === 0)
return void 0;
if (typeof arguments[0] === "object")
return import_redux.compose;
return import_redux.compose.apply(null, arguments);
};
var devToolsEnhancer = typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION__ ? window.__REDUX_DEVTOOLS_EXTENSION__ : function () {
return function (noop2) {
return noop2;
};
};
// src/isPlainObject.ts
function isPlainObject(value) {
if (typeof value !== "object" || value === null)
return false;
var proto = Object.getPrototypeOf(value);
if (proto === null)
return true;
var baseProto = proto;
while (Object.getPrototypeOf(baseProto) !== null) {
baseProto = Object.getPrototypeOf(baseProto);
}
return proto === baseProto;
}
// src/getDefaultMiddleware.ts
var import_redux_thunk = __toModule(require("redux-thunk"));
// src/tsHelpers.ts
var hasMatchFunction = function (v) {
return v && typeof v.match === "function";
};
// src/createAction.ts
function createAction(type, prepareAction) {
function actionCreator() {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
if (prepareAction) {
var prepared = prepareAction.apply(void 0, args);
if (!prepared) {
throw new Error("prepareAction did not return an object");
}
return __spreadValues(__spreadValues({
type: type,
payload: prepared.payload
}, "meta" in prepared && { meta: prepared.meta }), "error" in prepared && { error: prepared.error });
}
return { type: type, payload: args[0] };
}
actionCreator.toString = function () { return "" + type; };
actionCreator.type = type;
actionCreator.match = function (action) { return action.type === type; };
return actionCreator;
}
function isAction(action) {
return isPlainObject(action) && "type" in action;
}
function isActionCreator(action) {
return typeof action === "function" && "type" in action && hasMatchFunction(action);
}
function isFSA(action) {
return isAction(action) && typeof action.type === "string" && Object.keys(action).every(isValidKey);
}
function isValidKey(key) {
return ["type", "payload", "error", "meta"].indexOf(key) > -1;
}
function getType(actionCreator) {
return "" + actionCreator;
}
// src/actionCreatorInvariantMiddleware.ts
function getMessage(type) {
var splitType = type ? ("" + type).split("/") : [];
var actionName = splitType[splitType.length - 1] || "actionCreator";
return "Detected an action creator with type \"" + (type || "unknown") + "\" being dispatched. \nMake sure you're calling the action creator before dispatching, i.e. `dispatch(" + actionName + "())` instead of `dispatch(" + actionName + ")`. This is necessary even if the action has no payload.";
}
function createActionCreatorInvariantMiddleware(options) {
if (options === void 0) { options = {}; }
if (false) {
return function () { return function (next) { return function (action) { return next(action); }; }; };
}
var _c = options.isActionCreator, isActionCreator2 = _c === void 0 ? isActionCreator : _c;
return function () { return function (next) { return function (action) {
if (isActionCreator2(action)) {
console.warn(getMessage(action.type));
}
return next(action);
}; }; };
}
// src/utils.ts
var import_immer2 = __toModule(require("immer"));
function getTimeMeasureUtils(maxDelay, fnName) {
var elapsed = 0;
return {
measureTime: function (fn) {
var started = Date.now();
try {
return fn();
}
finally {
var finished = Date.now();
elapsed += finished - started;
}
},
warnIfExceeded: function () {
if (elapsed > maxDelay) {
console.warn(fnName + " took " + elapsed + "ms, which is more than the warning threshold of " + maxDelay + "ms. \nIf your state or actions are very large, you may want to disable the middleware as it might cause too much of a slowdown in development mode. See https://redux-toolkit.js.org/api/getDefaultMiddleware for instructions.\nIt is disabled in production builds, so you don't need to worry about that.");
}
}
};
}
var MiddlewareArray = /** @class */ (function (_super) {
__extends(MiddlewareArray, _super);
function MiddlewareArray() {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
var _this = _super.apply(this, args) || this;
Object.setPrototypeOf(_this, MiddlewareArray.prototype);
return _this;
}
Object.defineProperty(MiddlewareArray, Symbol.species, {
get: function () {
return MiddlewareArray;
},
enumerable: false,
configurable: true
});
MiddlewareArray.prototype.concat = function () {
var arr = [];
for (var _i = 0; _i < arguments.length; _i++) {
arr[_i] = arguments[_i];
}
return _super.prototype.concat.apply(this, arr);
};
MiddlewareArray.prototype.prepend = function () {
var arr = [];
for (var _i = 0; _i < arguments.length; _i++) {
arr[_i] = arguments[_i];
}
if (arr.length === 1 && Array.isArray(arr[0])) {
return new (MiddlewareArray.bind.apply(MiddlewareArray, __spreadArray([void 0], arr[0].concat(this))))();
}
return new (MiddlewareArray.bind.apply(MiddlewareArray, __spreadArray([void 0], arr.concat(this))))();
};
return MiddlewareArray;
}(Array));
var EnhancerArray = /** @class */ (function (_super) {
__extends(EnhancerArray, _super);
function EnhancerArray() {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
var _this = _super.apply(this, args) || this;
Object.setPrototypeOf(_this, EnhancerArray.prototype);
return _this;
}
Object.defineProperty(EnhancerArray, Symbol.species, {
get: function () {
return EnhancerArray;
},
enumerable: false,
configurable: true
});
EnhancerArray.prototype.concat = function () {
var arr = [];
for (var _i = 0; _i < arguments.length; _i++) {
arr[_i] = arguments[_i];
}
return _super.prototype.concat.apply(this, arr);
};
EnhancerArray.prototype.prepend = function () {
var arr = [];
for (var _i = 0; _i < arguments.length; _i++) {
arr[_i] = arguments[_i];
}
if (arr.length === 1 && Array.isArray(arr[0])) {
return new (EnhancerArray.bind.apply(EnhancerArray, __spreadArray([void 0], arr[0].concat(this))))();
}
return new (EnhancerArray.bind.apply(EnhancerArray, __spreadArray([void 0], arr.concat(this))))();
};
return EnhancerArray;
}(Array));
function freezeDraftable(val) {
return (0, import_immer2.isDraftable)(val) ? (0, import_immer2.default)(val, function () {
}) : val;
}
// src/immutableStateInvariantMiddleware.ts
var isProduction = false;
var prefix = "Invariant failed";
function invariant(condition, message) {
if (condition) {
return;
}
if (isProduction) {
throw new Error(prefix);
}
throw new Error(prefix + ": " + (message || ""));
}
function stringify(obj, serializer, indent, decycler) {
return JSON.stringify(obj, getSerialize(serializer, decycler), indent);
}
function getSerialize(serializer, decycler) {
var stack = [], keys = [];
if (!decycler)
decycler = function (_, value) {
if (stack[0] === value)
return "[Circular ~]";
return "[Circular ~." + keys.slice(0, stack.indexOf(value)).join(".") + "]";
};
return function (key, value) {
if (stack.length > 0) {
var thisPos = stack.indexOf(this);
~thisPos ? stack.splice(thisPos + 1) : stack.push(this);
~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key);
if (~stack.indexOf(value))
value = decycler.call(this, key, value);
}
else
stack.push(value);
return serializer == null ? value : serializer.call(this, key, value);
};
}
function isImmutableDefault(value) {
return typeof value !== "object" || value == null || Object.isFrozen(value);
}
function trackForMutations(isImmutable, ignorePaths, obj) {
var trackedProperties = trackProperties(isImmutable, ignorePaths, obj);
return {
detectMutations: function () {
return detectMutations(isImmutable, ignorePaths, trackedProperties, obj);
}
};
}
function trackProperties(isImmutable, ignorePaths, obj, path, checkedObjects) {
if (ignorePaths === void 0) { ignorePaths = []; }
if (path === void 0) { path = ""; }
if (checkedObjects === void 0) { checkedObjects = new Set(); }
var tracked = { value: obj };
if (!isImmutable(obj) && !checkedObjects.has(obj)) {
checkedObjects.add(obj);
tracked.children = {};
for (var key in obj) {
var childPath = path ? path + "." + key : key;
if (ignorePaths.length && ignorePaths.indexOf(childPath) !== -1) {
continue;
}
tracked.children[key] = trackProperties(isImmutable, ignorePaths, obj[key], childPath);
}
}
return tracked;
}
function detectMutations(isImmutable, ignoredPaths, trackedProperty, obj, sameParentRef, path) {
if (ignoredPaths === void 0) { ignoredPaths = []; }
if (sameParentRef === void 0) { sameParentRef = false; }
if (path === void 0) { path = ""; }
var prevObj = trackedProperty ? trackedProperty.value : void 0;
var sameRef = prevObj === obj;
if (sameParentRef && !sameRef && !Number.isNaN(obj)) {
return { wasMutated: true, path: path };
}
if (isImmutable(prevObj) || isImmutable(obj)) {
return { wasMutated: false };
}
var keysToDetect = {};
for (var key in trackedProperty.children) {
keysToDetect[key] = true;
}
for (var key in obj) {
keysToDetect[key] = true;
}
var hasIgnoredPaths = ignoredPaths.length > 0;
var _loop_2 = function (key) {
var nestedPath = path ? path + "." + key : key;
if (hasIgnoredPaths) {
var hasMatches = ignoredPaths.some(function (ignored) {
if (ignored instanceof RegExp) {
return ignored.test(nestedPath);
}
return nestedPath === ignored;
});
if (hasMatches) {
return "continue";
}
}
var result = detectMutations(isImmutable, ignoredPaths, trackedProperty.children[key], obj[key], sameRef, nestedPath);
if (result.wasMutated) {
return { value: result };
}
};
for (var key in keysToDetect) {
var state_1 = _loop_2(key);
if (typeof state_1 === "object")
return state_1.value;
}
return { wasMutated: false };
}
function createImmutableStateInvariantMiddleware(options) {
if (options === void 0) { options = {}; }
if (false) {
return function () { return function (next) { return function (action) { return next(action); }; }; };
}
var _c = options.isImmutable, isImmutable = _c === void 0 ? isImmutableDefault : _c, ignoredPaths = options.ignoredPaths, _d = options.warnAfter, warnAfter = _d === void 0 ? 32 : _d, ignore = options.ignore;
ignoredPaths = ignoredPaths || ignore;
var track = trackForMutations.bind(null, isImmutable, ignoredPaths);
return function (_c) {
var getState = _c.getState;
var state = getState();
var tracker = track(state);
var result;
return function (next) { return function (action) {
var measureUtils = getTimeMeasureUtils(warnAfter, "ImmutableStateInvariantMiddleware");
measureUtils.measureTime(function () {
state = getState();
result = tracker.detectMutations();
tracker = track(state);
invariant(!result.wasMutated, "A state mutation was detected between dispatches, in the path '" + (result.path || "") + "'. This may cause incorrect behavior. (https://redux.js.org/style-guide/style-guide#do-not-mutate-state)");
});
var dispatchedAction = next(action);
measureUtils.measureTime(function () {
state = getState();
result = tracker.detectMutations();
tracker = track(state);
result.wasMutated && invariant(!result.wasMutated, "A state mutation was detected inside a dispatch, in the path: " + (result.path || "") + ". Take a look at the reducer(s) handling the action " + stringify(action) + ". (https://redux.js.org/style-guide/style-guide#do-not-mutate-state)");
});
measureUtils.warnIfExceeded();
return dispatchedAction;
}; };
};
}
// src/serializableStateInvariantMiddleware.ts
function isPlain(val) {
var type = typeof val;
return val == null || type === "string" || type === "boolean" || type === "number" || Array.isArray(val) || isPlainObject(val);
}
function findNonSerializableValue(value, path, isSerializable, getEntries, ignoredPaths, cache) {
if (path === void 0) { path = ""; }
if (isSerializable === void 0) { isSerializable = isPlain; }
if (ignoredPaths === void 0) { ignoredPaths = []; }
var foundNestedSerializable;
if (!isSerializable(value)) {
return {
keyPath: path || "<root>",
value: value
};
}
if (typeof value !== "object" || value === null) {
return false;
}
if (cache == null ? void 0 : cache.has(value))
return false;
var entries = getEntries != null ? getEntries(value) : Object.entries(value);
var hasIgnoredPaths = ignoredPaths.length > 0;
var _loop_3 = function (key, nestedValue) {
var nestedPath = path ? path + "." + key : key;
if (hasIgnoredPaths) {
var hasMatches = ignoredPaths.some(function (ignored) {
if (ignored instanceof RegExp) {
return ignored.test(nestedPath);
}
return nestedPath === ignored;
});
if (hasMatches) {
return "continue";
}
}
if (!isSerializable(nestedValue)) {
return { value: {
keyPath: nestedPath,
value: nestedValue
} };
}
if (typeof nestedValue === "object") {
foundNestedSerializable = findNonSerializableValue(nestedValue, nestedPath, isSerializable, getEntries, ignoredPaths, cache);
if (foundNestedSerializable) {
return { value: foundNestedSerializable };
}
}
};
for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
var _c = entries_1[_i], key = _c[0], nestedValue = _c[1];
var state_2 = _loop_3(key, nestedValue);
if (typeof state_2 === "object")
return state_2.value;
}
if (cache && isNestedFrozen(value))
cache.add(value);
return false;
}
function isNestedFrozen(value) {
if (!Object.isFrozen(value))
return false;
for (var _i = 0, _c = Object.values(value); _i < _c.length; _i++) {
var nestedValue = _c[_i];
if (typeof nestedValue !== "object" || nestedValue === null)
continue;
if (!isNestedFrozen(nestedValue))
return false;
}
return true;
}
function createSerializableStateInvariantMiddleware(options) {
if (options === void 0) { options = {}; }
if (false) {
return function () { return function (next) { return function (action) { return next(action); }; }; };
}
var _c = options.isSerializable, isSerializable = _c === void 0 ? isPlain : _c, getEntries = options.getEntries, _d = options.ignoredActions, ignoredActions = _d === void 0 ? [] : _d, _e = options.ignoredActionPaths, ignoredActionPaths = _e === void 0 ? ["meta.arg", "meta.baseQueryMeta"] : _e, _f = options.ignoredPaths, ignoredPaths = _f === void 0 ? [] : _f, _g = options.warnAfter, warnAfter = _g === void 0 ? 32 : _g, _h = options.ignoreState, ignoreState = _h === void 0 ? false : _h, _j = options.ignoreActions, ignoreActions = _j === void 0 ? false : _j, _k = options.disableCache, disableCache = _k === void 0 ? false : _k;
var cache = !disableCache && WeakSet ? new WeakSet() : void 0;
return function (storeAPI) { return function (next) { return function (action) {
var result = next(action);
var measureUtils = getTimeMeasureUtils(warnAfter, "SerializableStateInvariantMiddleware");
if (!ignoreActions && !(ignoredActions.length && ignoredActions.indexOf(action.type) !== -1)) {
measureUtils.measureTime(function () {
var foundActionNonSerializableValue = findNonSerializableValue(action, "", isSerializable, getEntries, ignoredActionPaths, cache);
if (foundActionNonSerializableValue) {
var keyPath = foundActionNonSerializableValue.keyPath, value = foundActionNonSerializableValue.value;
console.error("A non-serializable value was detected in an action, in the path: `" + keyPath + "`. Value:", value, "\nTake a look at the logic that dispatched this action: ", action, "\n(See https://redux.js.org/faq/actions#why-should-type-be-a-string-or-at-least-serializable-why-should-my-action-types-be-constants)", "\n(To allow non-serializable values see: https://redux-toolkit.js.org/usage/usage-guide#working-with-non-serializable-data)");
}
});
}
if (!ignoreState) {
measureUtils.measureTime(function () {
var state = storeAPI.getState();
var foundStateNonSerializableValue = findNonSerializableValue(state, "", isSerializable, getEntries, ignoredPaths, cache);
if (foundStateNonSerializableValue) {
var keyPath = foundStateNonSerializableValue.keyPath, value = foundStateNonSerializableValue.value;
console.error("A non-serializable value was detected in the state, in the path: `" + keyPath + "`. Value:", value, "\nTake a look at the reducer(s) handling this action type: " + action.type + ".\n(See https://redux.js.org/faq/organizing-state#can-i-put-functions-promises-or-other-non-serializable-items-in-my-store-state)");
}
});
measureUtils.warnIfExceeded();
}
return result;
}; }; };
}
// src/getDefaultMiddleware.ts
function isBoolean(x) {
return typeof x === "boolean";
}
function curryGetDefaultMiddleware() {
return function curriedGetDefaultMiddleware(options) {
return getDefaultMiddleware(options);
};
}
function getDefaultMiddleware(options) {
if (options === void 0) { options = {}; }
var _c = options.thunk, thunk = _c === void 0 ? true : _c, _d = options.immutableCheck, immutableCheck = _d === void 0 ? true : _d, _e = options.serializableCheck, serializableCheck = _e === void 0 ? true : _e, _f = options.actionCreatorCheck, actionCreatorCheck = _f === void 0 ? true : _f;
var middlewareArray = new MiddlewareArray();
if (thunk) {
if (isBoolean(thunk)) {
middlewareArray.push(import_redux_thunk.default);
}
else {
middlewareArray.push(import_redux_thunk.default.withExtraArgument(thunk.extraArgument));
}
}
if (true) {
if (immutableCheck) {
var immutableOptions = {};
if (!isBoolean(immutableCheck)) {
immutableOptions = immutableCheck;
}
middlewareArray.unshift(createImmutableStateInvariantMiddleware(immutableOptions));
}
if (serializableCheck) {
var serializableOptions = {};
if (!isBoolean(serializableCheck)) {
serializableOptions = serializableCheck;
}
middlewareArray.push(createSerializableStateInvariantMiddleware(serializableOptions));
}
if (actionCreatorCheck) {
var actionCreatorOptions = {};
if (!isBoolean(actionCreatorCheck)) {
actionCreatorOptions = actionCreatorCheck;
}
middlewareArray.unshift(createActionCreatorInvariantMiddleware(actionCreatorOptions));
}
}
return middlewareArray;
}
// src/configureStore.ts
var IS_PRODUCTION = false;
function configureStore(options) {
var curriedGetDefaultMiddleware = curryGetDefaultMiddleware();
var _c = options || {}, _d = _c.reducer, reducer = _d === void 0 ? void 0 : _d, _e = _c.middleware, middleware = _e === void 0 ? curriedGetDefaultMiddleware() : _e, _f = _c.devTools, devTools = _f === void 0 ? true : _f, _g = _c.preloadedState, preloadedState = _g === void 0 ? void 0 : _g, _h = _c.enhancers, enhancers = _h === void 0 ? void 0 : _h;
var rootReducer;
if (typeof reducer === "function") {
rootReducer = reducer;
}
else if (isPlainObject(reducer)) {
rootReducer = (0, import_redux2.combineReducers)(reducer);
}
else {
throw new Error('"reducer" is a required argument, and must be a function or an object of functions that can be passed to combineReducers');
}
var finalMiddleware = middleware;
if (typeof finalMiddleware === "function") {
finalMiddleware = finalMiddleware(curriedGetDefaultMiddleware);
if (!IS_PRODUCTION && !Array.isArray(finalMiddleware)) {
throw new Error("when using a middleware builder function, an array of middleware must be returned");
}
}
if (!IS_PRODUCTION && finalMiddleware.some(function (item) { return typeof item !== "function"; })) {
throw new Error("each middleware provided to configureStore must be a function");
}
var middlewareEnhancer = (0, import_redux2.applyMiddleware).apply(void 0, finalMiddleware);
var finalCompose = import_redux2.compose;
if (devTools) {
finalCompose = composeWithDevTools(__spreadValues({
trace: !IS_PRODUCTION
}, typeof devTools === "object" && devTools));
}
var defaultEnhancers = new EnhancerArray(middlewareEnhancer);
var storeEnhancers = defaultEnhancers;
if (Array.isArray(enhancers)) {
storeEnhancers = __spreadArray([middlewareEnhancer], enhancers);
}
else if (typeof enhancers === "function") {
storeEnhancers = enhancers(defaultEnhancers);
}
var composedEnhancer = finalCompose.apply(void 0, storeEnhancers);
return (0, import_redux2.createStore)(rootReducer, preloadedState, composedEnhancer);
}
// src/createReducer.ts
var import_immer3 = __toModule(require("immer"));
// src/mapBuilders.ts
function executeReducerBuilderCallback(builderCallback) {
var actionsMap = {};
var actionMatchers = [];
var defaultCaseReducer;
var builder = {
addCase: function (typeOrActionCreator, reducer) {
if (true) {
if (actionMatchers.length > 0) {
throw new Error("`builder.addCase` should only be called before calling `builder.addMatcher`");
}
if (defaultCaseReducer) {
throw new Error("`builder.addCase` should only be called before calling `builder.addDefaultCase`");
}
}
var type = typeof typeOrActionCreator === "string" ? typeOrActionCreator : typeOrActionCreator.type;
if (!type) {
throw new Error("`builder.addCase` cannot be called with an empty action type");
}
if (type in actionsMap) {
throw new Error("`builder.addCase` cannot be called with two reducers for the same action type");
}
actionsMap[type] = reducer;
return builder;
},
addMatcher: function (matcher, reducer) {
if (true) {
if (defaultCaseReducer) {
throw new Error("`builder.addMatcher` should only be called before calling `builder.addDefaultCase`");
}
}
actionMatchers.push({ matcher: matcher, reducer: reducer });
return builder;
},
addDefaultCase: function (reducer) {
if (true) {
if (defaultCaseReducer) {
throw new Error("`builder.addDefaultCase` can only be called once");
}
}
defaultCaseReducer = reducer;
return builder;
}
};
builderCallback(builder);
return [actionsMap, actionMatchers, defaultCaseReducer];
}
// src/createReducer.ts
function isStateFunction(x) {
return typeof x === "function";
}
var hasWarnedAboutObjectNotation = false;
function createReducer(initialState, mapOrBuilderCallback, actionMatchers, defaultCaseReducer) {
if (actionMatchers === void 0) { actionMatchers = []; }
if (true) {
if (typeof mapOrBuilderCallback === "object") {
if (!hasWarnedAboutObjectNotation) {
hasWarnedAboutObjectNotation = true;
console.warn("The object notation for `createReducer` is deprecated, and will be removed in RTK 2.0. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createReducer");
}
}
}
var _c = typeof mapOrBuilderCallback === "function" ? executeReducerBuilderCallback(mapOrBuilderCallback) : [mapOrBuilderCallback, actionMatchers, defaultCaseReducer], actionsMap = _c[0], finalActionMatchers = _c[1], finalDefaultCaseReducer = _c[2];
var getInitialState;
if (isStateFunction(initialState)) {
getInitialState = function () { return freezeDraftable(initialState()); };
}
else {
var frozenInitialState_1 = freezeDraftable(initialState);
getInitialState = function () { return frozenInitialState_1; };
}
function reducer(state, action) {
if (state === void 0) { state = getInitialState(); }
var caseReducers = __spreadArray([
actionsMap[action.type]
], finalActionMatchers.filter(function (_c) {
var matcher = _c.matcher;
return matcher(action);
}).map(function (_c) {
var reducer2 = _c.reducer;
return reducer2;
}));
if (caseReducers.filter(function (cr) { return !!cr; }).length === 0) {
caseReducers = [finalDefaultCaseReducer];
}
return caseReducers.reduce(function (previousState, caseReducer) {
if (caseReducer) {
if ((0, import_immer3.isDraft)(previousState)) {
var draft = previousState;
var result = caseReducer(draft, action);
if (result === void 0) {
return previousState;
}
return result;
}
else if (!(0, import_immer3.isDraftable)(previousState)) {
var result = caseReducer(previousState, action);
if (result === void 0) {
if (previousState === null) {
return previousState;
}
throw Error("A case reducer on a non-draftable value must not return undefined");
}
return result;
}
else {
return (0, import_immer3.default)(previousState, function (draft) {
return caseReducer(draft, action);
});
}
}
return previousState;
}, state);
}
reducer.getInitialState = getInitialState;
return reducer;
}
// src/createSlice.ts
var hasWarnedAboutObjectNotation2 = false;
function getType2(slice, actionKey) {
return slice + "/" + actionKey;
}
function createSlice(options) {
var name = options.name;
if (!name) {
throw new Error("`name` is a required option for createSlice");
}
if (typeof process !== "undefined" && true) {
if (options.initialState === void 0) {
console.error("You must provide an `initialState` value that is not `undefined`. You may have misspelled `initialState`");
}
}
var initialState = typeof options.initialState == "function" ? options.initialState : freezeDraftable(options.initialState);
var reducers = options.reducers || {};
var reducerNames = Object.keys(reducers);
var sliceCaseReducersByName = {};
var sliceCaseReducersByType = {};
var actionCreators = {};
reducerNames.forEach(function (reducerName) {
var maybeReducerWithPrepare = reducers[reducerName];
var type = getType2(name, reducerName);
var caseReducer;
var prepareCallback;
if ("reducer" in maybeReducerWithPrepare) {
caseReducer = maybeReducerWithPrepare.reducer;
prepareCallback = maybeReducerWithPrepare.prepare;
}
else {
caseReducer = maybeReducerWithPrepare;
}
sliceCaseReducersByName[reducerName] = caseReducer;
sliceCaseReducersByType[type] = caseReducer;
actionCreators[reducerName] = prepareCallback ? createAction(type, prepareCallback) : createAction(type);
});
function buildReducer() {
if (true) {
if (typeof options.extraReducers === "object") {
if (!hasWarnedAboutObjectNotation2) {
hasWarnedAboutObjectNotation2 = true;
console.warn("The object notation for `createSlice.extraReducers` is deprecated, and will be removed in RTK 2.0. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createSlice");
}
}
}
var _c = typeof options.extraReducers === "function" ? executeReducerBuilderCallback(options.extraReducers) : [options.extraReducers], _d = _c[0], extraReducers = _d === void 0 ? {} : _d, _e = _c[1], actionMatchers = _e === void 0 ? [] : _e, _f = _c[2], defaultCaseReducer = _f === void 0 ? void 0 : _f;
var finalCaseReducers = __spreadValues(__spreadValues({}, extraReducers), sliceCaseReducersByType);
return createReducer(initialState, function (builder) {
for (var key in finalCaseReducers) {
builder.addCase(key, finalCaseReducers[key]);
}
for (var _i = 0, actionMatchers_1 = actionMatchers; _i < actionMatchers_1.length; _i++) {
var m = actionMatchers_1[_i];
builder.addMatcher(m.matcher, m.reducer);
}
if (defaultCaseReducer) {
builder.addDefaultCase(defaultCaseReducer);
}
});
}
var _reducer;
return {
name: name,
reducer: function (state, action) {
if (!_reducer)
_reducer = buildReducer();
return _reducer(state, action);
},
actions: actionCreators,
caseReducers: sliceCaseReducersByName,
getInitialState: function () {
if (!_reducer)
_reducer = buildReducer();
return _reducer.getInitialState();
}
};
}
// src/entities/entity_state.ts
function getInitialEntityState() {
return {
ids: [],
entities: {}
};
}
function createInitialStateFactory() {
function getInitialState(additionalState) {
if (additionalState === void 0) { additionalState = {}; }
return Object.assign(getInitialEntityState(), additionalState);
}
return { getInitialState: getInitialState };
}
// src/entities/state_selectors.ts
function createSelectorsFactory() {
function getSelectors(selectState) {
var selectIds = function (state) { return state.ids; };
var selectEntities = function (state) { return state.entities; };
var selectAll = createDraftSafeSelector(selectIds, selectEntities, function (ids, entities) { return ids.map(function (id) { return entities[id]; }); });
var selectId = function (_, id) { return id; };
var selectById = function (entities, id) { return entities[id]; };
var selectTotal = createDraftSafeSelector(selectIds, function (ids) { return ids.length; });
if (!selectState) {
return {
selectIds: selectIds,
selectEntities: selectEntities,
selectAll: selectAll,
selectTotal: selectTotal,
selectById: createDraftSafeSelector(selectEntities, selectId, selectById)
};
}
var selectGlobalizedEntities = createDraftSafeSelector(selectState, selectEntities);
return {
selectIds: createDraftSafeSelector(selectState, selectIds),
selectEntities: selectGlobalizedEntities,
selectAll: createDraftSafeSelector(selectState, selectAll),
selectTotal: createDraftSafeSelector(selectState, selectTotal),
selectById: createDraftSafeSelector(selectGlobalizedEntities, selectId, selectById)
};
}
return { getSelectors: getSelectors };
}
// src/entities/state_adapter.ts
var import_immer4 = __toModule(require("immer"));
function createSingleArgumentStateOperator(mutator) {
var operator = createStateOperator(function (_, state) { return mutator(state); });
return function operation(state) {
return operator(state, void 0);
};
}
function createStateOperator(mutator) {
return function operation(state, arg) {
function isPayloadActionArgument(arg2) {
return isFSA(arg2);
}
var runMutator = function (draft) {
if (isPayloadActionArgument(arg)) {
mutator(arg.payload, draft);
}
else {
mutator(arg, draft);
}
};
if ((0, import_immer4.isDraft)(state)) {
runMutator(state);
return state;
}
else {
return (0, import_immer4.default)(state, runMutator);
}
};
}
// src/entities/utils.ts
function selectIdValue(entity, selectId) {
var key = selectId(entity);
if (key === void 0) {
console.warn("The entity passed to the `selectId` implementation returned undefined.", "You should probably provide your own `selectId` implementation.", "The entity that was passed:", entity, "The `selectId` implementation:", selectId.toString());
}
return key;
}
function ensureEntitiesArray(entities) {
if (!Array.isArray(entities)) {
entities = Object.values(entities);
}
return entities;
}
function splitAddedUpdatedEntities(newEntities, selectId, state) {
newEntities = ensureEntitiesArray(newEntities);
var added = [];
var updated = [];
for (var _i = 0, newEntities_1 = newEntities; _i < newEntities_1.length; _i++) {
var entity = newEntities_1[_i];
var id = selectIdValue(entity, selectId);
if (id in state.entities) {
updated.push({ id: id, changes: entity });
}
else {
added.push(entity);
}
}
return [added, updated];
}
// src/entities/unsorted_state_adapter.ts
function createUnsortedStateAdapter(selectId) {
function addOneMutably(entity, state) {
var key = selectIdValue(entity, selectId);
if (key in state.entities) {
return;
}
state.ids.push(key);
state.entities[key] = entity;
}
function addManyMutably(newEntities, state) {
newEntities = ensureEntitiesArray(newEntities);
for (var _i = 0, newEntities_2 = newEntities; _i < newEntities_2.length; _i++) {
var entity = newEntities_2[_i];
addOneMutably(entity, state);
}
}
function setOneMutably(entity, state) {
var key = selectIdValue(entity, selectId);
if (!(key in state.entities)) {
state.ids.push(key);
}
state.entities[key] = entity;
}
function setManyMutably(newEntities, state) {
newEntities = ensureEntitiesArray(newEntities);
for (var _i = 0, newEntities_3 = newEntities; _i < newEntities_3.length; _i++) {
var entity = newEntities_3[_i];
setOneMutably(entity, state);
}
}
function setAllMutably(newEntities, state) {
newEntities = ensureEntitiesArray(newEntities);
state.ids = [];
state.entities = {};
addManyMutably(newEntities, state);
}
function removeOneMutably(key, state) {
return removeManyMutably([key], state);
}
function removeManyMutably(keys, state) {
var didMutate = false;
keys.forEach(function (key) {
if (key in state.entities) {
delete state.entities[key];
didMutate = true;
}
});
if (didMutate) {
state.ids = state.ids.filter(function (id) { return id in state.entities; });
}
}
function removeAllMutably(state) {
Object.assign(state, {
ids: [],
entities: {}
});
}
function takeNewKey(keys, update, state) {
var original2 = state.entities[update.id];
var updated = Object.assign({}, original2, update.changes);
var newKey = selectIdValue(updated, selectId);
var hasNewKey = newKey !== update.id;
if (hasNewKey) {
keys[update.id] = newKey;
delete state.entities[update.id];
}
state.entities[newKey] = updated;
return hasNewKey;
}
function updateOneMutably(update, state) {
return updateManyMutably([update], state);
}
function updateManyMutably(updates, state) {
var newKeys = {};
var updatesPerEntity = {};
updates.forEach(function (update) {
if (update.id in state.entities) {
updatesPerEntity[update.id] = {
id: update.id,
changes: __spreadValues(__spreadValues({}, updatesPerEntity[update.id] ? updatesPerEntity[update.id].changes : null), update.changes)
};
}
});
updates = Object.values(updatesPerEntity);
var didMutateEntities