@reduxjs/toolkit
Version:
The official, opinionated, batteries-included toolset for efficient Redux development
1,388 lines (1,363 loc) • 80.6 kB
JavaScript
"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// src/index.ts
var src_exports = {};
__export(src_exports, {
ReducerType: () => ReducerType,
SHOULD_AUTOBATCH: () => SHOULD_AUTOBATCH,
TaskAbortError: () => TaskAbortError,
Tuple: () => Tuple,
addListener: () => addListener,
asyncThunkCreator: () => asyncThunkCreator,
autoBatchEnhancer: () => autoBatchEnhancer,
buildCreateSlice: () => buildCreateSlice,
clearAllListeners: () => clearAllListeners,
combineSlices: () => combineSlices,
configureStore: () => configureStore,
createAction: () => createAction,
createActionCreatorInvariantMiddleware: () => createActionCreatorInvariantMiddleware,
createAsyncThunk: () => createAsyncThunk,
createDraftSafeSelector: () => createDraftSafeSelector,
createDraftSafeSelectorCreator: () => createDraftSafeSelectorCreator,
createDynamicMiddleware: () => createDynamicMiddleware,
createEntityAdapter: () => createEntityAdapter,
createImmutableStateInvariantMiddleware: () => createImmutableStateInvariantMiddleware,
createListenerMiddleware: () => createListenerMiddleware,
createNextState: () => import_immer6.produce,
createReducer: () => createReducer,
createSelector: () => import_reselect2.createSelector,
createSelectorCreator: () => import_reselect2.createSelectorCreator,
createSerializableStateInvariantMiddleware: () => createSerializableStateInvariantMiddleware,
createSlice: () => createSlice,
current: () => import_immer6.current,
findNonSerializableValue: () => findNonSerializableValue,
formatProdErrorMessage: () => formatProdErrorMessage,
freeze: () => import_immer6.freeze,
isActionCreator: () => isActionCreator,
isAllOf: () => isAllOf,
isAnyOf: () => isAnyOf,
isAsyncThunkAction: () => isAsyncThunkAction,
isDraft: () => import_immer6.isDraft,
isFluxStandardAction: () => isFSA,
isFulfilled: () => isFulfilled,
isImmutableDefault: () => isImmutableDefault,
isPending: () => isPending,
isPlain: () => isPlain,
isRejected: () => isRejected,
isRejectedWithValue: () => isRejectedWithValue,
lruMemoize: () => import_reselect2.lruMemoize,
miniSerializeError: () => miniSerializeError,
nanoid: () => nanoid,
original: () => import_immer6.original,
prepareAutoBatched: () => prepareAutoBatched,
removeListener: () => removeListener,
unwrapResult: () => unwrapResult,
weakMapMemoize: () => import_reselect2.weakMapMemoize
});
module.exports = __toCommonJS(src_exports);
__reExport(src_exports, require("redux"), module.exports);
var import_immer6 = require("immer");
var import_reselect2 = require("reselect");
// src/createDraftSafeSelector.ts
var import_immer = require("immer");
var import_reselect = require("reselect");
var createDraftSafeSelectorCreator = (...args) => {
const createSelector2 = (0, import_reselect.createSelectorCreator)(...args);
const createDraftSafeSelector2 = Object.assign((...args2) => {
const selector = createSelector2(...args2);
const wrappedSelector = (value, ...rest) => selector((0, import_immer.isDraft)(value) ? (0, import_immer.current)(value) : value, ...rest);
Object.assign(wrappedSelector, selector);
return wrappedSelector;
}, {
withTypes: () => createDraftSafeSelector2
});
return createDraftSafeSelector2;
};
var createDraftSafeSelector = /* @__PURE__ */ createDraftSafeSelectorCreator(import_reselect.weakMapMemoize);
// src/configureStore.ts
var import_redux4 = require("redux");
// src/devtoolsExtension.ts
var import_redux = 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(noop3) {
return noop3;
};
};
// src/getDefaultMiddleware.ts
var import_redux_thunk = require("redux-thunk");
// src/createAction.ts
var import_redux2 = require("redux");
// src/tsHelpers.ts
var hasMatchFunction = (v) => {
return v && typeof v.match === "function";
};
// src/createAction.ts
function createAction(type, prepareAction) {
function actionCreator(...args) {
if (prepareAction) {
let prepared = prepareAction(...args);
if (!prepared) {
throw new Error(false ? _formatProdErrorMessage(0) : "prepareAction did not return an object");
}
return {
type,
payload: prepared.payload,
..."meta" in prepared && {
meta: prepared.meta
},
..."error" in prepared && {
error: prepared.error
}
};
}
return {
type,
payload: args[0]
};
}
actionCreator.toString = () => `${type}`;
actionCreator.type = type;
actionCreator.match = (action) => (0, import_redux2.isAction)(action) && action.type === type;
return actionCreator;
}
function isActionCreator(action) {
return typeof action === "function" && "type" in action && // hasMatchFunction only wants Matchers but I don't see the point in rewriting it
hasMatchFunction(action);
}
function isFSA(action) {
return (0, import_redux2.isAction)(action) && Object.keys(action).every(isValidKey);
}
function isValidKey(key) {
return ["type", "payload", "error", "meta"].indexOf(key) > -1;
}
// src/actionCreatorInvariantMiddleware.ts
function getMessage(type) {
const splitType = type ? `${type}`.split("/") : [];
const actionName = splitType[splitType.length - 1] || "actionCreator";
return `Detected an action creator with type "${type || "unknown"}" being dispatched.
Make 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 (false) {
return () => (next) => (action) => next(action);
}
const {
isActionCreator: isActionCreator2 = isActionCreator
} = options;
return () => (next) => (action) => {
if (isActionCreator2(action)) {
console.warn(getMessage(action.type));
}
return next(action);
};
}
// src/utils.ts
var import_immer2 = require("immer");
function getTimeMeasureUtils(maxDelay, fnName) {
let elapsed = 0;
return {
measureTime(fn) {
const started = Date.now();
try {
return fn();
} finally {
const finished = Date.now();
elapsed += finished - started;
}
},
warnIfExceeded() {
if (elapsed > maxDelay) {
console.warn(`${fnName} took ${elapsed}ms, which is more than the warning threshold of ${maxDelay}ms.
If 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.
It is disabled in production builds, so you don't need to worry about that.`);
}
}
};
}
var Tuple = class _Tuple extends Array {
constructor(...items) {
super(...items);
Object.setPrototypeOf(this, _Tuple.prototype);
}
static get [Symbol.species]() {
return _Tuple;
}
concat(...arr) {
return super.concat.apply(this, arr);
}
prepend(...arr) {
if (arr.length === 1 && Array.isArray(arr[0])) {
return new _Tuple(...arr[0].concat(this));
}
return new _Tuple(...arr.concat(this));
}
};
function freezeDraftable(val) {
return (0, import_immer2.isDraftable)(val) ? (0, import_immer2.produce)(val, () => {
}) : val;
}
function getOrInsertComputed(map, key, compute) {
if (map.has(key)) return map.get(key);
return map.set(key, compute(key)).get(key);
}
// src/immutableStateInvariantMiddleware.ts
function isImmutableDefault(value) {
return typeof value !== "object" || value == null || Object.isFrozen(value);
}
function trackForMutations(isImmutable, ignorePaths, obj) {
const trackedProperties = trackProperties(isImmutable, ignorePaths, obj);
return {
detectMutations() {
return detectMutations(isImmutable, ignorePaths, trackedProperties, obj);
}
};
}
function trackProperties(isImmutable, ignorePaths = [], obj, path = "", checkedObjects = /* @__PURE__ */ new Set()) {
const tracked = {
value: obj
};
if (!isImmutable(obj) && !checkedObjects.has(obj)) {
checkedObjects.add(obj);
tracked.children = {};
for (const key in obj) {
const 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 = false, path = "") {
const prevObj = trackedProperty ? trackedProperty.value : void 0;
const sameRef = prevObj === obj;
if (sameParentRef && !sameRef && !Number.isNaN(obj)) {
return {
wasMutated: true,
path
};
}
if (isImmutable(prevObj) || isImmutable(obj)) {
return {
wasMutated: false
};
}
const keysToDetect = {};
for (let key in trackedProperty.children) {
keysToDetect[key] = true;
}
for (let key in obj) {
keysToDetect[key] = true;
}
const hasIgnoredPaths = ignoredPaths.length > 0;
for (let key in keysToDetect) {
const nestedPath = path ? path + "." + key : key;
if (hasIgnoredPaths) {
const hasMatches = ignoredPaths.some((ignored) => {
if (ignored instanceof RegExp) {
return ignored.test(nestedPath);
}
return nestedPath === ignored;
});
if (hasMatches) {
continue;
}
}
const result = detectMutations(isImmutable, ignoredPaths, trackedProperty.children[key], obj[key], sameRef, nestedPath);
if (result.wasMutated) {
return result;
}
}
return {
wasMutated: false
};
}
function createImmutableStateInvariantMiddleware(options = {}) {
if (false) {
return () => (next) => (action) => next(action);
} else {
let stringify2 = function(obj, serializer, indent, decycler) {
return JSON.stringify(obj, getSerialize2(serializer, decycler), indent);
}, getSerialize2 = function(serializer, decycler) {
let 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);
};
};
var stringify = stringify2, getSerialize = getSerialize2;
let {
isImmutable = isImmutableDefault,
ignoredPaths,
warnAfter = 32
} = options;
const track = trackForMutations.bind(null, isImmutable, ignoredPaths);
return ({
getState
}) => {
let state = getState();
let tracker = track(state);
let result;
return (next) => (action) => {
const measureUtils = getTimeMeasureUtils(warnAfter, "ImmutableStateInvariantMiddleware");
measureUtils.measureTime(() => {
state = getState();
result = tracker.detectMutations();
tracker = track(state);
if (result.wasMutated) {
throw new Error(false ? _formatProdErrorMessage(19) : `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)`);
}
});
const dispatchedAction = next(action);
measureUtils.measureTime(() => {
state = getState();
result = tracker.detectMutations();
tracker = track(state);
if (result.wasMutated) {
throw new Error(false ? _formatProdErrorMessage2(20) : `A state mutation was detected inside a dispatch, in the path: ${result.path || ""}. Take a look at the reducer(s) handling the action ${stringify2(action)}. (https://redux.js.org/style-guide/style-guide#do-not-mutate-state)`);
}
});
measureUtils.warnIfExceeded();
return dispatchedAction;
};
};
}
}
// src/serializableStateInvariantMiddleware.ts
var import_redux3 = require("redux");
function isPlain(val) {
const type = typeof val;
return val == null || type === "string" || type === "boolean" || type === "number" || Array.isArray(val) || (0, import_redux3.isPlainObject)(val);
}
function findNonSerializableValue(value, path = "", isSerializable = isPlain, getEntries, ignoredPaths = [], cache) {
let foundNestedSerializable;
if (!isSerializable(value)) {
return {
keyPath: path || "<root>",
value
};
}
if (typeof value !== "object" || value === null) {
return false;
}
if (cache?.has(value)) return false;
const entries = getEntries != null ? getEntries(value) : Object.entries(value);
const hasIgnoredPaths = ignoredPaths.length > 0;
for (const [key, nestedValue] of entries) {
const nestedPath = path ? path + "." + key : key;
if (hasIgnoredPaths) {
const hasMatches = ignoredPaths.some((ignored) => {
if (ignored instanceof RegExp) {
return ignored.test(nestedPath);
}
return nestedPath === ignored;
});
if (hasMatches) {
continue;
}
}
if (!isSerializable(nestedValue)) {
return {
keyPath: nestedPath,
value: nestedValue
};
}
if (typeof nestedValue === "object") {
foundNestedSerializable = findNonSerializableValue(nestedValue, nestedPath, isSerializable, getEntries, ignoredPaths, cache);
if (foundNestedSerializable) {
return foundNestedSerializable;
}
}
}
if (cache && isNestedFrozen(value)) cache.add(value);
return false;
}
function isNestedFrozen(value) {
if (!Object.isFrozen(value)) return false;
for (const nestedValue of Object.values(value)) {
if (typeof nestedValue !== "object" || nestedValue === null) continue;
if (!isNestedFrozen(nestedValue)) return false;
}
return true;
}
function createSerializableStateInvariantMiddleware(options = {}) {
if (false) {
return () => (next) => (action) => next(action);
} else {
const {
isSerializable = isPlain,
getEntries,
ignoredActions = [],
ignoredActionPaths = ["meta.arg", "meta.baseQueryMeta"],
ignoredPaths = [],
warnAfter = 32,
ignoreState = false,
ignoreActions = false,
disableCache = false
} = options;
const cache = !disableCache && WeakSet ? /* @__PURE__ */ new WeakSet() : void 0;
return (storeAPI) => (next) => (action) => {
if (!(0, import_redux3.isAction)(action)) {
return next(action);
}
const result = next(action);
const measureUtils = getTimeMeasureUtils(warnAfter, "SerializableStateInvariantMiddleware");
if (!ignoreActions && !(ignoredActions.length && ignoredActions.indexOf(action.type) !== -1)) {
measureUtils.measureTime(() => {
const foundActionNonSerializableValue = findNonSerializableValue(action, "", isSerializable, getEntries, ignoredActionPaths, cache);
if (foundActionNonSerializableValue) {
const {
keyPath,
value
} = foundActionNonSerializableValue;
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(() => {
const state = storeAPI.getState();
const foundStateNonSerializableValue = findNonSerializableValue(state, "", isSerializable, getEntries, ignoredPaths, cache);
if (foundStateNonSerializableValue) {
const {
keyPath,
value
} = foundStateNonSerializableValue;
console.error(`A non-serializable value was detected in the state, in the path: \`${keyPath}\`. Value:`, value, `
Take a look at the reducer(s) handling this action type: ${action.type}.
(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";
}
var buildGetDefaultMiddleware = () => function getDefaultMiddleware(options) {
const {
thunk = true,
immutableCheck = true,
serializableCheck = true,
actionCreatorCheck = true
} = options ?? {};
let middlewareArray = new Tuple();
if (thunk) {
if (isBoolean(thunk)) {
middlewareArray.push(import_redux_thunk.thunk);
} else {
middlewareArray.push((0, import_redux_thunk.withExtraArgument)(thunk.extraArgument));
}
}
if (true) {
if (immutableCheck) {
let immutableOptions = {};
if (!isBoolean(immutableCheck)) {
immutableOptions = immutableCheck;
}
middlewareArray.unshift(createImmutableStateInvariantMiddleware(immutableOptions));
}
if (serializableCheck) {
let serializableOptions = {};
if (!isBoolean(serializableCheck)) {
serializableOptions = serializableCheck;
}
middlewareArray.push(createSerializableStateInvariantMiddleware(serializableOptions));
}
if (actionCreatorCheck) {
let actionCreatorOptions = {};
if (!isBoolean(actionCreatorCheck)) {
actionCreatorOptions = actionCreatorCheck;
}
middlewareArray.unshift(createActionCreatorInvariantMiddleware(actionCreatorOptions));
}
}
return middlewareArray;
};
// src/autoBatchEnhancer.ts
var SHOULD_AUTOBATCH = "RTK_autoBatch";
var prepareAutoBatched = () => (payload) => ({
payload,
meta: {
[SHOULD_AUTOBATCH]: true
}
});
var createQueueWithTimer = (timeout) => {
return (notify) => {
setTimeout(notify, timeout);
};
};
var autoBatchEnhancer = (options = {
type: "raf"
}) => (next) => (...args) => {
const store = next(...args);
let notifying = true;
let shouldNotifyAtEndOfTick = false;
let notificationQueued = false;
const listeners = /* @__PURE__ */ new Set();
const queueCallback = options.type === "tick" ? queueMicrotask : options.type === "raf" ? (
// requestAnimationFrame won't exist in SSR environments. Fall back to a vague approximation just to keep from erroring.
typeof window !== "undefined" && window.requestAnimationFrame ? window.requestAnimationFrame : createQueueWithTimer(10)
) : options.type === "callback" ? options.queueNotification : createQueueWithTimer(options.timeout);
const notifyListeners = () => {
notificationQueued = false;
if (shouldNotifyAtEndOfTick) {
shouldNotifyAtEndOfTick = false;
listeners.forEach((l) => l());
}
};
return Object.assign({}, store, {
// Override the base `store.subscribe` method to keep original listeners
// from running if we're delaying notifications
subscribe(listener2) {
const wrappedListener = () => notifying && listener2();
const unsubscribe = store.subscribe(wrappedListener);
listeners.add(listener2);
return () => {
unsubscribe();
listeners.delete(listener2);
};
},
// Override the base `store.dispatch` method so that we can check actions
// for the `shouldAutoBatch` flag and determine if batching is active
dispatch(action) {
try {
notifying = !action?.meta?.[SHOULD_AUTOBATCH];
shouldNotifyAtEndOfTick = !notifying;
if (shouldNotifyAtEndOfTick) {
if (!notificationQueued) {
notificationQueued = true;
queueCallback(notifyListeners);
}
}
return store.dispatch(action);
} finally {
notifying = true;
}
}
});
};
// src/getDefaultEnhancers.ts
var buildGetDefaultEnhancers = (middlewareEnhancer) => function getDefaultEnhancers(options) {
const {
autoBatch = true
} = options ?? {};
let enhancerArray = new Tuple(middlewareEnhancer);
if (autoBatch) {
enhancerArray.push(autoBatchEnhancer(typeof autoBatch === "object" ? autoBatch : void 0));
}
return enhancerArray;
};
// src/configureStore.ts
function configureStore(options) {
const getDefaultMiddleware = buildGetDefaultMiddleware();
const {
reducer = void 0,
middleware,
devTools = true,
duplicateMiddlewareCheck = true,
preloadedState = void 0,
enhancers = void 0
} = options || {};
let rootReducer;
if (typeof reducer === "function") {
rootReducer = reducer;
} else if ((0, import_redux4.isPlainObject)(reducer)) {
rootReducer = (0, import_redux4.combineReducers)(reducer);
} else {
throw new Error(false ? _formatProdErrorMessage(1) : "`reducer` is a required argument, and must be a function or an object of functions that can be passed to combineReducers");
}
if (middleware && typeof middleware !== "function") {
throw new Error(false ? _formatProdErrorMessage2(2) : "`middleware` field must be a callback");
}
let finalMiddleware;
if (typeof middleware === "function") {
finalMiddleware = middleware(getDefaultMiddleware);
if (!Array.isArray(finalMiddleware)) {
throw new Error(false ? _formatProdErrorMessage3(3) : "when using a middleware builder function, an array of middleware must be returned");
}
} else {
finalMiddleware = getDefaultMiddleware();
}
if (finalMiddleware.some((item) => typeof item !== "function")) {
throw new Error(false ? _formatProdErrorMessage4(4) : "each middleware provided to configureStore must be a function");
}
if (duplicateMiddlewareCheck) {
let middlewareReferences = /* @__PURE__ */ new Set();
finalMiddleware.forEach((middleware2) => {
if (middlewareReferences.has(middleware2)) {
throw new Error(false ? _formatProdErrorMessage5(42) : "Duplicate middleware references found when creating the store. Ensure that each middleware is only included once.");
}
middlewareReferences.add(middleware2);
});
}
let finalCompose = import_redux4.compose;
if (devTools) {
finalCompose = composeWithDevTools({
// Enable capture of stack traces for dispatched Redux actions
trace: true,
...typeof devTools === "object" && devTools
});
}
const middlewareEnhancer = (0, import_redux4.applyMiddleware)(...finalMiddleware);
const getDefaultEnhancers = buildGetDefaultEnhancers(middlewareEnhancer);
if (enhancers && typeof enhancers !== "function") {
throw new Error(false ? _formatProdErrorMessage6(5) : "`enhancers` field must be a callback");
}
let storeEnhancers = typeof enhancers === "function" ? enhancers(getDefaultEnhancers) : getDefaultEnhancers();
if (!Array.isArray(storeEnhancers)) {
throw new Error(false ? _formatProdErrorMessage7(6) : "`enhancers` callback must return an array");
}
if (storeEnhancers.some((item) => typeof item !== "function")) {
throw new Error(false ? _formatProdErrorMessage8(7) : "each enhancer provided to configureStore must be a function");
}
if (finalMiddleware.length && !storeEnhancers.includes(middlewareEnhancer)) {
console.error("middlewares were provided, but middleware enhancer was not included in final enhancers - make sure to call `getDefaultEnhancers`");
}
const composedEnhancer = finalCompose(...storeEnhancers);
return (0, import_redux4.createStore)(rootReducer, preloadedState, composedEnhancer);
}
// src/createReducer.ts
var import_immer3 = require("immer");
// src/mapBuilders.ts
function executeReducerBuilderCallback(builderCallback) {
const actionsMap = {};
const actionMatchers = [];
let defaultCaseReducer;
const builder = {
addCase(typeOrActionCreator, reducer) {
if (true) {
if (actionMatchers.length > 0) {
throw new Error(false ? _formatProdErrorMessage(26) : "`builder.addCase` should only be called before calling `builder.addMatcher`");
}
if (defaultCaseReducer) {
throw new Error(false ? _formatProdErrorMessage2(27) : "`builder.addCase` should only be called before calling `builder.addDefaultCase`");
}
}
const type = typeof typeOrActionCreator === "string" ? typeOrActionCreator : typeOrActionCreator.type;
if (!type) {
throw new Error(false ? _formatProdErrorMessage3(28) : "`builder.addCase` cannot be called with an empty action type");
}
if (type in actionsMap) {
throw new Error(false ? _formatProdErrorMessage4(29) : `\`builder.addCase\` cannot be called with two reducers for the same action type '${type}'`);
}
actionsMap[type] = reducer;
return builder;
},
addMatcher(matcher, reducer) {
if (true) {
if (defaultCaseReducer) {
throw new Error(false ? _formatProdErrorMessage5(30) : "`builder.addMatcher` should only be called before calling `builder.addDefaultCase`");
}
}
actionMatchers.push({
matcher,
reducer
});
return builder;
},
addDefaultCase(reducer) {
if (true) {
if (defaultCaseReducer) {
throw new Error(false ? _formatProdErrorMessage6(31) : "`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";
}
function createReducer(initialState, mapOrBuilderCallback) {
if (true) {
if (typeof mapOrBuilderCallback === "object") {
throw new Error(false ? _formatProdErrorMessage(8) : "The object notation for `createReducer` has been removed. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createReducer");
}
}
let [actionsMap, finalActionMatchers, finalDefaultCaseReducer] = executeReducerBuilderCallback(mapOrBuilderCallback);
let getInitialState;
if (isStateFunction(initialState)) {
getInitialState = () => freezeDraftable(initialState());
} else {
const frozenInitialState = freezeDraftable(initialState);
getInitialState = () => frozenInitialState;
}
function reducer(state = getInitialState(), action) {
let caseReducers = [actionsMap[action.type], ...finalActionMatchers.filter(({
matcher
}) => matcher(action)).map(({
reducer: reducer2
}) => reducer2)];
if (caseReducers.filter((cr) => !!cr).length === 0) {
caseReducers = [finalDefaultCaseReducer];
}
return caseReducers.reduce((previousState, caseReducer) => {
if (caseReducer) {
if ((0, import_immer3.isDraft)(previousState)) {
const draft = previousState;
const result = caseReducer(draft, action);
if (result === void 0) {
return previousState;
}
return result;
} else if (!(0, import_immer3.isDraftable)(previousState)) {
const 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.produce)(previousState, (draft) => {
return caseReducer(draft, action);
});
}
}
return previousState;
}, state);
}
reducer.getInitialState = getInitialState;
return reducer;
}
// src/matchers.ts
var matches = (matcher, action) => {
if (hasMatchFunction(matcher)) {
return matcher.match(action);
} else {
return matcher(action);
}
};
function isAnyOf(...matchers) {
return (action) => {
return matchers.some((matcher) => matches(matcher, action));
};
}
function isAllOf(...matchers) {
return (action) => {
return matchers.every((matcher) => matches(matcher, action));
};
}
function hasExpectedRequestMetadata(action, validStatus) {
if (!action || !action.meta) return false;
const hasValidRequestId = typeof action.meta.requestId === "string";
const hasValidRequestStatus = validStatus.indexOf(action.meta.requestStatus) > -1;
return hasValidRequestId && hasValidRequestStatus;
}
function isAsyncThunkArray(a) {
return typeof a[0] === "function" && "pending" in a[0] && "fulfilled" in a[0] && "rejected" in a[0];
}
function isPending(...asyncThunks) {
if (asyncThunks.length === 0) {
return (action) => hasExpectedRequestMetadata(action, ["pending"]);
}
if (!isAsyncThunkArray(asyncThunks)) {
return isPending()(asyncThunks[0]);
}
return isAnyOf(...asyncThunks.map((asyncThunk) => asyncThunk.pending));
}
function isRejected(...asyncThunks) {
if (asyncThunks.length === 0) {
return (action) => hasExpectedRequestMetadata(action, ["rejected"]);
}
if (!isAsyncThunkArray(asyncThunks)) {
return isRejected()(asyncThunks[0]);
}
return isAnyOf(...asyncThunks.map((asyncThunk) => asyncThunk.rejected));
}
function isRejectedWithValue(...asyncThunks) {
const hasFlag = (action) => {
return action && action.meta && action.meta.rejectedWithValue;
};
if (asyncThunks.length === 0) {
return isAllOf(isRejected(...asyncThunks), hasFlag);
}
if (!isAsyncThunkArray(asyncThunks)) {
return isRejectedWithValue()(asyncThunks[0]);
}
return isAllOf(isRejected(...asyncThunks), hasFlag);
}
function isFulfilled(...asyncThunks) {
if (asyncThunks.length === 0) {
return (action) => hasExpectedRequestMetadata(action, ["fulfilled"]);
}
if (!isAsyncThunkArray(asyncThunks)) {
return isFulfilled()(asyncThunks[0]);
}
return isAnyOf(...asyncThunks.map((asyncThunk) => asyncThunk.fulfilled));
}
function isAsyncThunkAction(...asyncThunks) {
if (asyncThunks.length === 0) {
return (action) => hasExpectedRequestMetadata(action, ["pending", "fulfilled", "rejected"]);
}
if (!isAsyncThunkArray(asyncThunks)) {
return isAsyncThunkAction()(asyncThunks[0]);
}
return isAnyOf(...asyncThunks.flatMap((asyncThunk) => [asyncThunk.pending, asyncThunk.rejected, asyncThunk.fulfilled]));
}
// src/nanoid.ts
var urlAlphabet = "ModuleSymbhasOwnPr-0123456789ABCDEFGHNRVfgctiUvz_KqYTJkLxpZXIjQW";
var nanoid = (size = 21) => {
let id = "";
let i = size;
while (i--) {
id += urlAlphabet[Math.random() * 64 | 0];
}
return id;
};
// src/createAsyncThunk.ts
var commonProperties = ["name", "message", "stack", "code"];
var RejectWithValue = class {
constructor(payload, meta) {
this.payload = payload;
this.meta = meta;
}
/*
type-only property to distinguish between RejectWithValue and FulfillWithMeta
does not exist at runtime
*/
_type;
};
var FulfillWithMeta = class {
constructor(payload, meta) {
this.payload = payload;
this.meta = meta;
}
/*
type-only property to distinguish between RejectWithValue and FulfillWithMeta
does not exist at runtime
*/
_type;
};
var miniSerializeError = (value) => {
if (typeof value === "object" && value !== null) {
const simpleError = {};
for (const property of commonProperties) {
if (typeof value[property] === "string") {
simpleError[property] = value[property];
}
}
return simpleError;
}
return {
message: String(value)
};
};
var externalAbortMessage = "External signal was aborted";
var createAsyncThunk = /* @__PURE__ */ (() => {
function createAsyncThunk2(typePrefix, payloadCreator, options) {
const fulfilled = createAction(typePrefix + "/fulfilled", (payload, requestId, arg, meta) => ({
payload,
meta: {
...meta || {},
arg,
requestId,
requestStatus: "fulfilled"
}
}));
const pending = createAction(typePrefix + "/pending", (requestId, arg, meta) => ({
payload: void 0,
meta: {
...meta || {},
arg,
requestId,
requestStatus: "pending"
}
}));
const rejected = createAction(typePrefix + "/rejected", (error, requestId, arg, payload, meta) => ({
payload,
error: (options && options.serializeError || miniSerializeError)(error || "Rejected"),
meta: {
...meta || {},
arg,
requestId,
rejectedWithValue: !!payload,
requestStatus: "rejected",
aborted: error?.name === "AbortError",
condition: error?.name === "ConditionError"
}
}));
function actionCreator(arg, {
signal
} = {}) {
return (dispatch, getState, extra) => {
const requestId = options?.idGenerator ? options.idGenerator(arg) : nanoid();
const abortController = new AbortController();
let abortHandler;
let abortReason;
function abort(reason) {
abortReason = reason;
abortController.abort();
}
if (signal) {
if (signal.aborted) {
abort(externalAbortMessage);
} else {
signal.addEventListener("abort", () => abort(externalAbortMessage), {
once: true
});
}
}
const promise = async function() {
let finalAction;
try {
let conditionResult = options?.condition?.(arg, {
getState,
extra
});
if (isThenable(conditionResult)) {
conditionResult = await conditionResult;
}
if (conditionResult === false || abortController.signal.aborted) {
throw {
name: "ConditionError",
message: "Aborted due to condition callback returning false."
};
}
const abortedPromise = new Promise((_, reject) => {
abortHandler = () => {
reject({
name: "AbortError",
message: abortReason || "Aborted"
});
};
abortController.signal.addEventListener("abort", abortHandler);
});
dispatch(pending(requestId, arg, options?.getPendingMeta?.({
requestId,
arg
}, {
getState,
extra
})));
finalAction = await Promise.race([abortedPromise, Promise.resolve(payloadCreator(arg, {
dispatch,
getState,
extra,
requestId,
signal: abortController.signal,
abort,
rejectWithValue: (value, meta) => {
return new RejectWithValue(value, meta);
},
fulfillWithValue: (value, meta) => {
return new FulfillWithMeta(value, meta);
}
})).then((result) => {
if (result instanceof RejectWithValue) {
throw result;
}
if (result instanceof FulfillWithMeta) {
return fulfilled(result.payload, requestId, arg, result.meta);
}
return fulfilled(result, requestId, arg);
})]);
} catch (err) {
finalAction = err instanceof RejectWithValue ? rejected(null, requestId, arg, err.payload, err.meta) : rejected(err, requestId, arg);
} finally {
if (abortHandler) {
abortController.signal.removeEventListener("abort", abortHandler);
}
}
const skipDispatch = options && !options.dispatchConditionRejection && rejected.match(finalAction) && finalAction.meta.condition;
if (!skipDispatch) {
dispatch(finalAction);
}
return finalAction;
}();
return Object.assign(promise, {
abort,
requestId,
arg,
unwrap() {
return promise.then(unwrapResult);
}
});
};
}
return Object.assign(actionCreator, {
pending,
rejected,
fulfilled,
settled: isAnyOf(rejected, fulfilled),
typePrefix
});
}
createAsyncThunk2.withTypes = () => createAsyncThunk2;
return createAsyncThunk2;
})();
function unwrapResult(action) {
if (action.meta && action.meta.rejectedWithValue) {
throw action.payload;
}
if (action.error) {
throw action.error;
}
return action.payload;
}
function isThenable(value) {
return value !== null && typeof value === "object" && typeof value.then === "function";
}
// src/createSlice.ts
var asyncThunkSymbol = /* @__PURE__ */ Symbol.for("rtk-slice-createasyncthunk");
var asyncThunkCreator = {
[asyncThunkSymbol]: createAsyncThunk
};
var ReducerType = /* @__PURE__ */ ((ReducerType2) => {
ReducerType2["reducer"] = "reducer";
ReducerType2["reducerWithPrepare"] = "reducerWithPrepare";
ReducerType2["asyncThunk"] = "asyncThunk";
return ReducerType2;
})(ReducerType || {});
function getType(slice, actionKey) {
return `${slice}/${actionKey}`;
}
function buildCreateSlice({
creators
} = {}) {
const cAT = creators?.asyncThunk?.[asyncThunkSymbol];
return function createSlice2(options) {
const {
name,
reducerPath = name
} = options;
if (!name) {
throw new Error(false ? _formatProdErrorMessage(11) : "`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`");
}
}
const reducers = (typeof options.reducers === "function" ? options.reducers(buildReducerCreators()) : options.reducers) || {};
const reducerNames = Object.keys(reducers);
const context = {
sliceCaseReducersByName: {},
sliceCaseReducersByType: {},
actionCreators: {},
sliceMatchers: []
};
const contextMethods = {
addCase(typeOrActionCreator, reducer2) {
const type = typeof typeOrActionCreator === "string" ? typeOrActionCreator : typeOrActionCreator.type;
if (!type) {
throw new Error(false ? _formatProdErrorMessage2(12) : "`context.addCase` cannot be called with an empty action type");
}
if (type in context.sliceCaseReducersByType) {
throw new Error(false ? _formatProdErrorMessage3(13) : "`context.addCase` cannot be called with two reducers for the same action type: " + type);
}
context.sliceCaseReducersByType[type] = reducer2;
return contextMethods;
},
addMatcher(matcher, reducer2) {
context.sliceMatchers.push({
matcher,
reducer: reducer2
});
return contextMethods;
},
exposeAction(name2, actionCreator) {
context.actionCreators[name2] = actionCreator;
return contextMethods;
},
exposeCaseReducer(name2, reducer2) {
context.sliceCaseReducersByName[name2] = reducer2;
return contextMethods;
}
};
reducerNames.forEach((reducerName) => {
const reducerDefinition = reducers[reducerName];
const reducerDetails = {
reducerName,
type: getType(name, reducerName),
createNotation: typeof options.reducers === "function"
};
if (isAsyncThunkSliceReducerDefinition(reducerDefinition)) {
handleThunkCaseReducerDefinition(reducerDetails, reducerDefinition, contextMethods, cAT);
} else {
handleNormalReducerDefinition(reducerDetails, reducerDefinition, contextMethods);
}
});
function buildReducer() {
if (true) {
if (typeof options.extraReducers === "object") {
throw new Error(false ? _formatProdErrorMessage4(14) : "The object notation for `createSlice.extraReducers` has been removed. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createSlice");
}
}
const [extraReducers = {}, actionMatchers = [], defaultCaseReducer = void 0] = typeof options.extraReducers === "function" ? executeReducerBuilderCallback(options.extraReducers) : [options.extraReducers];
const finalCaseReducers = {
...extraReducers,
...context.sliceCaseReducersByType
};
return createReducer(options.initialState, (builder) => {
for (let key in finalCaseReducers) {
builder.addCase(key, finalCaseReducers[key]);
}
for (let sM of context.sliceMatchers) {
builder.addMatcher(sM.matcher, sM.reducer);
}
for (let m of actionMatchers) {
builder.addMatcher(m.matcher, m.reducer);
}
if (defaultCaseReducer) {
builder.addDefaultCase(defaultCaseReducer);
}
});
}
const selectSelf = (state) => state;
const injectedSelectorCache = /* @__PURE__ */ new Map();
const injectedStateCache = /* @__PURE__ */ new WeakMap();
let _reducer;
function reducer(state, action) {
if (!_reducer) _reducer = buildReducer();
return _reducer(state, action);
}
function getInitialState() {
if (!_reducer) _reducer = buildReducer();
return _reducer.getInitialState();
}
function makeSelectorProps(reducerPath2, injected = false) {
function selectSlice(state) {
let sliceState = state[reducerPath2];
if (typeof sliceState === "undefined") {
if (injected) {
sliceState = getOrInsertComputed(injectedStateCache, selectSlice, getInitialState);
} else if (true) {
throw new Error(false ? _formatProdErrorMessage5(15) : "selectSlice returned undefined for an uninjected slice reducer");
}
}
return sliceState;
}
function getSelectors(selectState = selectSelf) {
const selectorCache = getOrInsertComputed(injectedSelectorCache, injected, () => /* @__PURE__ */ new WeakMap());
return getOrInsertComputed(selectorCache, selectState, () => {
const map = {};
for (const [name2, selector] of Object.entries(options.selectors ?? {})) {
map[name2] = wrapSelector(selector, selectState, () => getOrInsertComputed(injectedStateCache, selectState, getInitialState), injected);
}
return map;
});
}
return {
reducerPath: reducerPath2,
getSelectors,
get selectors() {
return getSelectors(selectSlice);
},
selectSlice
};
}
const slice = {
name,
reducer,
actions: context.actionCreators,
caseReducers: context.sliceCaseReducersByName,
getInitialState,
...makeSelectorProps(reducerPath),
injectInto(injectable, {
reducerPath: pathOpt,
...config
} = {}) {
const newReducerPath = pathOpt ?? reducerPath;
injectable.inject({
reducerPath: newReducerPath,
reducer
}, config);
return {
...slice,
...makeSelectorProps(newReducerPath, true)
};
}
};
return slice;
};
}
function wrapSelector(selector, selectState, getInitialState, injected) {
function wrapper(rootState, ...args) {
let sliceState = selectState(rootState);
if (typeof sliceState === "undefined") {
if (injected) {
sliceState = getInitialState();
} else if (true) {
throw new Error(false ? _formatProdErrorMessage6(16) : "selectState returned undefined for an uninjected slice reducer");
}
}
return selector(sliceState, ...args);
}
wrapper.unwrapped = selector;
return wrapper;
}
var createSlice = /* @__PURE__ */ buildCreateSlice();
function buildReducerCreators() {
function asyncThunk(payloadCreator, config) {
return {
_reducerDefinitionType: "asyncThunk" /* asyncThunk */,
payloadCreator,
...config
};
}
asyncThunk.withTypes = () => asyncThunk;
return {
reducer(caseReducer) {
return Object.assign({
// hack so the wrapping function has the same name as the original
// we need to create a wrapper so the `reducerDefinitionType` is not assigned to the original
[caseReducer.name](...args) {
return caseReducer(...args);
}
}[caseReducer.name], {
_reducerDefinitionType: "reducer" /* reducer */
});
},
preparedReducer(prepare, reducer) {
return {
_reducerDefinitionType: "reducerWithPrepare" /* reducerWithPrepare */,
prepare,
reducer
};
},
asyncThunk
};
}
function handleNormalReducerDefinition({
type,
reducerName,
createNotation
}, maybeReducerWithPrepare, context) {
let caseReducer;
let prepareCallback;
if ("reducer" in maybeReducerWithPrepare) {
if (createNotation && !isCaseReducerWithPrepareDefinition(maybeReducerWithPrepare)) {
throw new Error(false ? _formatProdErrorMessage7(17) : "Please use the `create.preparedReducer` notation for prepared action creators with the `create` notation.");
}
caseReducer = maybeReducerWithPrepare.reducer;
prepareCallback = maybeReducerWithPrepare.prepare;
} else {
caseReducer = maybeReducerWithPrepare;
}
context.addCase(type, caseReducer).exposeCaseReducer(reducerName, caseReducer).exposeAction(reducerName, prepareCallback ? createAction(type, prepareCallback) : createAction(type));
}
function isAsyncThunkSliceReducerDefinition(reducerDefinition) {
return reducerDefinition._reducerDefinitionType === "asyncThunk" /* asyncThunk */;
}
function isCaseReducerWithPrepareDefinition(reducerDefinition) {
return reducerDefinition._reducerDefinitionType === "reducerWithPrepare" /* reducerWithPrepare */;
}
function handleThunkCaseReducerDefinition({
type,
reducerName
}, reducerDefinition, context, cAT) {
if (!cAT) {
throw new Error(false ? _formatProdErrorMessage8(18) : "Cannot use `create.asyncThunk` in the built-in `createSlice`. Use `buildCreateSlice({ creators: { asyncThunk: asyncThunkCreator } })` to create a customised version of `createSlice`.");
}
const {
payloadCreator,
fulfilled,
pending,
rejected,
settled,
options
} = reducerDefinition;
const thunk = cAT(type, payloadCreator, options);
context.exposeAction(reducerName, thunk);
if (fulfilled) {
context.addCase(thunk.fulfilled, fulfilled);
}
if (pending) {
context.addCase(thunk.pending, pending);
}
if (rejected) {
context.addCase(thunk.rejected, rejected);
}
if (settled) {
context.addMatcher(thunk.settled, settled);
}
context.exposeCaseReducer(reducerName, {
fulfilled: fulfilled || noop,
pending: pending || noop,
rejected: rejected || noop,
settled: settled || noop
});
}
function noop() {
}
// src/entities/entity_state.ts
function getInitialEntityState() {
return {
ids: [],
entities: {}
};
}
function createInitialStateFactory(stateAdapter) {
function getInitialState(additionalState = {}, entities) {
const state = Object.assign(getInitialEntityState(), additionalState);
return entities ? stateAdapter.setAll(state, entities) : state;
}
return {
getInitialState
};
}
// src/entities/state_selectors.ts
function createSelectorsFactory() {
function getSelectors(selectState, options = {}) {
const {
createSelector: createSelector2 = createDraftSafeSelector
} = options;
const selectIds = (state) => state.ids;
const selectEntities = (state) => state.entities;
const selectAll = createSelector2(selectIds, selectEntities, (ids, entities) => ids.map((id) => entities[id]));
const selectId = (_, id) => id;
const selectById = (entities, id) => entities[id];
const selectTotal = createSelector2(selectIds, (ids) => ids.length);
if (!selectState) {
return {
selectIds,
selectEntities,
selectAll,
selectTotal,
selectById: createSelector2(selectEntities, selectId, selectById)
};
}
const selectGlobalize