Debian Codegraph @

install/freeipa-webui/node_modules/@reduxjs/toolkit/dist/redux-toolkit.modern.mjs

raw
1 // src/index.ts
2 export * from "redux";
3 import { produce, current as current3, freeze, original as original2, isDraft as isDraft5 } from "immer";
4 import { createSelector, createSelectorCreator as createSelectorCreator2, lruMemoize, weakMapMemoize as weakMapMemoize2 } from "reselect";
5
6 // src/createDraftSafeSelector.ts
7 import { current, isDraft } from "immer";
8 import { createSelectorCreator, weakMapMemoize } from "reselect";
9 var createDraftSafeSelectorCreator = (...args) => {
10 const createSelector2 = createSelectorCreator(...args);
11 const createDraftSafeSelector2 = Object.assign((...args2) => {
12 const selector = createSelector2(...args2);
13 const wrappedSelector = (value, ...rest) => selector(isDraft(value) ? current(value) : value, ...rest);
14 Object.assign(wrappedSelector, selector);
15 return wrappedSelector;
16 }, {
17 withTypes: () => createDraftSafeSelector2
18 });
19 return createDraftSafeSelector2;
20 };
21 var createDraftSafeSelector = /* @__PURE__ */ createDraftSafeSelectorCreator(weakMapMemoize);
22
23 // src/configureStore.ts
24 import { applyMiddleware, createStore, compose as compose2, combineReducers, isPlainObject as isPlainObject2 } from "redux";
25
26 // src/devtoolsExtension.ts
27 import { compose } from "redux";
28 var composeWithDevTools = typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ ? window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ : function() {
29 if (arguments.length === 0) return void 0;
30 if (typeof arguments[0] === "object") return compose;
31 return compose.apply(null, arguments);
32 };
33 var devToolsEnhancer = typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION__ ? window.__REDUX_DEVTOOLS_EXTENSION__ : function() {
34 return function(noop3) {
35 return noop3;
36 };
37 };
38
39 // src/getDefaultMiddleware.ts
40 import { thunk as thunkMiddleware, withExtraArgument } from "redux-thunk";
41
42 // src/createAction.ts
43 import { isAction } from "redux";
44
45 // src/tsHelpers.ts
46 var hasMatchFunction = (v) => {
47 return v && typeof v.match === "function";
48 };
49
50 // src/createAction.ts
51 function createAction(type, prepareAction) {
52 function actionCreator(...args) {
53 if (prepareAction) {
54 let prepared = prepareAction(...args);
55 if (!prepared) {
56 throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(0) : "prepareAction did not return an object");
57 }
58 return {
59 type,
60 payload: prepared.payload,
61 ..."meta" in prepared && {
62 meta: prepared.meta
63 },
64 ..."error" in prepared && {
65 error: prepared.error
66 }
67 };
68 }
69 return {
70 type,
71 payload: args[0]
72 };
73 }
74 actionCreator.toString = () => `${type}`;
75 actionCreator.type = type;
76 actionCreator.match = (action) => isAction(action) && action.type === type;
77 return actionCreator;
78 }
79 function isActionCreator(action) {
80 return typeof action === "function" && "type" in action && // hasMatchFunction only wants Matchers but I don't see the point in rewriting it
81 hasMatchFunction(action);
82 }
83 function isFSA(action) {
84 return isAction(action) && Object.keys(action).every(isValidKey);
85 }
86 function isValidKey(key) {
87 return ["type", "payload", "error", "meta"].indexOf(key) > -1;
88 }
89
90 // src/actionCreatorInvariantMiddleware.ts
91 function getMessage(type) {
92 const splitType = type ? `${type}`.split("/") : [];
93 const actionName = splitType[splitType.length - 1] || "actionCreator";
94 return `Detected an action creator with type "${type || "unknown"}" being dispatched.
95 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.`;
96 }
97 function createActionCreatorInvariantMiddleware(options = {}) {
98 if (process.env.NODE_ENV === "production") {
99 return () => (next) => (action) => next(action);
100 }
101 const {
102 isActionCreator: isActionCreator2 = isActionCreator
103 } = options;
104 return () => (next) => (action) => {
105 if (isActionCreator2(action)) {
106 console.warn(getMessage(action.type));
107 }
108 return next(action);
109 };
110 }
111
112 // src/utils.ts
113 import { produce as createNextState, isDraftable } from "immer";
114 function getTimeMeasureUtils(maxDelay, fnName) {
115 let elapsed = 0;
116 return {
117 measureTime(fn) {
118 const started = Date.now();
119 try {
120 return fn();
121 } finally {
122 const finished = Date.now();
123 elapsed += finished - started;
124 }
125 },
126 warnIfExceeded() {
127 if (elapsed > maxDelay) {
128 console.warn(`${fnName} took ${elapsed}ms, which is more than the warning threshold of ${maxDelay}ms.
129 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.
130 It is disabled in production builds, so you don't need to worry about that.`);
131 }
132 }
133 };
134 }
135 var Tuple = class _Tuple extends Array {
136 constructor(...items) {
137 super(...items);
138 Object.setPrototypeOf(this, _Tuple.prototype);
139 }
140 static get [Symbol.species]() {
141 return _Tuple;
142 }
143 concat(...arr) {
144 return super.concat.apply(this, arr);
145 }
146 prepend(...arr) {
147 if (arr.length === 1 && Array.isArray(arr[0])) {
148 return new _Tuple(...arr[0].concat(this));
149 }
150 return new _Tuple(...arr.concat(this));
151 }
152 };
153 function freezeDraftable(val) {
154 return isDraftable(val) ? createNextState(val, () => {
155 }) : val;
156 }
157 function getOrInsertComputed(map, key, compute) {
158 if (map.has(key)) return map.get(key);
159 return map.set(key, compute(key)).get(key);
160 }
161
162 // src/immutableStateInvariantMiddleware.ts
163 function isImmutableDefault(value) {
164 return typeof value !== "object" || value == null || Object.isFrozen(value);
165 }
166 function trackForMutations(isImmutable, ignorePaths, obj) {
167 const trackedProperties = trackProperties(isImmutable, ignorePaths, obj);
168 return {
169 detectMutations() {
170 return detectMutations(isImmutable, ignorePaths, trackedProperties, obj);
171 }
172 };
173 }
174 function trackProperties(isImmutable, ignorePaths = [], obj, path = "", checkedObjects = /* @__PURE__ */ new Set()) {
175 const tracked = {
176 value: obj
177 };
178 if (!isImmutable(obj) && !checkedObjects.has(obj)) {
179 checkedObjects.add(obj);
180 tracked.children = {};
181 for (const key in obj) {
182 const childPath = path ? path + "." + key : key;
183 if (ignorePaths.length && ignorePaths.indexOf(childPath) !== -1) {
184 continue;
185 }
186 tracked.children[key] = trackProperties(isImmutable, ignorePaths, obj[key], childPath);
187 }
188 }
189 return tracked;
190 }
191 function detectMutations(isImmutable, ignoredPaths = [], trackedProperty, obj, sameParentRef = false, path = "") {
192 const prevObj = trackedProperty ? trackedProperty.value : void 0;
193 const sameRef = prevObj === obj;
194 if (sameParentRef && !sameRef && !Number.isNaN(obj)) {
195 return {
196 wasMutated: true,
197 path
198 };
199 }
200 if (isImmutable(prevObj) || isImmutable(obj)) {
201 return {
202 wasMutated: false
203 };
204 }
205 const keysToDetect = {};
206 for (let key in trackedProperty.children) {
207 keysToDetect[key] = true;
208 }
209 for (let key in obj) {
210 keysToDetect[key] = true;
211 }
212 const hasIgnoredPaths = ignoredPaths.length > 0;
213 for (let key in keysToDetect) {
214 const nestedPath = path ? path + "." + key : key;
215 if (hasIgnoredPaths) {
216 const hasMatches = ignoredPaths.some((ignored) => {
217 if (ignored instanceof RegExp) {
218 return ignored.test(nestedPath);
219 }
220 return nestedPath === ignored;
221 });
222 if (hasMatches) {
223 continue;
224 }
225 }
226 const result = detectMutations(isImmutable, ignoredPaths, trackedProperty.children[key], obj[key], sameRef, nestedPath);
227 if (result.wasMutated) {
228 return result;
229 }
230 }
231 return {
232 wasMutated: false
233 };
234 }
235 function createImmutableStateInvariantMiddleware(options = {}) {
236 if (process.env.NODE_ENV === "production") {
237 return () => (next) => (action) => next(action);
238 } else {
239 let stringify2 = function(obj, serializer, indent, decycler) {
240 return JSON.stringify(obj, getSerialize2(serializer, decycler), indent);
241 }, getSerialize2 = function(serializer, decycler) {
242 let stack = [], keys = [];
243 if (!decycler) decycler = function(_, value) {
244 if (stack[0] === value) return "[Circular ~]";
245 return "[Circular ~." + keys.slice(0, stack.indexOf(value)).join(".") + "]";
246 };
247 return function(key, value) {
248 if (stack.length > 0) {
249 var thisPos = stack.indexOf(this);
250 ~thisPos ? stack.splice(thisPos + 1) : stack.push(this);
251 ~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key);
252 if (~stack.indexOf(value)) value = decycler.call(this, key, value);
253 } else stack.push(value);
254 return serializer == null ? value : serializer.call(this, key, value);
255 };
256 };
257 var stringify = stringify2, getSerialize = getSerialize2;
258 let {
259 isImmutable = isImmutableDefault,
260 ignoredPaths,
261 warnAfter = 32
262 } = options;
263 const track = trackForMutations.bind(null, isImmutable, ignoredPaths);
264 return ({
265 getState
266 }) => {
267 let state = getState();
268 let tracker = track(state);
269 let result;
270 return (next) => (action) => {
271 const measureUtils = getTimeMeasureUtils(warnAfter, "ImmutableStateInvariantMiddleware");
272 measureUtils.measureTime(() => {
273 state = getState();
274 result = tracker.detectMutations();
275 tracker = track(state);
276 if (result.wasMutated) {
277 throw new Error(process.env.NODE_ENV === "production" ? 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)`);
278 }
279 });
280 const dispatchedAction = next(action);
281 measureUtils.measureTime(() => {
282 state = getState();
283 result = tracker.detectMutations();
284 tracker = track(state);
285 if (result.wasMutated) {
286 throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(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)`);
287 }
288 });
289 measureUtils.warnIfExceeded();
290 return dispatchedAction;
291 };
292 };
293 }
294 }
295
296 // src/serializableStateInvariantMiddleware.ts
297 import { isAction as isAction2, isPlainObject } from "redux";
298 function isPlain(val) {
299 const type = typeof val;
300 return val == null || type === "string" || type === "boolean" || type === "number" || Array.isArray(val) || isPlainObject(val);
301 }
302 function findNonSerializableValue(value, path = "", isSerializable = isPlain, getEntries, ignoredPaths = [], cache) {
303 let foundNestedSerializable;
304 if (!isSerializable(value)) {
305 return {
306 keyPath: path || "<root>",
307 value
308 };
309 }
310 if (typeof value !== "object" || value === null) {
311 return false;
312 }
313 if (cache?.has(value)) return false;
314 const entries = getEntries != null ? getEntries(value) : Object.entries(value);
315 const hasIgnoredPaths = ignoredPaths.length > 0;
316 for (const [key, nestedValue] of entries) {
317 const nestedPath = path ? path + "." + key : key;
318 if (hasIgnoredPaths) {
319 const hasMatches = ignoredPaths.some((ignored) => {
320 if (ignored instanceof RegExp) {
321 return ignored.test(nestedPath);
322 }
323 return nestedPath === ignored;
324 });
325 if (hasMatches) {
326 continue;
327 }
328 }
329 if (!isSerializable(nestedValue)) {
330 return {
331 keyPath: nestedPath,
332 value: nestedValue
333 };
334 }
335 if (typeof nestedValue === "object") {
336 foundNestedSerializable = findNonSerializableValue(nestedValue, nestedPath, isSerializable, getEntries, ignoredPaths, cache);
337 if (foundNestedSerializable) {
338 return foundNestedSerializable;
339 }
340 }
341 }
342 if (cache && isNestedFrozen(value)) cache.add(value);
343 return false;
344 }
345 function isNestedFrozen(value) {
346 if (!Object.isFrozen(value)) return false;
347 for (const nestedValue of Object.values(value)) {
348 if (typeof nestedValue !== "object" || nestedValue === null) continue;
349 if (!isNestedFrozen(nestedValue)) return false;
350 }
351 return true;
352 }
353 function createSerializableStateInvariantMiddleware(options = {}) {
354 if (process.env.NODE_ENV === "production") {
355 return () => (next) => (action) => next(action);
356 } else {
357 const {
358 isSerializable = isPlain,
359 getEntries,
360 ignoredActions = [],
361 ignoredActionPaths = ["meta.arg", "meta.baseQueryMeta"],
362 ignoredPaths = [],
363 warnAfter = 32,
364 ignoreState = false,
365 ignoreActions = false,
366 disableCache = false
367 } = options;
368 const cache = !disableCache && WeakSet ? /* @__PURE__ */ new WeakSet() : void 0;
369 return (storeAPI) => (next) => (action) => {
370 if (!isAction2(action)) {
371 return next(action);
372 }
373 const result = next(action);
374 const measureUtils = getTimeMeasureUtils(warnAfter, "SerializableStateInvariantMiddleware");
375 if (!ignoreActions && !(ignoredActions.length && ignoredActions.indexOf(action.type) !== -1)) {
376 measureUtils.measureTime(() => {
377 const foundActionNonSerializableValue = findNonSerializableValue(action, "", isSerializable, getEntries, ignoredActionPaths, cache);
378 if (foundActionNonSerializableValue) {
379 const {
380 keyPath,
381 value
382 } = foundActionNonSerializableValue;
383 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)");
384 }
385 });
386 }
387 if (!ignoreState) {
388 measureUtils.measureTime(() => {
389 const state = storeAPI.getState();
390 const foundStateNonSerializableValue = findNonSerializableValue(state, "", isSerializable, getEntries, ignoredPaths, cache);
391 if (foundStateNonSerializableValue) {
392 const {
393 keyPath,
394 value
395 } = foundStateNonSerializableValue;
396 console.error(`A non-serializable value was detected in the state, in the path: \`${keyPath}\`. Value:`, value, `
397 Take a look at the reducer(s) handling this action type: ${action.type}.
398 (See https://redux.js.org/faq/organizing-state#can-i-put-functions-promises-or-other-non-serializable-items-in-my-store-state)`);
399 }
400 });
401 measureUtils.warnIfExceeded();
402 }
403 return result;
404 };
405 }
406 }
407
408 // src/getDefaultMiddleware.ts
409 function isBoolean(x) {
410 return typeof x === "boolean";
411 }
412 var buildGetDefaultMiddleware = () => function getDefaultMiddleware(options) {
413 const {
414 thunk = true,
415 immutableCheck = true,
416 serializableCheck = true,
417 actionCreatorCheck = true
418 } = options ?? {};
419 let middlewareArray = new Tuple();
420 if (thunk) {
421 if (isBoolean(thunk)) {
422 middlewareArray.push(thunkMiddleware);
423 } else {
424 middlewareArray.push(withExtraArgument(thunk.extraArgument));
425 }
426 }
427 if (process.env.NODE_ENV !== "production") {
428 if (immutableCheck) {
429 let immutableOptions = {};
430 if (!isBoolean(immutableCheck)) {
431 immutableOptions = immutableCheck;
432 }
433 middlewareArray.unshift(createImmutableStateInvariantMiddleware(immutableOptions));
434 }
435 if (serializableCheck) {
436 let serializableOptions = {};
437 if (!isBoolean(serializableCheck)) {
438 serializableOptions = serializableCheck;
439 }
440 middlewareArray.push(createSerializableStateInvariantMiddleware(serializableOptions));
441 }
442 if (actionCreatorCheck) {
443 let actionCreatorOptions = {};
444 if (!isBoolean(actionCreatorCheck)) {
445 actionCreatorOptions = actionCreatorCheck;
446 }
447 middlewareArray.unshift(createActionCreatorInvariantMiddleware(actionCreatorOptions));
448 }
449 }
450 return middlewareArray;
451 };
452
453 // src/autoBatchEnhancer.ts
454 var SHOULD_AUTOBATCH = "RTK_autoBatch";
455 var prepareAutoBatched = () => (payload) => ({
456 payload,
457 meta: {
458 [SHOULD_AUTOBATCH]: true
459 }
460 });
461 var createQueueWithTimer = (timeout) => {
462 return (notify) => {
463 setTimeout(notify, timeout);
464 };
465 };
466 var autoBatchEnhancer = (options = {
467 type: "raf"
468 }) => (next) => (...args) => {
469 const store = next(...args);
470 let notifying = true;
471 let shouldNotifyAtEndOfTick = false;
472 let notificationQueued = false;
473 const listeners = /* @__PURE__ */ new Set();
474 const queueCallback = options.type === "tick" ? queueMicrotask : options.type === "raf" ? (
475 // requestAnimationFrame won't exist in SSR environments. Fall back to a vague approximation just to keep from erroring.
476 typeof window !== "undefined" && window.requestAnimationFrame ? window.requestAnimationFrame : createQueueWithTimer(10)
477 ) : options.type === "callback" ? options.queueNotification : createQueueWithTimer(options.timeout);
478 const notifyListeners = () => {
479 notificationQueued = false;
480 if (shouldNotifyAtEndOfTick) {
481 shouldNotifyAtEndOfTick = false;
482 listeners.forEach((l) => l());
483 }
484 };
485 return Object.assign({}, store, {
486 // Override the base `store.subscribe` method to keep original listeners
487 // from running if we're delaying notifications
488 subscribe(listener2) {
489 const wrappedListener = () => notifying && listener2();
490 const unsubscribe = store.subscribe(wrappedListener);
491 listeners.add(listener2);
492 return () => {
493 unsubscribe();
494 listeners.delete(listener2);
495 };
496 },
497 // Override the base `store.dispatch` method so that we can check actions
498 // for the `shouldAutoBatch` flag and determine if batching is active
499 dispatch(action) {
500 try {
501 notifying = !action?.meta?.[SHOULD_AUTOBATCH];
502 shouldNotifyAtEndOfTick = !notifying;
503 if (shouldNotifyAtEndOfTick) {
504 if (!notificationQueued) {
505 notificationQueued = true;
506 queueCallback(notifyListeners);
507 }
508 }
509 return store.dispatch(action);
510 } finally {
511 notifying = true;
512 }
513 }
514 });
515 };
516
517 // src/getDefaultEnhancers.ts
518 var buildGetDefaultEnhancers = (middlewareEnhancer) => function getDefaultEnhancers(options) {
519 const {
520 autoBatch = true
521 } = options ?? {};
522 let enhancerArray = new Tuple(middlewareEnhancer);
523 if (autoBatch) {
524 enhancerArray.push(autoBatchEnhancer(typeof autoBatch === "object" ? autoBatch : void 0));
525 }
526 return enhancerArray;
527 };
528
529 // src/configureStore.ts
530 function configureStore(options) {
531 const getDefaultMiddleware = buildGetDefaultMiddleware();
532 const {
533 reducer = void 0,
534 middleware,
535 devTools = true,
536 preloadedState = void 0,
537 enhancers = void 0
538 } = options || {};
539 let rootReducer;
540 if (typeof reducer === "function") {
541 rootReducer = reducer;
542 } else if (isPlainObject2(reducer)) {
543 rootReducer = combineReducers(reducer);
544 } else {
545 throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(1) : "`reducer` is a required argument, and must be a function or an object of functions that can be passed to combineReducers");
546 }
547 if (process.env.NODE_ENV !== "production" && middleware && typeof middleware !== "function") {
548 throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(2) : "`middleware` field must be a callback");
549 }
550 let finalMiddleware;
551 if (typeof middleware === "function") {
552 finalMiddleware = middleware(getDefaultMiddleware);
553 if (process.env.NODE_ENV !== "production" && !Array.isArray(finalMiddleware)) {
554 throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(3) : "when using a middleware builder function, an array of middleware must be returned");
555 }
556 } else {
557 finalMiddleware = getDefaultMiddleware();
558 }
559 if (process.env.NODE_ENV !== "production" && finalMiddleware.some((item) => typeof item !== "function")) {
560 throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(4) : "each middleware provided to configureStore must be a function");
561 }
562 let finalCompose = compose2;
563 if (devTools) {
564 finalCompose = composeWithDevTools({
565 // Enable capture of stack traces for dispatched Redux actions
566 trace: process.env.NODE_ENV !== "production",
567 ...typeof devTools === "object" && devTools
568 });
569 }
570 const middlewareEnhancer = applyMiddleware(...finalMiddleware);
571 const getDefaultEnhancers = buildGetDefaultEnhancers(middlewareEnhancer);
572 if (process.env.NODE_ENV !== "production" && enhancers && typeof enhancers !== "function") {
573 throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(5) : "`enhancers` field must be a callback");
574 }
575 let storeEnhancers = typeof enhancers === "function" ? enhancers(getDefaultEnhancers) : getDefaultEnhancers();
576 if (process.env.NODE_ENV !== "production" && !Array.isArray(storeEnhancers)) {
577 throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(6) : "`enhancers` callback must return an array");
578 }
579 if (process.env.NODE_ENV !== "production" && storeEnhancers.some((item) => typeof item !== "function")) {
580 throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(7) : "each enhancer provided to configureStore must be a function");
581 }
582 if (process.env.NODE_ENV !== "production" && finalMiddleware.length && !storeEnhancers.includes(middlewareEnhancer)) {
583 console.error("middlewares were provided, but middleware enhancer was not included in final enhancers - make sure to call `getDefaultEnhancers`");
584 }
585 const composedEnhancer = finalCompose(...storeEnhancers);
586 return createStore(rootReducer, preloadedState, composedEnhancer);
587 }
588
589 // src/createReducer.ts
590 import { produce as createNextState2, isDraft as isDraft2, isDraftable as isDraftable2 } from "immer";
591
592 // src/mapBuilders.ts
593 function executeReducerBuilderCallback(builderCallback) {
594 const actionsMap = {};
595 const actionMatchers = [];
596 let defaultCaseReducer;
597 const builder = {
598 addCase(typeOrActionCreator, reducer) {
599 if (process.env.NODE_ENV !== "production") {
600 if (actionMatchers.length > 0) {
601 throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(26) : "`builder.addCase` should only be called before calling `builder.addMatcher`");
602 }
603 if (defaultCaseReducer) {
604 throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(27) : "`builder.addCase` should only be called before calling `builder.addDefaultCase`");
605 }
606 }
607 const type = typeof typeOrActionCreator === "string" ? typeOrActionCreator : typeOrActionCreator.type;
608 if (!type) {
609 throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(28) : "`builder.addCase` cannot be called with an empty action type");
610 }
611 if (type in actionsMap) {
612 throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(29) : `\`builder.addCase\` cannot be called with two reducers for the same action type '${type}'`);
613 }
614 actionsMap[type] = reducer;
615 return builder;
616 },
617 addMatcher(matcher, reducer) {
618 if (process.env.NODE_ENV !== "production") {
619 if (defaultCaseReducer) {
620 throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(30) : "`builder.addMatcher` should only be called before calling `builder.addDefaultCase`");
621 }
622 }
623 actionMatchers.push({
624 matcher,
625 reducer
626 });
627 return builder;
628 },
629 addDefaultCase(reducer) {
630 if (process.env.NODE_ENV !== "production") {
631 if (defaultCaseReducer) {
632 throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(31) : "`builder.addDefaultCase` can only be called once");
633 }
634 }
635 defaultCaseReducer = reducer;
636 return builder;
637 }
638 };
639 builderCallback(builder);
640 return [actionsMap, actionMatchers, defaultCaseReducer];
641 }
642
643 // src/createReducer.ts
644 function isStateFunction(x) {
645 return typeof x === "function";
646 }
647 function createReducer(initialState, mapOrBuilderCallback) {
648 if (process.env.NODE_ENV !== "production") {
649 if (typeof mapOrBuilderCallback === "object") {
650 throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(8) : "The object notation for `createReducer` has been removed. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createReducer");
651 }
652 }
653 let [actionsMap, finalActionMatchers, finalDefaultCaseReducer] = executeReducerBuilderCallback(mapOrBuilderCallback);
654 let getInitialState;
655 if (isStateFunction(initialState)) {
656 getInitialState = () => freezeDraftable(initialState());
657 } else {
658 const frozenInitialState = freezeDraftable(initialState);
659 getInitialState = () => frozenInitialState;
660 }
661 function reducer(state = getInitialState(), action) {
662 let caseReducers = [actionsMap[action.type], ...finalActionMatchers.filter(({
663 matcher
664 }) => matcher(action)).map(({
665 reducer: reducer2
666 }) => reducer2)];
667 if (caseReducers.filter((cr) => !!cr).length === 0) {
668 caseReducers = [finalDefaultCaseReducer];
669 }
670 return caseReducers.reduce((previousState, caseReducer) => {
671 if (caseReducer) {
672 if (isDraft2(previousState)) {
673 const draft = previousState;
674 const result = caseReducer(draft, action);
675 if (result === void 0) {
676 return previousState;
677 }
678 return result;
679 } else if (!isDraftable2(previousState)) {
680 const result = caseReducer(previousState, action);
681 if (result === void 0) {
682 if (previousState === null) {
683 return previousState;
684 }
685 throw Error("A case reducer on a non-draftable value must not return undefined");
686 }
687 return result;
688 } else {
689 return createNextState2(previousState, (draft) => {
690 return caseReducer(draft, action);
691 });
692 }
693 }
694 return previousState;
695 }, state);
696 }
697 reducer.getInitialState = getInitialState;
698 return reducer;
699 }
700
701 // src/matchers.ts
702 var matches = (matcher, action) => {
703 if (hasMatchFunction(matcher)) {
704 return matcher.match(action);
705 } else {
706 return matcher(action);
707 }
708 };
709 function isAnyOf(...matchers) {
710 return (action) => {
711 return matchers.some((matcher) => matches(matcher, action));
712 };
713 }
714 function isAllOf(...matchers) {
715 return (action) => {
716 return matchers.every((matcher) => matches(matcher, action));
717 };
718 }
719 function hasExpectedRequestMetadata(action, validStatus) {
720 if (!action || !action.meta) return false;
721 const hasValidRequestId = typeof action.meta.requestId === "string";
722 const hasValidRequestStatus = validStatus.indexOf(action.meta.requestStatus) > -1;
723 return hasValidRequestId && hasValidRequestStatus;
724 }
725 function isAsyncThunkArray(a) {
726 return typeof a[0] === "function" && "pending" in a[0] && "fulfilled" in a[0] && "rejected" in a[0];
727 }
728 function isPending(...asyncThunks) {
729 if (asyncThunks.length === 0) {
730 return (action) => hasExpectedRequestMetadata(action, ["pending"]);
731 }
732 if (!isAsyncThunkArray(asyncThunks)) {
733 return isPending()(asyncThunks[0]);
734 }
735 return isAnyOf(...asyncThunks.map((asyncThunk) => asyncThunk.pending));
736 }
737 function isRejected(...asyncThunks) {
738 if (asyncThunks.length === 0) {
739 return (action) => hasExpectedRequestMetadata(action, ["rejected"]);
740 }
741 if (!isAsyncThunkArray(asyncThunks)) {
742 return isRejected()(asyncThunks[0]);
743 }
744 return isAnyOf(...asyncThunks.map((asyncThunk) => asyncThunk.rejected));
745 }
746 function isRejectedWithValue(...asyncThunks) {
747 const hasFlag = (action) => {
748 return action && action.meta && action.meta.rejectedWithValue;
749 };
750 if (asyncThunks.length === 0) {
751 return isAllOf(isRejected(...asyncThunks), hasFlag);
752 }
753 if (!isAsyncThunkArray(asyncThunks)) {
754 return isRejectedWithValue()(asyncThunks[0]);
755 }
756 return isAllOf(isRejected(...asyncThunks), hasFlag);
757 }
758 function isFulfilled(...asyncThunks) {
759 if (asyncThunks.length === 0) {
760 return (action) => hasExpectedRequestMetadata(action, ["fulfilled"]);
761 }
762 if (!isAsyncThunkArray(asyncThunks)) {
763 return isFulfilled()(asyncThunks[0]);
764 }
765 return isAnyOf(...asyncThunks.map((asyncThunk) => asyncThunk.fulfilled));
766 }
767 function isAsyncThunkAction(...asyncThunks) {
768 if (asyncThunks.length === 0) {
769 return (action) => hasExpectedRequestMetadata(action, ["pending", "fulfilled", "rejected"]);
770 }
771 if (!isAsyncThunkArray(asyncThunks)) {
772 return isAsyncThunkAction()(asyncThunks[0]);
773 }
774 return isAnyOf(...asyncThunks.flatMap((asyncThunk) => [asyncThunk.pending, asyncThunk.rejected, asyncThunk.fulfilled]));
775 }
776
777 // src/nanoid.ts
778 var urlAlphabet = "ModuleSymbhasOwnPr-0123456789ABCDEFGHNRVfgctiUvz_KqYTJkLxpZXIjQW";
779 var nanoid = (size = 21) => {
780 let id = "";
781 let i = size;
782 while (i--) {
783 id += urlAlphabet[Math.random() * 64 | 0];
784 }
785 return id;
786 };
787
788 // src/createAsyncThunk.ts
789 var commonProperties = ["name", "message", "stack", "code"];
790 var RejectWithValue = class {
791 constructor(payload, meta) {
792 this.payload = payload;
793 this.meta = meta;
794 }
795 /*
796 type-only property to distinguish between RejectWithValue and FulfillWithMeta
797 does not exist at runtime
798 */
799 _type;
800 };
801 var FulfillWithMeta = class {
802 constructor(payload, meta) {
803 this.payload = payload;
804 this.meta = meta;
805 }
806 /*
807 type-only property to distinguish between RejectWithValue and FulfillWithMeta
808 does not exist at runtime
809 */
810 _type;
811 };
812 var miniSerializeError = (value) => {
813 if (typeof value === "object" && value !== null) {
814 const simpleError = {};
815 for (const property of commonProperties) {
816 if (typeof value[property] === "string") {
817 simpleError[property] = value[property];
818 }
819 }
820 return simpleError;
821 }
822 return {
823 message: String(value)
824 };
825 };
826 var externalAbortMessage = "External signal was aborted";
827 var createAsyncThunk = /* @__PURE__ */ (() => {
828 function createAsyncThunk2(typePrefix, payloadCreator, options) {
829 const fulfilled = createAction(typePrefix + "/fulfilled", (payload, requestId, arg, meta) => ({
830 payload,
831 meta: {
832 ...meta || {},
833 arg,
834 requestId,
835 requestStatus: "fulfilled"
836 }
837 }));
838 const pending = createAction(typePrefix + "/pending", (requestId, arg, meta) => ({
839 payload: void 0,
840 meta: {
841 ...meta || {},
842 arg,
843 requestId,
844 requestStatus: "pending"
845 }
846 }));
847 const rejected = createAction(typePrefix + "/rejected", (error, requestId, arg, payload, meta) => ({
848 payload,
849 error: (options && options.serializeError || miniSerializeError)(error || "Rejected"),
850 meta: {
851 ...meta || {},
852 arg,
853 requestId,
854 rejectedWithValue: !!payload,
855 requestStatus: "rejected",
856 aborted: error?.name === "AbortError",
857 condition: error?.name === "ConditionError"
858 }
859 }));
860 function actionCreator(arg, {
861 signal
862 } = {}) {
863 return (dispatch, getState, extra) => {
864 const requestId = options?.idGenerator ? options.idGenerator(arg) : nanoid();
865 const abortController = new AbortController();
866 let abortHandler;
867 let abortReason;
868 function abort(reason) {
869 abortReason = reason;
870 abortController.abort();
871 }
872 if (signal) {
873 if (signal.aborted) {
874 abort(externalAbortMessage);
875 } else {
876 signal.addEventListener("abort", () => abort(externalAbortMessage), {
877 once: true
878 });
879 }
880 }
881 const promise = async function() {
882 let finalAction;
883 try {
884 let conditionResult = options?.condition?.(arg, {
885 getState,
886 extra
887 });
888 if (isThenable(conditionResult)) {
889 conditionResult = await conditionResult;
890 }
891 if (conditionResult === false || abortController.signal.aborted) {
892 throw {
893 name: "ConditionError",
894 message: "Aborted due to condition callback returning false."
895 };
896 }
897 const abortedPromise = new Promise((_, reject) => {
898 abortHandler = () => {
899 reject({
900 name: "AbortError",
901 message: abortReason || "Aborted"
902 });
903 };
904 abortController.signal.addEventListener("abort", abortHandler);
905 });
906 dispatch(pending(requestId, arg, options?.getPendingMeta?.({
907 requestId,
908 arg
909 }, {
910 getState,
911 extra
912 })));
913 finalAction = await Promise.race([abortedPromise, Promise.resolve(payloadCreator(arg, {
914 dispatch,
915 getState,
916 extra,
917 requestId,
918 signal: abortController.signal,
919 abort,
920 rejectWithValue: (value, meta) => {
921 return new RejectWithValue(value, meta);
922 },
923 fulfillWithValue: (value, meta) => {
924 return new FulfillWithMeta(value, meta);
925 }
926 })).then((result) => {
927 if (result instanceof RejectWithValue) {
928 throw result;
929 }
930 if (result instanceof FulfillWithMeta) {
931 return fulfilled(result.payload, requestId, arg, result.meta);
932 }
933 return fulfilled(result, requestId, arg);
934 })]);
935 } catch (err) {
936 finalAction = err instanceof RejectWithValue ? rejected(null, requestId, arg, err.payload, err.meta) : rejected(err, requestId, arg);
937 } finally {
938 if (abortHandler) {
939 abortController.signal.removeEventListener("abort", abortHandler);
940 }
941 }
942 const skipDispatch = options && !options.dispatchConditionRejection && rejected.match(finalAction) && finalAction.meta.condition;
943 if (!skipDispatch) {
944 dispatch(finalAction);
945 }
946 return finalAction;
947 }();
948 return Object.assign(promise, {
949 abort,
950 requestId,
951 arg,
952 unwrap() {
953 return promise.then(unwrapResult);
954 }
955 });
956 };
957 }
958 return Object.assign(actionCreator, {
959 pending,
960 rejected,
961 fulfilled,
962 settled: isAnyOf(rejected, fulfilled),
963 typePrefix
964 });
965 }
966 createAsyncThunk2.withTypes = () => createAsyncThunk2;
967 return createAsyncThunk2;
968 })();
969 function unwrapResult(action) {
970 if (action.meta && action.meta.rejectedWithValue) {
971 throw action.payload;
972 }
973 if (action.error) {
974 throw action.error;
975 }
976 return action.payload;
977 }
978 function isThenable(value) {
979 return value !== null && typeof value === "object" && typeof value.then === "function";
980 }
981
982 // src/createSlice.ts
983 var asyncThunkSymbol = /* @__PURE__ */ Symbol.for("rtk-slice-createasyncthunk");
984 var asyncThunkCreator = {
985 [asyncThunkSymbol]: createAsyncThunk
986 };
987 var ReducerType = /* @__PURE__ */ ((ReducerType2) => {
988 ReducerType2["reducer"] = "reducer";
989 ReducerType2["reducerWithPrepare"] = "reducerWithPrepare";
990 ReducerType2["asyncThunk"] = "asyncThunk";
991 return ReducerType2;
992 })(ReducerType || {});
993 function getType(slice, actionKey) {
994 return `${slice}/${actionKey}`;
995 }
996 function buildCreateSlice({
997 creators
998 } = {}) {
999 const cAT = creators?.asyncThunk?.[asyncThunkSymbol];
1000 return function createSlice2(options) {
1001 const {
1002 name,
1003 reducerPath = name
1004 } = options;
1005 if (!name) {
1006 throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(11) : "`name` is a required option for createSlice");
1007 }
1008 if (typeof process !== "undefined" && process.env.NODE_ENV === "development") {
1009 if (options.initialState === void 0) {
1010 console.error("You must provide an `initialState` value that is not `undefined`. You may have misspelled `initialState`");
1011 }
1012 }
1013 const reducers = (typeof options.reducers === "function" ? options.reducers(buildReducerCreators()) : options.reducers) || {};
1014 const reducerNames = Object.keys(reducers);
1015 const context = {
1016 sliceCaseReducersByName: {},
1017 sliceCaseReducersByType: {},
1018 actionCreators: {},
1019 sliceMatchers: []
1020 };
1021 const contextMethods = {
1022 addCase(typeOrActionCreator, reducer2) {
1023 const type = typeof typeOrActionCreator === "string" ? typeOrActionCreator : typeOrActionCreator.type;
1024 if (!type) {
1025 throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(12) : "`context.addCase` cannot be called with an empty action type");
1026 }
1027 if (type in context.sliceCaseReducersByType) {
1028 throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(13) : "`context.addCase` cannot be called with two reducers for the same action type: " + type);
1029 }
1030 context.sliceCaseReducersByType[type] = reducer2;
1031 return contextMethods;
1032 },
1033 addMatcher(matcher, reducer2) {
1034 context.sliceMatchers.push({
1035 matcher,
1036 reducer: reducer2
1037 });
1038 return contextMethods;
1039 },
1040 exposeAction(name2, actionCreator) {
1041 context.actionCreators[name2] = actionCreator;
1042 return contextMethods;
1043 },
1044 exposeCaseReducer(name2, reducer2) {
1045 context.sliceCaseReducersByName[name2] = reducer2;
1046 return contextMethods;
1047 }
1048 };
1049 reducerNames.forEach((reducerName) => {
1050 const reducerDefinition = reducers[reducerName];
1051 const reducerDetails = {
1052 reducerName,
1053 type: getType(name, reducerName),
1054 createNotation: typeof options.reducers === "function"
1055 };
1056 if (isAsyncThunkSliceReducerDefinition(reducerDefinition)) {
1057 handleThunkCaseReducerDefinition(reducerDetails, reducerDefinition, contextMethods, cAT);
1058 } else {
1059 handleNormalReducerDefinition(reducerDetails, reducerDefinition, contextMethods);
1060 }
1061 });
1062 function buildReducer() {
1063 if (process.env.NODE_ENV !== "production") {
1064 if (typeof options.extraReducers === "object") {
1065 throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(14) : "The object notation for `createSlice.extraReducers` has been removed. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createSlice");
1066 }
1067 }
1068 const [extraReducers = {}, actionMatchers = [], defaultCaseReducer = void 0] = typeof options.extraReducers === "function" ? executeReducerBuilderCallback(options.extraReducers) : [options.extraReducers];
1069 const finalCaseReducers = {
1070 ...extraReducers,
1071 ...context.sliceCaseReducersByType
1072 };
1073 return createReducer(options.initialState, (builder) => {
1074 for (let key in finalCaseReducers) {
1075 builder.addCase(key, finalCaseReducers[key]);
1076 }
1077 for (let sM of context.sliceMatchers) {
1078 builder.addMatcher(sM.matcher, sM.reducer);
1079 }
1080 for (let m of actionMatchers) {
1081 builder.addMatcher(m.matcher, m.reducer);
1082 }
1083 if (defaultCaseReducer) {
1084 builder.addDefaultCase(defaultCaseReducer);
1085 }
1086 });
1087 }
1088 const selectSelf = (state) => state;
1089 const injectedSelectorCache = /* @__PURE__ */ new Map();
1090 let _reducer;
1091 function reducer(state, action) {
1092 if (!_reducer) _reducer = buildReducer();
1093 return _reducer(state, action);
1094 }
1095 function getInitialState() {
1096 if (!_reducer) _reducer = buildReducer();
1097 return _reducer.getInitialState();
1098 }
1099 function makeSelectorProps(reducerPath2, injected = false) {
1100 function selectSlice(state) {
1101 let sliceState = state[reducerPath2];
1102 if (typeof sliceState === "undefined") {
1103 if (injected) {
1104 sliceState = getInitialState();
1105 } else if (process.env.NODE_ENV !== "production") {
1106 throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(15) : "selectSlice returned undefined for an uninjected slice reducer");
1107 }
1108 }
1109 return sliceState;
1110 }
1111 function getSelectors(selectState = selectSelf) {
1112 const selectorCache = getOrInsertComputed(injectedSelectorCache, injected, () => /* @__PURE__ */ new WeakMap());
1113 return getOrInsertComputed(selectorCache, selectState, () => {
1114 const map = {};
1115 for (const [name2, selector] of Object.entries(options.selectors ?? {})) {
1116 map[name2] = wrapSelector(selector, selectState, getInitialState, injected);
1117 }
1118 return map;
1119 });
1120 }
1121 return {
1122 reducerPath: reducerPath2,
1123 getSelectors,
1124 get selectors() {
1125 return getSelectors(selectSlice);
1126 },
1127 selectSlice
1128 };
1129 }
1130 const slice = {
1131 name,
1132 reducer,
1133 actions: context.actionCreators,
1134 caseReducers: context.sliceCaseReducersByName,
1135 getInitialState,
1136 ...makeSelectorProps(reducerPath),
1137 injectInto(injectable, {
1138 reducerPath: pathOpt,
1139 ...config
1140 } = {}) {
1141 const newReducerPath = pathOpt ?? reducerPath;
1142 injectable.inject({
1143 reducerPath: newReducerPath,
1144 reducer
1145 }, config);
1146 return {
1147 ...slice,
1148 ...makeSelectorProps(newReducerPath, true)
1149 };
1150 }
1151 };
1152 return slice;
1153 };
1154 }
1155 function wrapSelector(selector, selectState, getInitialState, injected) {
1156 function wrapper(rootState, ...args) {
1157 let sliceState = selectState(rootState);
1158 if (typeof sliceState === "undefined") {
1159 if (injected) {
1160 sliceState = getInitialState();
1161 } else if (process.env.NODE_ENV !== "production") {
1162 throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(16) : "selectState returned undefined for an uninjected slice reducer");
1163 }
1164 }
1165 return selector(sliceState, ...args);
1166 }
1167 wrapper.unwrapped = selector;
1168 return wrapper;
1169 }
1170 var createSlice = /* @__PURE__ */ buildCreateSlice();
1171 function buildReducerCreators() {
1172 function asyncThunk(payloadCreator, config) {
1173 return {
1174 _reducerDefinitionType: "asyncThunk" /* asyncThunk */,
1175 payloadCreator,
1176 ...config
1177 };
1178 }
1179 asyncThunk.withTypes = () => asyncThunk;
1180 return {
1181 reducer(caseReducer) {
1182 return Object.assign({
1183 // hack so the wrapping function has the same name as the original
1184 // we need to create a wrapper so the `reducerDefinitionType` is not assigned to the original
1185 [caseReducer.name](...args) {
1186 return caseReducer(...args);
1187 }
1188 }[caseReducer.name], {
1189 _reducerDefinitionType: "reducer" /* reducer */
1190 });
1191 },
1192 preparedReducer(prepare, reducer) {
1193 return {
1194 _reducerDefinitionType: "reducerWithPrepare" /* reducerWithPrepare */,
1195 prepare,
1196 reducer
1197 };
1198 },
1199 asyncThunk
1200 };
1201 }
1202 function handleNormalReducerDefinition({
1203 type,
1204 reducerName,
1205 createNotation
1206 }, maybeReducerWithPrepare, context) {
1207 let caseReducer;
1208 let prepareCallback;
1209 if ("reducer" in maybeReducerWithPrepare) {
1210 if (createNotation && !isCaseReducerWithPrepareDefinition(maybeReducerWithPrepare)) {
1211 throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(17) : "Please use the `create.preparedReducer` notation for prepared action creators with the `create` notation.");
1212 }
1213 caseReducer = maybeReducerWithPrepare.reducer;
1214 prepareCallback = maybeReducerWithPrepare.prepare;
1215 } else {
1216 caseReducer = maybeReducerWithPrepare;
1217 }
1218 context.addCase(type, caseReducer).exposeCaseReducer(reducerName, caseReducer).exposeAction(reducerName, prepareCallback ? createAction(type, prepareCallback) : createAction(type));
1219 }
1220 function isAsyncThunkSliceReducerDefinition(reducerDefinition) {
1221 return reducerDefinition._reducerDefinitionType === "asyncThunk" /* asyncThunk */;
1222 }
1223 function isCaseReducerWithPrepareDefinition(reducerDefinition) {
1224 return reducerDefinition._reducerDefinitionType === "reducerWithPrepare" /* reducerWithPrepare */;
1225 }
1226 function handleThunkCaseReducerDefinition({
1227 type,
1228 reducerName
1229 }, reducerDefinition, context, cAT) {
1230 if (!cAT) {
1231 throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(18) : "Cannot use `create.asyncThunk` in the built-in `createSlice`. Use `buildCreateSlice({ creators: { asyncThunk: asyncThunkCreator } })` to create a customised version of `createSlice`.");
1232 }
1233 const {
1234 payloadCreator,
1235 fulfilled,
1236 pending,
1237 rejected,
1238 settled,
1239 options
1240 } = reducerDefinition;
1241 const thunk = cAT(type, payloadCreator, options);
1242 context.exposeAction(reducerName, thunk);
1243 if (fulfilled) {
1244 context.addCase(thunk.fulfilled, fulfilled);
1245 }
1246 if (pending) {
1247 context.addCase(thunk.pending, pending);
1248 }
1249 if (rejected) {
1250 context.addCase(thunk.rejected, rejected);
1251 }
1252 if (settled) {
1253 context.addMatcher(thunk.settled, settled);
1254 }
1255 context.exposeCaseReducer(reducerName, {
1256 fulfilled: fulfilled || noop,
1257 pending: pending || noop,
1258 rejected: rejected || noop,
1259 settled: settled || noop
1260 });
1261 }
1262 function noop() {
1263 }
1264
1265 // src/entities/entity_state.ts
1266 function getInitialEntityState() {
1267 return {
1268 ids: [],
1269 entities: {}
1270 };
1271 }
1272 function createInitialStateFactory(stateAdapter) {
1273 function getInitialState(additionalState = {}, entities) {
1274 const state = Object.assign(getInitialEntityState(), additionalState);
1275 return entities ? stateAdapter.setAll(state, entities) : state;
1276 }
1277 return {
1278 getInitialState
1279 };
1280 }
1281
1282 // src/entities/state_selectors.ts
1283 function createSelectorsFactory() {
1284 function getSelectors(selectState, options = {}) {
1285 const {
1286 createSelector: createSelector2 = createDraftSafeSelector
1287 } = options;
1288 const selectIds = (state) => state.ids;
1289 const selectEntities = (state) => state.entities;
1290 const selectAll = createSelector2(selectIds, selectEntities, (ids, entities) => ids.map((id) => entities[id]));
1291 const selectId = (_, id) => id;
1292 const selectById = (entities, id) => entities[id];
1293 const selectTotal = createSelector2(selectIds, (ids) => ids.length);
1294 if (!selectState) {
1295 return {
1296 selectIds,
1297 selectEntities,
1298 selectAll,
1299 selectTotal,
1300 selectById: createSelector2(selectEntities, selectId, selectById)
1301 };
1302 }
1303 const selectGlobalizedEntities = createSelector2(selectState, selectEntities);
1304 return {
1305 selectIds: createSelector2(selectState, selectIds),
1306 selectEntities: selectGlobalizedEntities,
1307 selectAll: createSelector2(selectState, selectAll),
1308 selectTotal: createSelector2(selectState, selectTotal),
1309 selectById: createSelector2(selectGlobalizedEntities, selectId, selectById)
1310 };
1311 }
1312 return {
1313 getSelectors
1314 };
1315 }
1316
1317 // src/entities/state_adapter.ts
1318 import { produce as createNextState3, isDraft as isDraft3 } from "immer";
1319 var isDraftTyped = isDraft3;
1320 function createSingleArgumentStateOperator(mutator) {
1321 const operator = createStateOperator((_, state) => mutator(state));
1322 return function operation(state) {
1323 return operator(state, void 0);
1324 };
1325 }
1326 function createStateOperator(mutator) {
1327 return function operation(state, arg) {
1328 function isPayloadActionArgument(arg2) {
1329 return isFSA(arg2);
1330 }
1331 const runMutator = (draft) => {
1332 if (isPayloadActionArgument(arg)) {
1333 mutator(arg.payload, draft);
1334 } else {
1335 mutator(arg, draft);
1336 }
1337 };
1338 if (isDraftTyped(state)) {
1339 runMutator(state);
1340 return state;
1341 }
1342 return createNextState3(state, runMutator);
1343 };
1344 }
1345
1346 // src/entities/utils.ts
1347 import { current as current2, isDraft as isDraft4 } from "immer";
1348 function selectIdValue(entity, selectId) {
1349 const key = selectId(entity);
1350 if (process.env.NODE_ENV !== "production" && key === void 0) {
1351 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());
1352 }
1353 return key;
1354 }
1355 function ensureEntitiesArray(entities) {
1356 if (!Array.isArray(entities)) {
1357 entities = Object.values(entities);
1358 }
1359 return entities;
1360 }
1361 function getCurrent(value) {
1362 return isDraft4(value) ? current2(value) : value;
1363 }
1364 function splitAddedUpdatedEntities(newEntities, selectId, state) {
1365 newEntities = ensureEntitiesArray(newEntities);
1366 const existingIdsArray = getCurrent(state.ids);
1367 const existingIds = new Set(existingIdsArray);
1368 const added = [];
1369 const updated = [];
1370 for (const entity of newEntities) {
1371 const id = selectIdValue(entity, selectId);
1372 if (existingIds.has(id)) {
1373 updated.push({
1374 id,
1375 changes: entity
1376 });
1377 } else {
1378 added.push(entity);
1379 }
1380 }
1381 return [added, updated, existingIdsArray];
1382 }
1383
1384 // src/entities/unsorted_state_adapter.ts
1385 function createUnsortedStateAdapter(selectId) {
1386 function addOneMutably(entity, state) {
1387 const key = selectIdValue(entity, selectId);
1388 if (key in state.entities) {
1389 return;
1390 }
1391 state.ids.push(key);
1392 state.entities[key] = entity;
1393 }
1394 function addManyMutably(newEntities, state) {
1395 newEntities = ensureEntitiesArray(newEntities);
1396 for (const entity of newEntities) {
1397 addOneMutably(entity, state);
1398 }
1399 }
1400 function setOneMutably(entity, state) {
1401 const key = selectIdValue(entity, selectId);
1402 if (!(key in state.entities)) {
1403 state.ids.push(key);
1404 }
1405 ;
1406 state.entities[key] = entity;
1407 }
1408 function setManyMutably(newEntities, state) {
1409 newEntities = ensureEntitiesArray(newEntities);
1410 for (const entity of newEntities) {
1411 setOneMutably(entity, state);
1412 }
1413 }
1414 function setAllMutably(newEntities, state) {
1415 newEntities = ensureEntitiesArray(newEntities);
1416 state.ids = [];
1417 state.entities = {};
1418 addManyMutably(newEntities, state);
1419 }
1420 function removeOneMutably(key, state) {
1421 return removeManyMutably([key], state);
1422 }
1423 function removeManyMutably(keys, state) {
1424 let didMutate = false;
1425 keys.forEach((key) => {
1426 if (key in state.entities) {
1427 delete state.entities[key];
1428 didMutate = true;
1429 }
1430 });
1431 if (didMutate) {
1432 state.ids = state.ids.filter((id) => id in state.entities);
1433 }
1434 }
1435 function removeAllMutably(state) {
1436 Object.assign(state, {
1437 ids: [],
1438 entities: {}
1439 });
1440 }
1441 function takeNewKey(keys, update, state) {
1442 const original3 = state.entities[update.id];
1443 if (original3 === void 0) {
1444 return false;
1445 }
1446 const updated = Object.assign({}, original3, update.changes);
1447 const newKey = selectIdValue(updated, selectId);
1448 const hasNewKey = newKey !== update.id;
1449 if (hasNewKey) {
1450 keys[update.id] = newKey;
1451 delete state.entities[update.id];
1452 }
1453 ;
1454 state.entities[newKey] = updated;
1455 return hasNewKey;
1456 }
1457 function updateOneMutably(update, state) {
1458 return updateManyMutably([update], state);
1459 }
1460 function updateManyMutably(updates, state) {
1461 const newKeys = {};
1462 const updatesPerEntity = {};
1463 updates.forEach((update) => {
1464 if (update.id in state.entities) {
1465 updatesPerEntity[update.id] = {
1466 id: update.id,
1467 // Spreads ignore falsy values, so this works even if there isn't
1468 // an existing update already at this key
1469 changes: {
1470 ...updatesPerEntity[update.id]?.changes,
1471 ...update.changes
1472 }
1473 };
1474 }
1475 });
1476 updates = Object.values(updatesPerEntity);
1477 const didMutateEntities = updates.length > 0;
1478 if (didMutateEntities) {
1479 const didMutateIds = updates.filter((update) => takeNewKey(newKeys, update, state)).length > 0;
1480 if (didMutateIds) {
1481 state.ids = Object.values(state.entities).map((e) => selectIdValue(e, selectId));
1482 }
1483 }
1484 }
1485 function upsertOneMutably(entity, state) {
1486 return upsertManyMutably([entity], state);
1487 }
1488 function upsertManyMutably(newEntities, state) {
1489 const [added, updated] = splitAddedUpdatedEntities(newEntities, selectId, state);
1490 updateManyMutably(updated, state);
1491 addManyMutably(added, state);
1492 }
1493 return {
1494 removeAll: createSingleArgumentStateOperator(removeAllMutably),
1495 addOne: createStateOperator(addOneMutably),
1496 addMany: createStateOperator(addManyMutably),
1497 setOne: createStateOperator(setOneMutably),
1498 setMany: createStateOperator(setManyMutably),
1499 setAll: createStateOperator(setAllMutably),
1500 updateOne: createStateOperator(updateOneMutably),
1501 updateMany: createStateOperator(updateManyMutably),
1502 upsertOne: createStateOperator(upsertOneMutably),
1503 upsertMany: createStateOperator(upsertManyMutably),
1504 removeOne: createStateOperator(removeOneMutably),
1505 removeMany: createStateOperator(removeManyMutably)
1506 };
1507 }
1508
1509 // src/entities/sorted_state_adapter.ts
1510 function findInsertIndex(sortedItems, item, comparisonFunction) {
1511 let lowIndex = 0;
1512 let highIndex = sortedItems.length;
1513 while (lowIndex < highIndex) {
1514 let middleIndex = lowIndex + highIndex >>> 1;
1515 const currentItem = sortedItems[middleIndex];
1516 const res = comparisonFunction(item, currentItem);
1517 if (res >= 0) {
1518 lowIndex = middleIndex + 1;
1519 } else {
1520 highIndex = middleIndex;
1521 }
1522 }
1523 return lowIndex;
1524 }
1525 function insert(sortedItems, item, comparisonFunction) {
1526 const insertAtIndex = findInsertIndex(sortedItems, item, comparisonFunction);
1527 sortedItems.splice(insertAtIndex, 0, item);
1528 return sortedItems;
1529 }
1530 function createSortedStateAdapter(selectId, comparer) {
1531 const {
1532 removeOne,
1533 removeMany,
1534 removeAll
1535 } = createUnsortedStateAdapter(selectId);
1536 function addOneMutably(entity, state) {
1537 return addManyMutably([entity], state);
1538 }
1539 function addManyMutably(newEntities, state, existingIds) {
1540 newEntities = ensureEntitiesArray(newEntities);
1541 const existingKeys = new Set(existingIds ?? getCurrent(state.ids));
1542 const models = newEntities.filter((model) => !existingKeys.has(selectIdValue(model, selectId)));
1543 if (models.length !== 0) {
1544 mergeFunction(state, models);
1545 }
1546 }
1547 function setOneMutably(entity, state) {
1548 return setManyMutably([entity], state);
1549 }
1550 function setManyMutably(newEntities, state) {
1551 newEntities = ensureEntitiesArray(newEntities);
1552 if (newEntities.length !== 0) {
1553 for (const item of newEntities) {
1554 delete state.entities[selectId(item)];
1555 }
1556 mergeFunction(state, newEntities);
1557 }
1558 }
1559 function setAllMutably(newEntities, state) {
1560 newEntities = ensureEntitiesArray(newEntities);
1561 state.entities = {};
1562 state.ids = [];
1563 addManyMutably(newEntities, state, []);
1564 }
1565 function updateOneMutably(update, state) {
1566 return updateManyMutably([update], state);
1567 }
1568 function updateManyMutably(updates, state) {
1569 let appliedUpdates = false;
1570 let replacedIds = false;
1571 for (let update of updates) {
1572 const entity = state.entities[update.id];
1573 if (!entity) {
1574 continue;
1575 }
1576 appliedUpdates = true;
1577 Object.assign(entity, update.changes);
1578 const newId = selectId(entity);
1579 if (update.id !== newId) {
1580 replacedIds = true;
1581 delete state.entities[update.id];
1582 const oldIndex = state.ids.indexOf(update.id);
1583 state.ids[oldIndex] = newId;
1584 state.entities[newId] = entity;
1585 }
1586 }
1587 if (appliedUpdates) {
1588 mergeFunction(state, [], appliedUpdates, replacedIds);
1589 }
1590 }
1591 function upsertOneMutably(entity, state) {
1592 return upsertManyMutably([entity], state);
1593 }
1594 function upsertManyMutably(newEntities, state) {
1595 const [added, updated, existingIdsArray] = splitAddedUpdatedEntities(newEntities, selectId, state);
1596 if (updated.length) {
1597 updateManyMutably(updated, state);
1598 }
1599 if (added.length) {
1600 addManyMutably(added, state, existingIdsArray);
1601 }
1602 }
1603 function areArraysEqual(a, b) {
1604 if (a.length !== b.length) {
1605 return false;
1606 }
1607 for (let i = 0; i < a.length; i++) {
1608 if (a[i] === b[i]) {
1609 continue;
1610 }
1611 return false;
1612 }
1613 return true;
1614 }
1615 const mergeFunction = (state, addedItems, appliedUpdates, replacedIds) => {
1616 const currentEntities = getCurrent(state.entities);
1617 const currentIds = getCurrent(state.ids);
1618 const stateEntities = state.entities;
1619 let ids = currentIds;
1620 if (replacedIds) {
1621 ids = new Set(currentIds);
1622 }
1623 let sortedEntities = [];
1624 for (const id of ids) {
1625 const entity = currentEntities[id];
1626 if (entity) {
1627 sortedEntities.push(entity);
1628 }
1629 }
1630 const wasPreviouslyEmpty = sortedEntities.length === 0;
1631 for (const item of addedItems) {
1632 stateEntities[selectId(item)] = item;
1633 if (!wasPreviouslyEmpty) {
1634 insert(sortedEntities, item, comparer);
1635 }
1636 }
1637 if (wasPreviouslyEmpty) {
1638 sortedEntities = addedItems.slice().sort(comparer);
1639 } else if (appliedUpdates) {
1640 sortedEntities.sort(comparer);
1641 }
1642 const newSortedIds = sortedEntities.map(selectId);
1643 if (!areArraysEqual(currentIds, newSortedIds)) {
1644 state.ids = newSortedIds;
1645 }
1646 };
1647 return {
1648 removeOne,
1649 removeMany,
1650 removeAll,
1651 addOne: createStateOperator(addOneMutably),
1652 updateOne: createStateOperator(updateOneMutably),
1653 upsertOne: createStateOperator(upsertOneMutably),
1654 setOne: createStateOperator(setOneMutably),
1655 setMany: createStateOperator(setManyMutably),
1656 setAll: createStateOperator(setAllMutably),
1657 addMany: createStateOperator(addManyMutably),
1658 updateMany: createStateOperator(updateManyMutably),
1659 upsertMany: createStateOperator(upsertManyMutably)
1660 };
1661 }
1662
1663 // src/entities/create_adapter.ts
1664 function createEntityAdapter(options = {}) {
1665 const {
1666 selectId,
1667 sortComparer
1668 } = {
1669 sortComparer: false,
1670 selectId: (instance) => instance.id,
1671 ...options
1672 };
1673 const stateAdapter = sortComparer ? createSortedStateAdapter(selectId, sortComparer) : createUnsortedStateAdapter(selectId);
1674 const stateFactory = createInitialStateFactory(stateAdapter);
1675 const selectorsFactory = createSelectorsFactory();
1676 return {
1677 selectId,
1678 sortComparer,
1679 ...stateFactory,
1680 ...selectorsFactory,
1681 ...stateAdapter
1682 };
1683 }
1684
1685 // src/listenerMiddleware/index.ts
1686 import { isAction as isAction3 } from "redux";
1687
1688 // src/listenerMiddleware/exceptions.ts
1689 var task = "task";
1690 var listener = "listener";
1691 var completed = "completed";
1692 var cancelled = "cancelled";
1693 var taskCancelled = `task-${cancelled}`;
1694 var taskCompleted = `task-${completed}`;
1695 var listenerCancelled = `${listener}-${cancelled}`;
1696 var listenerCompleted = `${listener}-${completed}`;
1697 var TaskAbortError = class {
1698 constructor(code) {
1699 this.code = code;
1700 this.message = `${task} ${cancelled} (reason: ${code})`;
1701 }
1702 name = "TaskAbortError";
1703 message;
1704 };
1705
1706 // src/listenerMiddleware/utils.ts
1707 var assertFunction = (func, expected) => {
1708 if (typeof func !== "function") {
1709 throw new TypeError(process.env.NODE_ENV === "production" ? formatProdErrorMessage(32) : `${expected} is not a function`);
1710 }
1711 };
1712 var noop2 = () => {
1713 };
1714 var catchRejection = (promise, onError = noop2) => {
1715 promise.catch(onError);
1716 return promise;
1717 };
1718 var addAbortSignalListener = (abortSignal, callback) => {
1719 abortSignal.addEventListener("abort", callback, {
1720 once: true
1721 });
1722 return () => abortSignal.removeEventListener("abort", callback);
1723 };
1724 var abortControllerWithReason = (abortController, reason) => {
1725 const signal = abortController.signal;
1726 if (signal.aborted) {
1727 return;
1728 }
1729 if (!("reason" in signal)) {
1730 Object.defineProperty(signal, "reason", {
1731 enumerable: true,
1732 value: reason,
1733 configurable: true,
1734 writable: true
1735 });
1736 }
1737 ;
1738 abortController.abort(reason);
1739 };
1740
1741 // src/listenerMiddleware/task.ts
1742 var validateActive = (signal) => {
1743 if (signal.aborted) {
1744 const {
1745 reason
1746 } = signal;
1747 throw new TaskAbortError(reason);
1748 }
1749 };
1750 function raceWithSignal(signal, promise) {
1751 let cleanup = noop2;
1752 return new Promise((resolve, reject) => {
1753 const notifyRejection = () => reject(new TaskAbortError(signal.reason));
1754 if (signal.aborted) {
1755 notifyRejection();
1756 return;
1757 }
1758 cleanup = addAbortSignalListener(signal, notifyRejection);
1759 promise.finally(() => cleanup()).then(resolve, reject);
1760 }).finally(() => {
1761 cleanup = noop2;
1762 });
1763 }
1764 var runTask = async (task2, cleanUp) => {
1765 try {
1766 await Promise.resolve();
1767 const value = await task2();
1768 return {
1769 status: "ok",
1770 value
1771 };
1772 } catch (error) {
1773 return {
1774 status: error instanceof TaskAbortError ? "cancelled" : "rejected",
1775 error
1776 };
1777 } finally {
1778 cleanUp?.();
1779 }
1780 };
1781 var createPause = (signal) => {
1782 return (promise) => {
1783 return catchRejection(raceWithSignal(signal, promise).then((output) => {
1784 validateActive(signal);
1785 return output;
1786 }));
1787 };
1788 };
1789 var createDelay = (signal) => {
1790 const pause = createPause(signal);
1791 return (timeoutMs) => {
1792 return pause(new Promise((resolve) => setTimeout(resolve, timeoutMs)));
1793 };
1794 };
1795
1796 // src/listenerMiddleware/index.ts
1797 var {
1798 assign
1799 } = Object;
1800 var INTERNAL_NIL_TOKEN = {};
1801 var alm = "listenerMiddleware";
1802 var createFork = (parentAbortSignal, parentBlockingPromises) => {
1803 const linkControllers = (controller) => addAbortSignalListener(parentAbortSignal, () => abortControllerWithReason(controller, parentAbortSignal.reason));
1804 return (taskExecutor, opts) => {
1805 assertFunction(taskExecutor, "taskExecutor");
1806 const childAbortController = new AbortController();
1807 linkControllers(childAbortController);
1808 const result = runTask(async () => {
1809 validateActive(parentAbortSignal);
1810 validateActive(childAbortController.signal);
1811 const result2 = await taskExecutor({
1812 pause: createPause(childAbortController.signal),
1813 delay: createDelay(childAbortController.signal),
1814 signal: childAbortController.signal
1815 });
1816 validateActive(childAbortController.signal);
1817 return result2;
1818 }, () => abortControllerWithReason(childAbortController, taskCompleted));
1819 if (opts?.autoJoin) {
1820 parentBlockingPromises.push(result.catch(noop2));
1821 }
1822 return {
1823 result: createPause(parentAbortSignal)(result),
1824 cancel() {
1825 abortControllerWithReason(childAbortController, taskCancelled);
1826 }
1827 };
1828 };
1829 };
1830 var createTakePattern = (startListening, signal) => {
1831 const take = async (predicate, timeout) => {
1832 validateActive(signal);
1833 let unsubscribe = () => {
1834 };
1835 const tuplePromise = new Promise((resolve, reject) => {
1836 let stopListening = startListening({
1837 predicate,
1838 effect: (action, listenerApi) => {
1839 listenerApi.unsubscribe();
1840 resolve([action, listenerApi.getState(), listenerApi.getOriginalState()]);
1841 }
1842 });
1843 unsubscribe = () => {
1844 stopListening();
1845 reject();
1846 };
1847 });
1848 const promises = [tuplePromise];
1849 if (timeout != null) {
1850 promises.push(new Promise((resolve) => setTimeout(resolve, timeout, null)));
1851 }
1852 try {
1853 const output = await raceWithSignal(signal, Promise.race(promises));
1854 validateActive(signal);
1855 return output;
1856 } finally {
1857 unsubscribe();
1858 }
1859 };
1860 return (predicate, timeout) => catchRejection(take(predicate, timeout));
1861 };
1862 var getListenerEntryPropsFrom = (options) => {
1863 let {
1864 type,
1865 actionCreator,
1866 matcher,
1867 predicate,
1868 effect
1869 } = options;
1870 if (type) {
1871 predicate = createAction(type).match;
1872 } else if (actionCreator) {
1873 type = actionCreator.type;
1874 predicate = actionCreator.match;
1875 } else if (matcher) {
1876 predicate = matcher;
1877 } else if (predicate) {
1878 } else {
1879 throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(21) : "Creating or removing a listener requires one of the known fields for matching an action");
1880 }
1881 assertFunction(effect, "options.listener");
1882 return {
1883 predicate,
1884 type,
1885 effect
1886 };
1887 };
1888 var createListenerEntry = /* @__PURE__ */ assign((options) => {
1889 const {
1890 type,
1891 predicate,
1892 effect
1893 } = getListenerEntryPropsFrom(options);
1894 const entry = {
1895 id: nanoid(),
1896 effect,
1897 type,
1898 predicate,
1899 pending: /* @__PURE__ */ new Set(),
1900 unsubscribe: () => {
1901 throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(22) : "Unsubscribe not initialized");
1902 }
1903 };
1904 return entry;
1905 }, {
1906 withTypes: () => createListenerEntry
1907 });
1908 var findListenerEntry = (listenerMap, options) => {
1909 const {
1910 type,
1911 effect,
1912 predicate
1913 } = getListenerEntryPropsFrom(options);
1914 return Array.from(listenerMap.values()).find((entry) => {
1915 const matchPredicateOrType = typeof type === "string" ? entry.type === type : entry.predicate === predicate;
1916 return matchPredicateOrType && entry.effect === effect;
1917 });
1918 };
1919 var cancelActiveListeners = (entry) => {
1920 entry.pending.forEach((controller) => {
1921 abortControllerWithReason(controller, listenerCancelled);
1922 });
1923 };
1924 var createClearListenerMiddleware = (listenerMap) => {
1925 return () => {
1926 listenerMap.forEach(cancelActiveListeners);
1927 listenerMap.clear();
1928 };
1929 };
1930 var safelyNotifyError = (errorHandler, errorToNotify, errorInfo) => {
1931 try {
1932 errorHandler(errorToNotify, errorInfo);
1933 } catch (errorHandlerError) {
1934 setTimeout(() => {
1935 throw errorHandlerError;
1936 }, 0);
1937 }
1938 };
1939 var addListener = /* @__PURE__ */ assign(/* @__PURE__ */ createAction(`${alm}/add`), {
1940 withTypes: () => addListener
1941 });
1942 var clearAllListeners = /* @__PURE__ */ createAction(`${alm}/removeAll`);
1943 var removeListener = /* @__PURE__ */ assign(/* @__PURE__ */ createAction(`${alm}/remove`), {
1944 withTypes: () => removeListener
1945 });
1946 var defaultErrorHandler = (...args) => {
1947 console.error(`${alm}/error`, ...args);
1948 };
1949 var createListenerMiddleware = (middlewareOptions = {}) => {
1950 const listenerMap = /* @__PURE__ */ new Map();
1951 const {
1952 extra,
1953 onError = defaultErrorHandler
1954 } = middlewareOptions;
1955 assertFunction(onError, "onError");
1956 const insertEntry = (entry) => {
1957 entry.unsubscribe = () => listenerMap.delete(entry.id);
1958 listenerMap.set(entry.id, entry);
1959 return (cancelOptions) => {
1960 entry.unsubscribe();
1961 if (cancelOptions?.cancelActive) {
1962 cancelActiveListeners(entry);
1963 }
1964 };
1965 };
1966 const startListening = (options) => {
1967 const entry = findListenerEntry(listenerMap, options) ?? createListenerEntry(options);
1968 return insertEntry(entry);
1969 };
1970 assign(startListening, {
1971 withTypes: () => startListening
1972 });
1973 const stopListening = (options) => {
1974 const entry = findListenerEntry(listenerMap, options);
1975 if (entry) {
1976 entry.unsubscribe();
1977 if (options.cancelActive) {
1978 cancelActiveListeners(entry);
1979 }
1980 }
1981 return !!entry;
1982 };
1983 assign(stopListening, {
1984 withTypes: () => stopListening
1985 });
1986 const notifyListener = async (entry, action, api, getOriginalState) => {
1987 const internalTaskController = new AbortController();
1988 const take = createTakePattern(startListening, internalTaskController.signal);
1989 const autoJoinPromises = [];
1990 try {
1991 entry.pending.add(internalTaskController);
1992 await Promise.resolve(entry.effect(
1993 action,
1994 // Use assign() rather than ... to avoid extra helper functions added to bundle
1995 assign({}, api, {
1996 getOriginalState,
1997 condition: (predicate, timeout) => take(predicate, timeout).then(Boolean),
1998 take,
1999 delay: createDelay(internalTaskController.signal),
2000 pause: createPause(internalTaskController.signal),
2001 extra,
2002 signal: internalTaskController.signal,
2003 fork: createFork(internalTaskController.signal, autoJoinPromises),
2004 unsubscribe: entry.unsubscribe,
2005 subscribe: () => {
2006 listenerMap.set(entry.id, entry);
2007 },
2008 cancelActiveListeners: () => {
2009 entry.pending.forEach((controller, _, set) => {
2010 if (controller !== internalTaskController) {
2011 abortControllerWithReason(controller, listenerCancelled);
2012 set.delete(controller);
2013 }
2014 });
2015 },
2016 cancel: () => {
2017 abortControllerWithReason(internalTaskController, listenerCancelled);
2018 entry.pending.delete(internalTaskController);
2019 },
2020 throwIfCancelled: () => {
2021 validateActive(internalTaskController.signal);
2022 }
2023 })
2024 ));
2025 } catch (listenerError) {
2026 if (!(listenerError instanceof TaskAbortError)) {
2027 safelyNotifyError(onError, listenerError, {
2028 raisedBy: "effect"
2029 });
2030 }
2031 } finally {
2032 await Promise.all(autoJoinPromises);
2033 abortControllerWithReason(internalTaskController, listenerCompleted);
2034 entry.pending.delete(internalTaskController);
2035 }
2036 };
2037 const clearListenerMiddleware = createClearListenerMiddleware(listenerMap);
2038 const middleware = (api) => (next) => (action) => {
2039 if (!isAction3(action)) {
2040 return next(action);
2041 }
2042 if (addListener.match(action)) {
2043 return startListening(action.payload);
2044 }
2045 if (clearAllListeners.match(action)) {
2046 clearListenerMiddleware();
2047 return;
2048 }
2049 if (removeListener.match(action)) {
2050 return stopListening(action.payload);
2051 }
2052 let originalState = api.getState();
2053 const getOriginalState = () => {
2054 if (originalState === INTERNAL_NIL_TOKEN) {
2055 throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(23) : `${alm}: getOriginalState can only be called synchronously`);
2056 }
2057 return originalState;
2058 };
2059 let result;
2060 try {
2061 result = next(action);
2062 if (listenerMap.size > 0) {
2063 const currentState = api.getState();
2064 const listenerEntries = Array.from(listenerMap.values());
2065 for (const entry of listenerEntries) {
2066 let runListener = false;
2067 try {
2068 runListener = entry.predicate(action, currentState, originalState);
2069 } catch (predicateError) {
2070 runListener = false;
2071 safelyNotifyError(onError, predicateError, {
2072 raisedBy: "predicate"
2073 });
2074 }
2075 if (!runListener) {
2076 continue;
2077 }
2078 notifyListener(entry, action, api, getOriginalState);
2079 }
2080 }
2081 } finally {
2082 originalState = INTERNAL_NIL_TOKEN;
2083 }
2084 return result;
2085 };
2086 return {
2087 middleware,
2088 startListening,
2089 stopListening,
2090 clearListeners: clearListenerMiddleware
2091 };
2092 };
2093
2094 // src/dynamicMiddleware/index.ts
2095 import { compose as compose3 } from "redux";
2096 var createMiddlewareEntry = (middleware) => ({
2097 middleware,
2098 applied: /* @__PURE__ */ new Map()
2099 });
2100 var matchInstance = (instanceId) => (action) => action?.meta?.instanceId === instanceId;
2101 var createDynamicMiddleware = () => {
2102 const instanceId = nanoid();
2103 const middlewareMap = /* @__PURE__ */ new Map();
2104 const withMiddleware = Object.assign(createAction("dynamicMiddleware/add", (...middlewares) => ({
2105 payload: middlewares,
2106 meta: {
2107 instanceId
2108 }
2109 })), {
2110 withTypes: () => withMiddleware
2111 });
2112 const addMiddleware = Object.assign(function addMiddleware2(...middlewares) {
2113 middlewares.forEach((middleware2) => {
2114 getOrInsertComputed(middlewareMap, middleware2, createMiddlewareEntry);
2115 });
2116 }, {
2117 withTypes: () => addMiddleware
2118 });
2119 const getFinalMiddleware = (api) => {
2120 const appliedMiddleware = Array.from(middlewareMap.values()).map((entry) => getOrInsertComputed(entry.applied, api, entry.middleware));
2121 return compose3(...appliedMiddleware);
2122 };
2123 const isWithMiddleware = isAllOf(withMiddleware, matchInstance(instanceId));
2124 const middleware = (api) => (next) => (action) => {
2125 if (isWithMiddleware(action)) {
2126 addMiddleware(...action.payload);
2127 return api.dispatch;
2128 }
2129 return getFinalMiddleware(api)(next)(action);
2130 };
2131 return {
2132 middleware,
2133 addMiddleware,
2134 withMiddleware,
2135 instanceId
2136 };
2137 };
2138
2139 // src/combineSlices.ts
2140 import { combineReducers as combineReducers2 } from "redux";
2141 var isSliceLike = (maybeSliceLike) => "reducerPath" in maybeSliceLike && typeof maybeSliceLike.reducerPath === "string";
2142 var getReducers = (slices) => slices.flatMap((sliceOrMap) => isSliceLike(sliceOrMap) ? [[sliceOrMap.reducerPath, sliceOrMap.reducer]] : Object.entries(sliceOrMap));
2143 var ORIGINAL_STATE = Symbol.for("rtk-state-proxy-original");
2144 var isStateProxy = (value) => !!value && !!value[ORIGINAL_STATE];
2145 var stateProxyMap = /* @__PURE__ */ new WeakMap();
2146 var createStateProxy = (state, reducerMap) => getOrInsertComputed(stateProxyMap, state, () => new Proxy(state, {
2147 get: (target, prop, receiver) => {
2148 if (prop === ORIGINAL_STATE) return target;
2149 const result = Reflect.get(target, prop, receiver);
2150 if (typeof result === "undefined") {
2151 const reducer = reducerMap[prop.toString()];
2152 if (reducer) {
2153 const reducerResult = reducer(void 0, {
2154 type: nanoid()
2155 });
2156 if (typeof reducerResult === "undefined") {
2157 throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(24) : `The slice reducer for key "${prop.toString()}" returned undefined when called for selector(). If the state passed to the reducer is undefined, you must explicitly return the initial state. The initial state may not be undefined. If you don't want to set a value for this reducer, you can use null instead of undefined.`);
2158 }
2159 return reducerResult;
2160 }
2161 }
2162 return result;
2163 }
2164 }));
2165 var original = (state) => {
2166 if (!isStateProxy(state)) {
2167 throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(25) : "original must be used on state Proxy");
2168 }
2169 return state[ORIGINAL_STATE];
2170 };
2171 var noopReducer = (state = {}) => state;
2172 function combineSlices(...slices) {
2173 const reducerMap = Object.fromEntries(getReducers(slices));
2174 const getReducer = () => Object.keys(reducerMap).length ? combineReducers2(reducerMap) : noopReducer;
2175 let reducer = getReducer();
2176 function combinedReducer(state, action) {
2177 return reducer(state, action);
2178 }
2179 combinedReducer.withLazyLoadedSlices = () => combinedReducer;
2180 const inject = (slice, config = {}) => {
2181 const {
2182 reducerPath,
2183 reducer: reducerToInject
2184 } = slice;
2185 const currentReducer = reducerMap[reducerPath];
2186 if (!config.overrideExisting && currentReducer && currentReducer !== reducerToInject) {
2187 if (typeof process !== "undefined" && process.env.NODE_ENV === "development") {
2188 console.error(`called \`inject\` to override already-existing reducer ${reducerPath} without specifying \`overrideExisting: true\``);
2189 }
2190 return combinedReducer;
2191 }
2192 reducerMap[reducerPath] = reducerToInject;
2193 reducer = getReducer();
2194 return combinedReducer;
2195 };
2196 const selector = Object.assign(function makeSelector(selectorFn, selectState) {
2197 return function selector2(state, ...args) {
2198 return selectorFn(createStateProxy(selectState ? selectState(state, ...args) : state, reducerMap), ...args);
2199 };
2200 }, {
2201 original
2202 });
2203 return Object.assign(combinedReducer, {
2204 inject,
2205 selector
2206 });
2207 }
2208
2209 // src/formatProdErrorMessage.ts
2210 function formatProdErrorMessage(code) {
2211 return `Minified Redux Toolkit error #${code}; visit https://redux-toolkit.js.org/Errors?code=${code} for the full message or use the non-minified dev environment for full errors. `;
2212 }
2213 export {
2214 ReducerType,
2215 SHOULD_AUTOBATCH,
2216 TaskAbortError,
2217 Tuple,
2218 addListener,
2219 asyncThunkCreator,
2220 autoBatchEnhancer,
2221 buildCreateSlice,
2222 clearAllListeners,
2223 combineSlices,
2224 configureStore,
2225 createAction,
2226 createActionCreatorInvariantMiddleware,
2227 createAsyncThunk,
2228 createDraftSafeSelector,
2229 createDraftSafeSelectorCreator,
2230 createDynamicMiddleware,
2231 createEntityAdapter,
2232 createImmutableStateInvariantMiddleware,
2233 createListenerMiddleware,
2234 produce as createNextState,
2235 createReducer,
2236 createSelector,
2237 createSelectorCreator2 as createSelectorCreator,
2238 createSerializableStateInvariantMiddleware,
2239 createSlice,
2240 current3 as current,
2241 findNonSerializableValue,
2242 formatProdErrorMessage,
2243 freeze,
2244 isActionCreator,
2245 isAllOf,
2246 isAnyOf,
2247 isAsyncThunkAction,
2248 isDraft5 as isDraft,
2249 isFSA as isFluxStandardAction,
2250 isFulfilled,
2251 isImmutableDefault,
2252 isPending,
2253 isPlain,
2254 isRejected,
2255 isRejectedWithValue,
2256 lruMemoize,
2257 miniSerializeError,
2258 nanoid,
2259 original2 as original,
2260 prepareAutoBatched,
2261 removeListener,
2262 unwrapResult,
2263 weakMapMemoize2 as weakMapMemoize
2264 };
2265 //# sourceMappingURL=redux-toolkit.modern.mjs.map