Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More →
redux-starter-kit
Advanced tools
redux-starter-kit - npm Package Compare versions
Comparing version 1.0.1 to 2.0.0
@@ -1,356 +0,1 @@ | ||
| import { Middleware, Reducer, ReducersMapObject, Action, AnyAction, StoreEnhancer, Store, DeepPartial } from "redux"; | ||
| import { EnhancerOptions as DevToolsOptions } from "redux-devtools-extension"; | ||
| import { ThunkDispatch } from "redux-thunk"; | ||
| import { Draft } from "immer"; | ||
| /** | ||
| * Returns true if the passed value is "plain", i.e. a value that is either | ||
| * directly JSON-serializable (boolean, number, string, array, plain object) | ||
| * or `undefined`. | ||
| * | ||
| * @param val The value to check. | ||
| */ | ||
| declare function isPlain(val: any): boolean; | ||
| interface NonSerializableValue { | ||
| keyPath: string; | ||
| value: unknown; | ||
| } | ||
| declare function findNonSerializableValue(value: unknown, path?: ReadonlyArray<string>, isSerializable?: (value: unknown) => boolean, getEntries?: (value: unknown) => [string, any][]): NonSerializableValue | false; | ||
| /** | ||
| * Options for `createSerializableStateInvariantMiddleware()`. | ||
| */ | ||
| interface SerializableStateInvariantMiddlewareOptions { | ||
| /** | ||
| * The function to check if a value is considered serializable. This | ||
| * function is applied recursively to every value contained in the | ||
| * state. Defaults to `isPlain()`. | ||
| */ | ||
| isSerializable?: (value: any) => boolean; | ||
| /** | ||
| * The function that will be used to retrieve entries from each | ||
| * value. If unspecified, `Object.entries` will be used. Defaults | ||
| * to `undefined`. | ||
| */ | ||
| getEntries?: (value: any) => [string, any][]; | ||
| /** | ||
| * An array of action types to ignore when checking for serializability, Defaults to [] | ||
| */ | ||
| ignoredActions?: string[]; | ||
| } | ||
| /** | ||
| * Creates a middleware that, after every state change, checks if the new | ||
| * state is serializable. If a non-serializable value is found within the | ||
| * state, an error is printed to the console. | ||
| * | ||
| * @param options Middleware options. | ||
| */ | ||
| declare function createSerializableStateInvariantMiddleware(options?: SerializableStateInvariantMiddlewareOptions): Middleware; | ||
| interface ThunkOptions<E = any> { | ||
| extraArgument: E; | ||
| } | ||
| interface ImmutableStateInvariantMiddlewareOptions { | ||
| isImmutable?: (value: any) => boolean; | ||
| ignore?: string[]; | ||
| } | ||
| interface GetDefaultMiddlewareOptions { | ||
| thunk?: boolean | ThunkOptions; | ||
| immutableCheck?: boolean | ImmutableStateInvariantMiddlewareOptions; | ||
| serializableCheck?: boolean | SerializableStateInvariantMiddlewareOptions; | ||
| } | ||
| /** | ||
| * Returns any array containing the default middleware installed by | ||
| * `configureStore()`. Useful if you want to configure your store with a custom | ||
| * `middleware` array but still keep the default set. | ||
| * | ||
| * @return The default middleware used by `configureStore()`. | ||
| */ | ||
| declare function getDefaultMiddleware<S = any>(options?: GetDefaultMiddlewareOptions): Middleware<{}, S>[]; | ||
| declare type ConfigureEnhancersCallback = (defaultEnhancers: StoreEnhancer[]) => StoreEnhancer[]; | ||
| /** | ||
| * Options for `configureStore()`. | ||
| */ | ||
| interface ConfigureStoreOptions<S = any, A extends Action = AnyAction> { | ||
| /** | ||
| * A single reducer function that will be used as the root reducer, or an | ||
| * object of slice reducers that will be passed to `combineReducers()`. | ||
| */ | ||
| reducer: Reducer<S, A> | ReducersMapObject<S, A>; | ||
| /** | ||
| * An array of Redux middleware to install. If not supplied, defaults to | ||
| * the set of middleware returned by `getDefaultMiddleware()`. | ||
| */ | ||
| middleware?: Middleware<{}, S>[]; | ||
| /** | ||
| * Whether to enable Redux DevTools integration. Defaults to `true`. | ||
| * | ||
| * Additional configuration can be done by passing Redux DevTools options | ||
| */ | ||
| devTools?: boolean | DevToolsOptions; | ||
| /** | ||
| * The initial state, same as Redux's createStore. | ||
| * You may optionally specify it to hydrate the state | ||
| * from the server in universal apps, or to restore a previously serialized | ||
| * user session. If you use `combineReducers()` to produce the root reducer | ||
| * function (either directly or indirectly by passing an object as `reducer`), | ||
| * this must be an object with the same shape as the reducer map keys. | ||
| */ | ||
| preloadedState?: DeepPartial<S extends any ? S : S>; | ||
| /** | ||
| * The store enhancers to apply. See Redux's `createStore()`. | ||
| * All enhancers will be included before the DevTools Extension enhancer. | ||
| * If you need to customize the order of enhancers, supply a callback | ||
| * function that will receive the original array (ie, `[applyMiddleware]`), | ||
| * and should return a new array (such as `[applyMiddleware, offline]`). | ||
| * If you only need to add middleware, you can use the `middleware` parameter instaead. | ||
| */ | ||
| enhancers?: StoreEnhancer[] | ConfigureEnhancersCallback; | ||
| } | ||
| /** | ||
| * A Redux store returned by `configureStore()`. Supports dispatching | ||
| * side-effectful _thunks_ in addition to plain actions. | ||
| */ | ||
| interface EnhancedStore<S = any, A extends Action = AnyAction> extends Store<S, A> { | ||
| dispatch: ThunkDispatch<S, any, A>; | ||
| } | ||
| /** | ||
| * A friendly abstraction over the standard Redux `createStore()` function. | ||
| * | ||
| * @param config The store configuration. | ||
| * @returns A configured Redux store. | ||
| */ | ||
| declare function configureStore<S = any, A extends Action = AnyAction>(options: ConfigureStoreOptions<S, A>): EnhancedStore<S, A>; | ||
| declare type IsAny<T, True, False = never> = (True | False) extends (T extends never ? True : False) ? True : False; | ||
| declare type IsUnknown<T, True, False = never> = unknown extends T ? IsAny<T, False, True> : False; | ||
| declare type IsEmptyObj<T, True, False = never> = T extends any ? keyof T extends never ? IsUnknown<T, False, True> : False : never; | ||
| /** | ||
| * returns True if TS version is above 3.5, False if below. | ||
| * uses feature detection to detect TS version >= 3.5 | ||
| * * versions below 3.5 will return `{}` for unresolvable interference | ||
| * * versions above will return `unknown` | ||
| * */ | ||
| declare type AtLeastTS35<True, False> = [True, False][IsUnknown<ReturnType<(<T>() => T)>, 0, 1>]; | ||
| declare type IsUnknownOrNonInferrable<T, True, False> = AtLeastTS35<IsUnknown<T, True, False>, IsEmptyObj<T, True, False>>; | ||
| /** | ||
| * An action with a string type and an associated payload. This is the | ||
| * type of action returned by `createAction()` action creators. | ||
| * | ||
| * @template P The type of the action's payload. | ||
| * @template T the type used for the action type. | ||
| * @template M The type of the action's meta (optional) | ||
| * @template E The type of the action's error (optional) | ||
| */ | ||
| declare type PayloadAction<P = void, T extends string = string, M = never, E = never> = WithOptional<M, E, WithPayload<P, Action<T>>>; | ||
| declare type PrepareAction<P> = ((...args: any[]) => { | ||
| payload: P; | ||
| }) | ((...args: any[]) => { | ||
| payload: P; | ||
| meta: any; | ||
| }) | ((...args: any[]) => { | ||
| payload: P; | ||
| error: any; | ||
| }) | ((...args: any[]) => { | ||
| payload: P; | ||
| meta: any; | ||
| error: any; | ||
| }); | ||
| declare type ActionCreatorWithPreparedPayload<PA extends PrepareAction<any> | void, T extends string = string> = PA extends PrepareAction<infer P> ? WithTypePropertyAndMatch<(...args: Parameters<PA>) => PayloadAction<P, T, MetaOrNever<PA>, ErrorOrNever<PA>>, T, P, MetaOrNever<PA>, ErrorOrNever<PA>> : void; | ||
| declare type ActionCreatorWithOptionalPayload<P, T extends string = string> = WithTypePropertyAndMatch<{ | ||
| (payload?: undefined): PayloadAction<undefined, T>; | ||
| <PT extends Diff<P, undefined>>(payload?: PT): PayloadAction<PT, T>; | ||
| }, T, P | undefined>; | ||
| declare type ActionCreatorWithoutPayload<T extends string = string> = WithTypePropertyAndMatch<() => PayloadAction<undefined, T>, T, undefined>; | ||
| declare type ActionCreatorWithPayload<P, T extends string = string> = WithTypePropertyAndMatch<IsUnknownOrNonInferrable<P, <PT extends unknown>(payload: PT) => PayloadAction<PT, T>, <PT extends P>(payload: PT) => PayloadAction<PT, T>>, T, P>; | ||
| /** | ||
| * An action creator that produces actions with a `payload` attribute. | ||
| */ | ||
| declare type PayloadActionCreator<P = void, T extends string = string, PA extends PrepareAction<P> | void = void> = IfPrepareActionMethodProvided<PA, ActionCreatorWithPreparedPayload<PA, T>, IfMaybeUndefined<P, ActionCreatorWithOptionalPayload<P, T>, IfVoid<P, ActionCreatorWithoutPayload<T>, ActionCreatorWithPayload<P, T>>>>; | ||
| /** | ||
| * A utility function to create an action creator for the given action type | ||
| * string. The action creator accepts a single argument, which will be included | ||
| * in the action object as a field called payload. The action creator function | ||
| * will also have its toString() overriden so that it returns the action type, | ||
| * allowing it to be used in reducer logic that is looking for that action type. | ||
| * | ||
| * @param type The action type to use for created actions. | ||
| * @param prepare (optional) a method that takes any number of arguments and returns { payload } or { payload, meta }. | ||
| * If this is given, the resulting action creator will pass it's arguments to this method to calculate payload & meta. | ||
| */ | ||
| declare function createAction<P = void, T extends string = string>(type: T): PayloadActionCreator<P, T>; | ||
| declare function createAction<PA extends PrepareAction<any>, T extends string = string>(type: T, prepareAction: PA): PayloadActionCreator<ReturnType<PA>['payload'], T, PA>; | ||
| /** | ||
| * Returns the action type of the actions created by the passed | ||
| * `createAction()`-generated action creator (arbitrary action creators | ||
| * are not supported). | ||
| * | ||
| * @param action The action creator whose action type to get. | ||
| * @returns The action type used by the action creator. | ||
| */ | ||
| declare function getType<T extends string>(actionCreator: PayloadActionCreator<any, T>): T; | ||
| declare type Diff<T, U> = T extends U ? never : T; | ||
| declare type WithPayload<P, T> = T & { | ||
| payload: P; | ||
| }; | ||
| declare type WithOptional<M, E, T> = T & ([M] extends [never] ? {} : { | ||
| meta: M; | ||
| }) & ([E] extends [never] ? {} : { | ||
| error: E; | ||
| }); | ||
| declare type WithTypeProperty<MergeIn, T extends string> = { | ||
| type: T; | ||
| } & MergeIn; | ||
| declare type WithMatch<MergeIn, T extends string, P, M = never, E = never> = { | ||
| match(action: Action<unknown>): action is PayloadAction<P, T, M, E>; | ||
| } & MergeIn; | ||
| declare type WithTypePropertyAndMatch<MergeIn, T extends string, P, M = never, E = never> = WithTypeProperty<WithMatch<MergeIn, T, P, M, E>, T>; | ||
| declare type IfPrepareActionMethodProvided<PA extends PrepareAction<any> | void, True, False> = PA extends (...args: any[]) => any ? True : False; | ||
| declare type MetaOrNever<PA extends PrepareAction<any>> = ReturnType<PA> extends { | ||
| meta: infer M; | ||
| } ? M : never; | ||
| declare type ErrorOrNever<PA extends PrepareAction<any>> = ReturnType<PA> extends { | ||
| error: infer E; | ||
| } ? E : never; | ||
| declare type IfMaybeUndefined<P, True, False> = [undefined] extends [P] ? True : False; | ||
| declare type IfVoid<P, True, False> = [void] extends [P] ? True : False; | ||
| /** | ||
| * Defines a mapping from action types to corresponding action object shapes. | ||
| */ | ||
| declare type Actions<T extends keyof any = string> = Record<T, Action>; | ||
| /** | ||
| * An *case reducer* is a reducer function for a speficic action type. Case | ||
| * reducers can be composed to full reducers using `createReducer()`. | ||
| * | ||
| * Unlike a normal Redux reducer, a case reducer is never called with an | ||
| * `undefined` state to determine the initial state. Instead, the initial | ||
| * state is explicitly specified as an argument to `createReducer()`. | ||
| * | ||
| * In addition, a case reducer can choose to mutate the passed-in `state` | ||
| * value directly instead of returning a new state. This does not actually | ||
| * cause the store state to be mutated directly; instead, thanks to | ||
| * [immer](https://github.com/mweststrate/immer), the mutations are | ||
| * translated to copy operations that result in a new state. | ||
| */ | ||
| declare type CaseReducer<S = any, A extends Action = AnyAction> = (state: Draft<S>, action: A) => S | void; | ||
| /** | ||
| * A mapping from action types to case reducers for `createReducer()`. | ||
| */ | ||
| declare type CaseReducers<S, AS extends Actions> = { | ||
| [T in keyof AS]: AS[T] extends Action ? CaseReducer<S, AS[T]> : void; | ||
| }; | ||
| /** | ||
| * A utility function that allows defining a reducer as a mapping from action | ||
| * type to *case reducer* functions that handle these action types. The | ||
| * reducer's initial state is passed as the first argument. | ||
| * | ||
| * The body of every case reducer is implicitly wrapped with a call to | ||
| * `produce()` from the [immer](https://github.com/mweststrate/immer) library. | ||
| * This means that rather than returning a new state object, you can also | ||
| * mutate the passed-in state object directly; these mutations will then be | ||
| * automatically and efficiently translated into copies, giving you both | ||
| * convenience and immutability. | ||
| * | ||
| * @param initialState The initial state to be returned by the reducer. | ||
| * @param actionsMap A mapping from action types to action-type-specific | ||
| * case redeucers. | ||
| */ | ||
| declare function createReducer<S, CR extends CaseReducers<S, any> = CaseReducers<S, any>>(initialState: S, actionsMap: CR): Reducer<S>; | ||
| /** | ||
| * An action creator atttached to a slice. | ||
| * | ||
| * @deprecated please use PayloadActionCreator directly | ||
| */ | ||
| declare type SliceActionCreator<P> = PayloadActionCreator<P>; | ||
| interface Slice<State = any, CaseReducers extends SliceCaseReducerDefinitions<State, PayloadActions> = { | ||
| [key: string]: any; | ||
| }> { | ||
| /** | ||
| * The slice name. | ||
| */ | ||
| name: string; | ||
| /** | ||
| * The slice's reducer. | ||
| */ | ||
| reducer: Reducer<State>; | ||
| /** | ||
| * Action creators for the types of actions that are handled by the slice | ||
| * reducer. | ||
| */ | ||
| actions: CaseReducerActions<CaseReducers>; | ||
| caseReducers: SliceDefinedCaseReducers<CaseReducers, State>; | ||
| } | ||
| /** | ||
| * Options for `createSlice()`. | ||
| */ | ||
| interface CreateSliceOptions<State = any, CR extends SliceCaseReducerDefinitions<State, any> = SliceCaseReducerDefinitions<State, any>> { | ||
| /** | ||
| * The slice's name. Used to namespace the generated action types. | ||
| */ | ||
| name: string; | ||
| /** | ||
| * The initial state to be returned by the slice reducer. | ||
| */ | ||
| initialState: State; | ||
| /** | ||
| * A mapping from action types to action-type-specific *case reducer* | ||
| * functions. For every action type, a matching action creator will be | ||
| * generated using `createAction()`. | ||
| */ | ||
| reducers: CR; | ||
| /** | ||
| * A mapping from action types to action-type-specific *case reducer* | ||
| * functions. These reducers should have existing action types used | ||
| * as the keys, and action creators will _not_ be generated. | ||
| */ | ||
| extraReducers?: CaseReducers<NoInfer<State>, any>; | ||
| } | ||
| declare type PayloadActions<Types extends keyof any = string> = Record<Types, PayloadAction>; | ||
| declare type CaseReducerWithPrepare<State, Action extends PayloadAction> = { | ||
| reducer: CaseReducer<State, Action>; | ||
| prepare: PrepareAction<Action['payload']>; | ||
| }; | ||
| declare type SliceCaseReducerDefinitions<State, PA extends PayloadActions> = { | ||
| [ActionType in keyof PA]: CaseReducer<State, PA[ActionType]> | CaseReducerWithPrepare<State, PA[ActionType]>; | ||
| }; | ||
| declare type IfIsReducerFunctionWithoutAction<R, True, False = never> = R extends (state: any) => any ? True : False; | ||
| declare type IfIsCaseReducerWithPrepare<R, True, False = never> = R extends { | ||
| prepare: Function; | ||
| } ? True : False; | ||
| declare type PayloadForReducer<R> = R extends (state: any, action: PayloadAction<infer P>) => any ? P : void; | ||
| declare type PrepareActionForReducer<R> = R extends { | ||
| prepare: infer Prepare; | ||
| } ? Prepare : never; | ||
| declare type ActionForReducer<R, S> = R extends (state: S, action: PayloadAction<infer P>) => S ? PayloadAction<P> : R extends { | ||
| reducer(state: any, action: PayloadAction<infer P>): any; | ||
| } ? PayloadAction<P> : unknown; | ||
| declare type CaseReducerActions<CaseReducers extends SliceCaseReducerDefinitions<any, any>> = { | ||
| [Type in keyof CaseReducers]: IfIsCaseReducerWithPrepare<CaseReducers[Type], ActionCreatorWithPreparedPayload<PrepareActionForReducer<CaseReducers[Type]>>, IfIsReducerFunctionWithoutAction<CaseReducers[Type], ActionCreatorWithoutPayload, PayloadActionCreator<PayloadForReducer<CaseReducers[Type]>>>>; | ||
| }; | ||
| declare type SliceDefinedCaseReducers<CaseReducers extends SliceCaseReducerDefinitions<any, any>, State = any> = { | ||
| [Type in keyof CaseReducers]: CaseReducer<State, ActionForReducer<CaseReducers[Type], State>>; | ||
| }; | ||
| declare type NoInfer<T> = [T][T extends any ? 0 : never]; | ||
| declare type SliceCaseReducersCheck<S, ACR> = { | ||
| [P in keyof ACR]: ACR[P] extends { | ||
| reducer(s: S, action?: { | ||
| payload: infer O; | ||
| }): any; | ||
| } ? { | ||
| prepare(...a: never[]): { | ||
| payload: O; | ||
| }; | ||
| } : {}; | ||
| }; | ||
| declare type RestrictCaseReducerDefinitionsToMatchReducerAndPrepare<S, CR extends SliceCaseReducerDefinitions<S, any>> = { | ||
| reducers: SliceCaseReducersCheck<S, NoInfer<CR>>; | ||
| }; | ||
| /** | ||
| * A function that accepts an initial state, an object full of reducer | ||
| * functions, and a "slice name", and automatically generates | ||
| * action creators and action types that correspond to the | ||
| * reducers and state. | ||
| * | ||
| * The `reducer` argument is passed to `createReducer()`. | ||
| */ | ||
| declare function createSlice<State, CaseReducers extends SliceCaseReducerDefinitions<State, any>>(options: CreateSliceOptions<State, CaseReducers> & RestrictCaseReducerDefinitionsToMatchReducerAndPrepare<State, CaseReducers>): Slice<State, CaseReducers>; | ||
| export * from 'redux'; | ||
| export { default as createNextState } from 'immer'; | ||
| export { createSelector } from "reselect"; | ||
| export { ConfigureEnhancersCallback, ConfigureStoreOptions, EnhancedStore, configureStore, PayloadAction, PrepareAction, ActionCreatorWithPreparedPayload, ActionCreatorWithOptionalPayload, ActionCreatorWithoutPayload, ActionCreatorWithPayload, PayloadActionCreator, createAction, getType, Actions, CaseReducer, CaseReducers, createReducer, SliceActionCreator, Slice, CreateSliceOptions, createSlice, isPlain, findNonSerializableValue, SerializableStateInvariantMiddlewareOptions, createSerializableStateInvariantMiddleware, getDefaultMiddleware }; | ||
| export {}; |
| 'use strict'; | ||
| function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; } | ||
| var redux = require('redux'); | ||
| var createNextState = _interopDefault(require('immer')); | ||
| var reselect = require('reselect'); | ||
| var reduxDevtoolsExtension = require('redux-devtools-extension'); | ||
| var thunkMiddleware = _interopDefault(require('redux-thunk')); | ||
| function _extends() { | ||
| _extends = Object.assign || function (target) { | ||
| for (var i = 1; i < arguments.length; i++) { | ||
| var source = arguments[i]; | ||
| for (var key in source) { | ||
| if (Object.prototype.hasOwnProperty.call(source, key)) { | ||
| target[key] = source[key]; | ||
| } | ||
| } | ||
| } | ||
| return target; | ||
| }; | ||
| return _extends.apply(this, arguments); | ||
| } | ||
| /** | ||
| * Returns true if the passed value is "plain" object, i.e. an object whose | ||
| * protoype is the root `Object.prototype`. This includes objects created | ||
| * using object literals, but not for instance for class instances. | ||
| * | ||
| * @param {any} value The value to inspect. | ||
| * @returns {boolean} True if the argument appears to be a plain object. | ||
| */ | ||
| function isPlainObject(value) { | ||
| if (typeof value !== 'object' || value === null) return false; | ||
| var proto = value; | ||
| while (Object.getPrototypeOf(proto) !== null) { | ||
| proto = Object.getPrototypeOf(proto); | ||
| } | ||
| return Object.getPrototypeOf(value) === proto; | ||
| } | ||
| /** | ||
| * Returns true if the passed value is "plain", i.e. a value that is either | ||
| * directly JSON-serializable (boolean, number, string, array, plain object) | ||
| * or `undefined`. | ||
| * | ||
| * @param val The value to check. | ||
| */ | ||
| function isPlain(val) { | ||
| return typeof val === 'undefined' || val === null || typeof val === 'string' || typeof val === 'boolean' || typeof val === 'number' || Array.isArray(val) || isPlainObject(val); | ||
| } | ||
| var NON_SERIALIZABLE_STATE_MESSAGE = | ||
| /*#__PURE__*/ | ||
| ['A non-serializable value was detected in the state, in the path: `%s`. Value: %o', 'Take a look at the reducer(s) handling this action type: %s.', '(See https://redux.js.org/faq/organizing-state#can-i-put-functions-promises-or-other-non-serializable-items-in-my-store-state)'].join('\n'); | ||
| var NON_SERIALIZABLE_ACTION_MESSAGE = | ||
| /*#__PURE__*/ | ||
| ['A non-serializable value was detected in an action, in the path: `%s`. Value: %o', 'Take a look at the logic that dispatched this action: %o.', '(See https://redux.js.org/faq/actions#why-should-type-be-a-string-or-at-least-serializable-why-should-my-action-types-be-constants)'].join('\n'); | ||
| function findNonSerializableValue(value, path, isSerializable, getEntries) { | ||
| if (path === void 0) { | ||
| path = []; | ||
| } | ||
| if (isSerializable === void 0) { | ||
| isSerializable = isPlain; | ||
| } | ||
| var foundNestedSerializable; | ||
| if (!isSerializable(value)) { | ||
| return { | ||
| keyPath: path.join('.') || '<root>', | ||
| value: value | ||
| }; | ||
| } | ||
| if (typeof value !== 'object' || value === null) { | ||
| return false; | ||
| } | ||
| var entries = getEntries != null ? getEntries(value) : Object.entries(value); | ||
| for (var _iterator = entries, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { | ||
| var _ref; | ||
| if (_isArray) { | ||
| if (_i >= _iterator.length) break; | ||
| _ref = _iterator[_i++]; | ||
| } else { | ||
| _i = _iterator.next(); | ||
| if (_i.done) break; | ||
| _ref = _i.value; | ||
| } | ||
| var _ref2 = _ref, | ||
| property = _ref2[0], | ||
| nestedValue = _ref2[1]; | ||
| var nestedPath = path.concat(property); | ||
| if (!isSerializable(nestedValue)) { | ||
| return { | ||
| keyPath: nestedPath.join('.'), | ||
| value: nestedValue | ||
| }; | ||
| } | ||
| if (typeof nestedValue === 'object') { | ||
| foundNestedSerializable = findNonSerializableValue(nestedValue, nestedPath, isSerializable, getEntries); | ||
| if (foundNestedSerializable) { | ||
| return foundNestedSerializable; | ||
| } | ||
| } | ||
| } | ||
| return false; | ||
| } | ||
| /** | ||
| * Creates a middleware that, after every state change, checks if the new | ||
| * state is serializable. If a non-serializable value is found within the | ||
| * state, an error is printed to the console. | ||
| * | ||
| * @param options Middleware options. | ||
| */ | ||
| function createSerializableStateInvariantMiddleware(options) { | ||
| if (options === void 0) { | ||
| options = {}; | ||
| } | ||
| var _options = options, | ||
| _options$isSerializab = _options.isSerializable, | ||
| isSerializable = _options$isSerializab === void 0 ? isPlain : _options$isSerializab, | ||
| getEntries = _options.getEntries, | ||
| _options$ignoredActio = _options.ignoredActions, | ||
| ignoredActions = _options$ignoredActio === void 0 ? [] : _options$ignoredActio; | ||
| return function (storeAPI) { | ||
| return function (next) { | ||
| return function (action) { | ||
| if (ignoredActions.length && ignoredActions.indexOf(action.type) !== -1) { | ||
| return next(action); | ||
| } | ||
| var foundActionNonSerializableValue = findNonSerializableValue(action, [], isSerializable, getEntries); | ||
| if (foundActionNonSerializableValue) { | ||
| var keyPath = foundActionNonSerializableValue.keyPath, | ||
| value = foundActionNonSerializableValue.value; | ||
| console.error(NON_SERIALIZABLE_ACTION_MESSAGE, keyPath, value, action); | ||
| } | ||
| var result = next(action); | ||
| var state = storeAPI.getState(); | ||
| var foundStateNonSerializableValue = findNonSerializableValue(state, [], isSerializable, getEntries); | ||
| if (foundStateNonSerializableValue) { | ||
| var _keyPath = foundStateNonSerializableValue.keyPath, | ||
| _value = foundStateNonSerializableValue.value; | ||
| console.error(NON_SERIALIZABLE_STATE_MESSAGE, _keyPath, _value, action.type); | ||
| } | ||
| return result; | ||
| }; | ||
| }; | ||
| }; | ||
| } | ||
| function isBoolean(x) { | ||
| return typeof x === 'boolean'; | ||
| } | ||
| /** | ||
| * Returns any array containing the default middleware installed by | ||
| * `configureStore()`. Useful if you want to configure your store with a custom | ||
| * `middleware` array but still keep the default set. | ||
| * | ||
| * @return The default middleware used by `configureStore()`. | ||
| */ | ||
| function getDefaultMiddleware(options) { | ||
| if (options === void 0) { | ||
| options = {}; | ||
| } | ||
| var _options = options, | ||
| _options$thunk = _options.thunk, | ||
| thunk = _options$thunk === void 0 ? true : _options$thunk, | ||
| _options$immutableChe = _options.immutableCheck, | ||
| immutableCheck = _options$immutableChe === void 0 ? true : _options$immutableChe, | ||
| _options$serializable = _options.serializableCheck, | ||
| serializableCheck = _options$serializable === void 0 ? true : _options$serializable; | ||
| var middlewareArray = []; | ||
| if (thunk) { | ||
| if (isBoolean(thunk)) { | ||
| middlewareArray.push(thunkMiddleware); | ||
| } else { | ||
| middlewareArray.push(thunkMiddleware.withExtraArgument(thunk.extraArgument)); | ||
| } | ||
| } | ||
| { | ||
| /* START_REMOVE_UMD */ | ||
| if (immutableCheck) { | ||
| var createImmutableStateInvariantMiddleware = require('redux-immutable-state-invariant')["default"]; | ||
| var immutableOptions = {}; | ||
| if (!isBoolean(immutableCheck)) { | ||
| immutableOptions = immutableCheck; | ||
| } | ||
| middlewareArray.unshift(createImmutableStateInvariantMiddleware(immutableOptions)); | ||
| } | ||
| /* STOP_REMOVE_UMD */ | ||
| if (serializableCheck) { | ||
| var serializableOptions = {}; | ||
| if (!isBoolean(serializableCheck)) { | ||
| serializableOptions = serializableCheck; | ||
| } | ||
| middlewareArray.push(createSerializableStateInvariantMiddleware(serializableOptions)); | ||
| } | ||
| } | ||
| return middlewareArray; | ||
| } | ||
| var IS_PRODUCTION = "development" === 'production'; | ||
| /** | ||
| * A friendly abstraction over the standard Redux `createStore()` function. | ||
| * | ||
| * @param config The store configuration. | ||
| * @returns A configured Redux store. | ||
| */ | ||
| function configureStore(options) { | ||
| var _ref = options || {}, | ||
| _ref$reducer = _ref.reducer, | ||
| reducer = _ref$reducer === void 0 ? undefined : _ref$reducer, | ||
| _ref$middleware = _ref.middleware, | ||
| middleware = _ref$middleware === void 0 ? getDefaultMiddleware() : _ref$middleware, | ||
| _ref$devTools = _ref.devTools, | ||
| devTools = _ref$devTools === void 0 ? true : _ref$devTools, | ||
| _ref$preloadedState = _ref.preloadedState, | ||
| preloadedState = _ref$preloadedState === void 0 ? undefined : _ref$preloadedState, | ||
| _ref$enhancers = _ref.enhancers, | ||
| enhancers = _ref$enhancers === void 0 ? undefined : _ref$enhancers; | ||
| var rootReducer; | ||
| if (typeof reducer === 'function') { | ||
| rootReducer = reducer; | ||
| } else if (isPlainObject(reducer)) { | ||
| rootReducer = redux.combineReducers(reducer); | ||
| } else { | ||
| throw new Error('"reducer" is a required argument, and must be a function or an object of functions that can be passed to combineReducers'); | ||
| } | ||
| var middlewareEnhancer = redux.applyMiddleware.apply(void 0, middleware); | ||
| var finalCompose = redux.compose; | ||
| if (devTools) { | ||
| finalCompose = reduxDevtoolsExtension.composeWithDevTools(_extends({ | ||
| // Enable capture of stack traces for dispatched Redux actions | ||
| trace: !IS_PRODUCTION | ||
| }, typeof devTools === 'object' && devTools)); | ||
| } | ||
| var storeEnhancers = [middlewareEnhancer]; | ||
| if (Array.isArray(enhancers)) { | ||
| storeEnhancers = [middlewareEnhancer].concat(enhancers); | ||
| } else if (typeof enhancers === 'function') { | ||
| storeEnhancers = enhancers(storeEnhancers); | ||
| } | ||
| var composedEnhancer = finalCompose.apply(void 0, storeEnhancers); | ||
| return redux.createStore(rootReducer, preloadedState, composedEnhancer); | ||
| } | ||
| function createAction(type, prepareAction) { | ||
| function actionCreator() { | ||
| if (prepareAction) { | ||
| var prepared = prepareAction.apply(void 0, arguments); | ||
| if (!prepared) { | ||
| throw new Error('prepareAction did not return an object'); | ||
| } | ||
| return _extends({ | ||
| type: type, | ||
| payload: prepared.payload | ||
| }, 'meta' in prepared && { | ||
| meta: prepared.meta | ||
| }, {}, 'error' in prepared && { | ||
| error: prepared.error | ||
| }); | ||
| } | ||
| return { | ||
| type: type, | ||
| payload: arguments.length <= 0 ? undefined : arguments[0] | ||
| }; | ||
| } | ||
| actionCreator.toString = function () { | ||
| return "" + type; | ||
| }; | ||
| actionCreator.type = type; | ||
| actionCreator.match = function (action) { | ||
| return action.type === type; | ||
| }; | ||
| return actionCreator; | ||
| } | ||
| /** | ||
| * Returns the action type of the actions created by the passed | ||
| * `createAction()`-generated action creator (arbitrary action creators | ||
| * are not supported). | ||
| * | ||
| * @param action The action creator whose action type to get. | ||
| * @returns The action type used by the action creator. | ||
| */ | ||
| function getType(actionCreator) { | ||
| return "" + actionCreator; | ||
| } | ||
| /** | ||
| * A utility function that allows defining a reducer as a mapping from action | ||
| * type to *case reducer* functions that handle these action types. The | ||
| * reducer's initial state is passed as the first argument. | ||
| * | ||
| * The body of every case reducer is implicitly wrapped with a call to | ||
| * `produce()` from the [immer](https://github.com/mweststrate/immer) library. | ||
| * This means that rather than returning a new state object, you can also | ||
| * mutate the passed-in state object directly; these mutations will then be | ||
| * automatically and efficiently translated into copies, giving you both | ||
| * convenience and immutability. | ||
| * | ||
| * @param initialState The initial state to be returned by the reducer. | ||
| * @param actionsMap A mapping from action types to action-type-specific | ||
| * case redeucers. | ||
| */ | ||
| function createReducer(initialState, actionsMap) { | ||
| return function (state, action) { | ||
| if (state === void 0) { | ||
| state = initialState; | ||
| } | ||
| // @ts-ignore createNextState() produces an Immutable<Draft<S>> rather | ||
| // than an Immutable<S>, and TypeScript cannot find out how to reconcile | ||
| // these two types. | ||
| return createNextState(state, function (draft) { | ||
| var caseReducer = actionsMap[action.type]; | ||
| return caseReducer ? caseReducer(draft, action) : undefined; | ||
| }); | ||
| }; | ||
| } | ||
| function getType$1(slice, actionKey) { | ||
| return slice + "/" + actionKey; | ||
| } // internal definition is a little less restrictive | ||
| function createSlice(options) { | ||
| var name = options.name, | ||
| initialState = options.initialState; | ||
| if (!name) { | ||
| throw new Error('`name` is a required option for createSlice'); | ||
| } | ||
| var reducers = options.reducers || {}; | ||
| var extraReducers = options.extraReducers || {}; | ||
| var reducerNames = Object.keys(reducers); | ||
| var sliceCaseReducersByName = {}; | ||
| var sliceCaseReducersByType = {}; | ||
| var actionCreators = {}; | ||
| reducerNames.forEach(function (reducerName) { | ||
| var maybeReducerWithPrepare = reducers[reducerName]; | ||
| var type = getType$1(name, reducerName); | ||
| var caseReducer; | ||
| var prepareCallback; | ||
| if (typeof maybeReducerWithPrepare === 'function') { | ||
| caseReducer = maybeReducerWithPrepare; | ||
| } else { | ||
| caseReducer = maybeReducerWithPrepare.reducer; | ||
| prepareCallback = maybeReducerWithPrepare.prepare; | ||
| } | ||
| sliceCaseReducersByName[reducerName] = caseReducer; | ||
| sliceCaseReducersByType[type] = caseReducer; | ||
| actionCreators[reducerName] = prepareCallback ? createAction(type, prepareCallback) : createAction(type); | ||
| }); | ||
| var finalCaseReducers = _extends({}, extraReducers, {}, sliceCaseReducersByType); | ||
| var reducer = createReducer(initialState, finalCaseReducers); | ||
| return { | ||
| name: name, | ||
| reducer: reducer, | ||
| actions: actionCreators, | ||
| caseReducers: sliceCaseReducersByName | ||
| }; | ||
| } | ||
| Object.keys(redux).forEach(function (k) { | ||
| if (k !== 'default') Object.defineProperty(exports, k, { | ||
| enumerable: true, | ||
| get: function () { | ||
| return redux[k]; | ||
| } | ||
| }); | ||
| }); | ||
| exports.createNextState = createNextState; | ||
| Object.defineProperty(exports, 'createSelector', { | ||
| enumerable: true, | ||
| get: function () { | ||
| return reselect.createSelector; | ||
| } | ||
| }); | ||
| exports.configureStore = configureStore; | ||
| exports.createAction = createAction; | ||
| exports.createReducer = createReducer; | ||
| exports.createSerializableStateInvariantMiddleware = createSerializableStateInvariantMiddleware; | ||
| exports.createSlice = createSlice; | ||
| exports.findNonSerializableValue = findNonSerializableValue; | ||
| exports.getDefaultMiddleware = getDefaultMiddleware; | ||
| exports.getType = getType; | ||
| exports.isPlain = isPlain; | ||
| throw new Error('🚨 redux-starter-kit has been renamed to @reduxjs/toolkit. Please uninstall redux-starter-kit and install @reduxjs/toolkit instead. Learn more about this change here: https://github.com/reduxjs/redux-toolkit/releases/tag/v1.0.4 . Thanks! :)'); | ||
| //# sourceMappingURL=redux-starter-kit.cjs.development.js.map |
@@ -1,2 +0,2 @@ | ||
| "use strict";function e(e){return e&&"object"==typeof e&&"default"in e?e.default:e}var t=require("redux"),r=e(require("immer")),o=require("reselect"),n=require("redux-devtools-extension"),a=e(require("redux-thunk"));function i(){return(i=Object.assign||function(e){for(var t=1;t<arguments.length;t++){var r=arguments[t];for(var o in r)Object.prototype.hasOwnProperty.call(r,o)&&(e[o]=r[o])}return e}).apply(this,arguments)}function u(e){if("object"!=typeof e||null===e)return!1;for(var t=e;null!==Object.getPrototypeOf(t);)t=Object.getPrototypeOf(t);return Object.getPrototypeOf(e)===t}function c(e){return null==e||"string"==typeof e||"boolean"==typeof e||"number"==typeof e||Array.isArray(e)||u(e)}var s=["A non-serializable value was detected in the state, in the path: `%s`. Value: %o","Take a look at the reducer(s) handling this action type: %s.","(See https://redux.js.org/faq/organizing-state#can-i-put-functions-promises-or-other-non-serializable-items-in-my-store-state)"].join("\n"),l=["A non-serializable value was detected in an action, in the path: `%s`. Value: %o","Take a look at the logic that dispatched this action: %o.","(See https://redux.js.org/faq/actions#why-should-type-be-a-string-or-at-least-serializable-why-should-my-action-types-be-constants)"].join("\n");function f(e,t,r,o){var n;if(void 0===t&&(t=[]),void 0===r&&(r=c),!r(e))return{keyPath:t.join(".")||"<root>",value:e};if("object"!=typeof e||null===e)return!1;var a=null!=o?o(e):Object.entries(e),i=Array.isArray(a),u=0;for(a=i?a:a[Symbol.iterator]();;){var s;if(i){if(u>=a.length)break;s=a[u++]}else{if((u=a.next()).done)break;s=u.value}var l=s[1],d=t.concat(s[0]);if(!r(l))return{keyPath:d.join("."),value:l};if("object"==typeof l&&(n=f(l,d,r,o)))return n}return!1}function d(e){void 0===e&&(e={});var t=e.thunk,r=void 0===t||t,o=[];return r&&o.push("boolean"==typeof r?a:a.withExtraArgument(r.extraArgument)),o}function p(e,t){function r(){if(t){var r=t.apply(void 0,arguments);if(!r)throw new Error("prepareAction did not return an object");return i({type:e,payload:r.payload},"meta"in r&&{meta:r.meta},{},"error"in r&&{error:r.error})}return{type:e,payload:arguments.length<=0?void 0:arguments[0]}}return r.toString=function(){return""+e},r.type=e,r.match=function(t){return t.type===e},r}function v(e,t){return function(o,n){return void 0===o&&(o=e),r(o,(function(e){var r=t[n.type];return r?r(e,n):void 0}))}}Object.keys(t).forEach((function(e){"default"!==e&&Object.defineProperty(exports,e,{enumerable:!0,get:function(){return t[e]}})})),exports.createNextState=r,Object.defineProperty(exports,"createSelector",{enumerable:!0,get:function(){return o.createSelector}}),exports.configureStore=function(e){var r,o=e||{},a=o.reducer,c=void 0===a?void 0:a,s=o.middleware,l=void 0===s?d():s,f=o.devTools,p=void 0===f||f,v=o.preloadedState,y=void 0===v?void 0:v,h=o.enhancers,b=void 0===h?void 0:h;if("function"==typeof c)r=c;else{if(!u(c))throw new Error('"reducer" is a required argument, and must be a function or an object of functions that can be passed to combineReducers');r=t.combineReducers(c)}var g=t.applyMiddleware.apply(void 0,l),m=t.compose;p&&(m=n.composeWithDevTools(i({trace:!1},"object"==typeof p&&p)));var x=[g];Array.isArray(b)?x=[g].concat(b):"function"==typeof b&&(x=b(x));var j=m.apply(void 0,x);return t.createStore(r,y,j)},exports.createAction=p,exports.createReducer=v,exports.createSerializableStateInvariantMiddleware=function(e){void 0===e&&(e={});var t=e.isSerializable,r=void 0===t?c:t,o=e.getEntries,n=e.ignoredActions,a=void 0===n?[]:n;return function(e){return function(t){return function(n){if(a.length&&-1!==a.indexOf(n.type))return t(n);var i=f(n,[],r,o);i&&console.error(l,i.keyPath,i.value,n);var u=t(n),c=f(e.getState(),[],r,o);return c&&console.error(s,c.keyPath,c.value,n.type),u}}}},exports.createSlice=function(e){var t=e.name,r=e.initialState;if(!t)throw new Error("`name` is a required option for createSlice");var o=e.reducers||{},n=e.extraReducers||{},a=Object.keys(o),u={},c={},s={};a.forEach((function(e){var r,n,a=o[e],i=t+"/"+e;"function"==typeof a?r=a:(r=a.reducer,n=a.prepare),u[e]=r,c[i]=r,s[e]=n?p(i,n):p(i)}));var l=v(r,i({},n,{},c));return{name:t,reducer:l,actions:s,caseReducers:u}},exports.findNonSerializableValue=f,exports.getDefaultMiddleware=d,exports.getType=function(e){return""+e},exports.isPlain=c; | ||
| "use strict";throw new Error("🚨 redux-starter-kit has been renamed to @reduxjs/toolkit. Please uninstall redux-starter-kit and install @reduxjs/toolkit instead. Learn more about this change here: https://github.com/reduxjs/redux-toolkit/releases/tag/v1.0.4 . Thanks! :)"); | ||
| //# sourceMappingURL=redux-starter-kit.cjs.production.min.js.map |
@@ -1,423 +0,2 @@ | ||
| import { combineReducers, applyMiddleware, createStore, compose } from 'redux'; | ||
| export * from 'redux'; | ||
| import createNextState from 'immer'; | ||
| export { default as createNextState } from 'immer'; | ||
| export { createSelector } from 'reselect'; | ||
| import { composeWithDevTools } from 'redux-devtools-extension'; | ||
| import thunkMiddleware from 'redux-thunk'; | ||
| function _extends() { | ||
| _extends = Object.assign || function (target) { | ||
| for (var i = 1; i < arguments.length; i++) { | ||
| var source = arguments[i]; | ||
| for (var key in source) { | ||
| if (Object.prototype.hasOwnProperty.call(source, key)) { | ||
| target[key] = source[key]; | ||
| } | ||
| } | ||
| } | ||
| return target; | ||
| }; | ||
| return _extends.apply(this, arguments); | ||
| } | ||
| /** | ||
| * Returns true if the passed value is "plain" object, i.e. an object whose | ||
| * protoype is the root `Object.prototype`. This includes objects created | ||
| * using object literals, but not for instance for class instances. | ||
| * | ||
| * @param {any} value The value to inspect. | ||
| * @returns {boolean} True if the argument appears to be a plain object. | ||
| */ | ||
| function isPlainObject(value) { | ||
| if (typeof value !== 'object' || value === null) return false; | ||
| var proto = value; | ||
| while (Object.getPrototypeOf(proto) !== null) { | ||
| proto = Object.getPrototypeOf(proto); | ||
| } | ||
| return Object.getPrototypeOf(value) === proto; | ||
| } | ||
| /** | ||
| * Returns true if the passed value is "plain", i.e. a value that is either | ||
| * directly JSON-serializable (boolean, number, string, array, plain object) | ||
| * or `undefined`. | ||
| * | ||
| * @param val The value to check. | ||
| */ | ||
| function isPlain(val) { | ||
| return typeof val === 'undefined' || val === null || typeof val === 'string' || typeof val === 'boolean' || typeof val === 'number' || Array.isArray(val) || isPlainObject(val); | ||
| } | ||
| var NON_SERIALIZABLE_STATE_MESSAGE = | ||
| /*#__PURE__*/ | ||
| ['A non-serializable value was detected in the state, in the path: `%s`. Value: %o', 'Take a look at the reducer(s) handling this action type: %s.', '(See https://redux.js.org/faq/organizing-state#can-i-put-functions-promises-or-other-non-serializable-items-in-my-store-state)'].join('\n'); | ||
| var NON_SERIALIZABLE_ACTION_MESSAGE = | ||
| /*#__PURE__*/ | ||
| ['A non-serializable value was detected in an action, in the path: `%s`. Value: %o', 'Take a look at the logic that dispatched this action: %o.', '(See https://redux.js.org/faq/actions#why-should-type-be-a-string-or-at-least-serializable-why-should-my-action-types-be-constants)'].join('\n'); | ||
| function findNonSerializableValue(value, path, isSerializable, getEntries) { | ||
| if (path === void 0) { | ||
| path = []; | ||
| } | ||
| if (isSerializable === void 0) { | ||
| isSerializable = isPlain; | ||
| } | ||
| var foundNestedSerializable; | ||
| if (!isSerializable(value)) { | ||
| return { | ||
| keyPath: path.join('.') || '<root>', | ||
| value: value | ||
| }; | ||
| } | ||
| if (typeof value !== 'object' || value === null) { | ||
| return false; | ||
| } | ||
| var entries = getEntries != null ? getEntries(value) : Object.entries(value); | ||
| for (var _iterator = entries, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { | ||
| var _ref; | ||
| if (_isArray) { | ||
| if (_i >= _iterator.length) break; | ||
| _ref = _iterator[_i++]; | ||
| } else { | ||
| _i = _iterator.next(); | ||
| if (_i.done) break; | ||
| _ref = _i.value; | ||
| } | ||
| var _ref2 = _ref, | ||
| property = _ref2[0], | ||
| nestedValue = _ref2[1]; | ||
| var nestedPath = path.concat(property); | ||
| if (!isSerializable(nestedValue)) { | ||
| return { | ||
| keyPath: nestedPath.join('.'), | ||
| value: nestedValue | ||
| }; | ||
| } | ||
| if (typeof nestedValue === 'object') { | ||
| foundNestedSerializable = findNonSerializableValue(nestedValue, nestedPath, isSerializable, getEntries); | ||
| if (foundNestedSerializable) { | ||
| return foundNestedSerializable; | ||
| } | ||
| } | ||
| } | ||
| return false; | ||
| } | ||
| /** | ||
| * Creates a middleware that, after every state change, checks if the new | ||
| * state is serializable. If a non-serializable value is found within the | ||
| * state, an error is printed to the console. | ||
| * | ||
| * @param options Middleware options. | ||
| */ | ||
| function createSerializableStateInvariantMiddleware(options) { | ||
| if (options === void 0) { | ||
| options = {}; | ||
| } | ||
| var _options = options, | ||
| _options$isSerializab = _options.isSerializable, | ||
| isSerializable = _options$isSerializab === void 0 ? isPlain : _options$isSerializab, | ||
| getEntries = _options.getEntries, | ||
| _options$ignoredActio = _options.ignoredActions, | ||
| ignoredActions = _options$ignoredActio === void 0 ? [] : _options$ignoredActio; | ||
| return function (storeAPI) { | ||
| return function (next) { | ||
| return function (action) { | ||
| if (ignoredActions.length && ignoredActions.indexOf(action.type) !== -1) { | ||
| return next(action); | ||
| } | ||
| var foundActionNonSerializableValue = findNonSerializableValue(action, [], isSerializable, getEntries); | ||
| if (foundActionNonSerializableValue) { | ||
| var keyPath = foundActionNonSerializableValue.keyPath, | ||
| value = foundActionNonSerializableValue.value; | ||
| console.error(NON_SERIALIZABLE_ACTION_MESSAGE, keyPath, value, action); | ||
| } | ||
| var result = next(action); | ||
| var state = storeAPI.getState(); | ||
| var foundStateNonSerializableValue = findNonSerializableValue(state, [], isSerializable, getEntries); | ||
| if (foundStateNonSerializableValue) { | ||
| var _keyPath = foundStateNonSerializableValue.keyPath, | ||
| _value = foundStateNonSerializableValue.value; | ||
| console.error(NON_SERIALIZABLE_STATE_MESSAGE, _keyPath, _value, action.type); | ||
| } | ||
| return result; | ||
| }; | ||
| }; | ||
| }; | ||
| } | ||
| function isBoolean(x) { | ||
| return typeof x === 'boolean'; | ||
| } | ||
| /** | ||
| * Returns any array containing the default middleware installed by | ||
| * `configureStore()`. Useful if you want to configure your store with a custom | ||
| * `middleware` array but still keep the default set. | ||
| * | ||
| * @return The default middleware used by `configureStore()`. | ||
| */ | ||
| function getDefaultMiddleware(options) { | ||
| if (options === void 0) { | ||
| options = {}; | ||
| } | ||
| var _options = options, | ||
| _options$thunk = _options.thunk, | ||
| thunk = _options$thunk === void 0 ? true : _options$thunk, | ||
| _options$immutableChe = _options.immutableCheck, | ||
| immutableCheck = _options$immutableChe === void 0 ? true : _options$immutableChe, | ||
| _options$serializable = _options.serializableCheck, | ||
| serializableCheck = _options$serializable === void 0 ? true : _options$serializable; | ||
| var middlewareArray = []; | ||
| if (thunk) { | ||
| if (isBoolean(thunk)) { | ||
| middlewareArray.push(thunkMiddleware); | ||
| } else { | ||
| middlewareArray.push(thunkMiddleware.withExtraArgument(thunk.extraArgument)); | ||
| } | ||
| } | ||
| if (process.env.NODE_ENV !== 'production') { | ||
| /* START_REMOVE_UMD */ | ||
| if (immutableCheck) { | ||
| var createImmutableStateInvariantMiddleware = require('redux-immutable-state-invariant')["default"]; | ||
| var immutableOptions = {}; | ||
| if (!isBoolean(immutableCheck)) { | ||
| immutableOptions = immutableCheck; | ||
| } | ||
| middlewareArray.unshift(createImmutableStateInvariantMiddleware(immutableOptions)); | ||
| } | ||
| /* STOP_REMOVE_UMD */ | ||
| if (serializableCheck) { | ||
| var serializableOptions = {}; | ||
| if (!isBoolean(serializableCheck)) { | ||
| serializableOptions = serializableCheck; | ||
| } | ||
| middlewareArray.push(createSerializableStateInvariantMiddleware(serializableOptions)); | ||
| } | ||
| } | ||
| return middlewareArray; | ||
| } | ||
| var IS_PRODUCTION = process.env.NODE_ENV === 'production'; | ||
| /** | ||
| * A friendly abstraction over the standard Redux `createStore()` function. | ||
| * | ||
| * @param config The store configuration. | ||
| * @returns A configured Redux store. | ||
| */ | ||
| function configureStore(options) { | ||
| var _ref = options || {}, | ||
| _ref$reducer = _ref.reducer, | ||
| reducer = _ref$reducer === void 0 ? undefined : _ref$reducer, | ||
| _ref$middleware = _ref.middleware, | ||
| middleware = _ref$middleware === void 0 ? getDefaultMiddleware() : _ref$middleware, | ||
| _ref$devTools = _ref.devTools, | ||
| devTools = _ref$devTools === void 0 ? true : _ref$devTools, | ||
| _ref$preloadedState = _ref.preloadedState, | ||
| preloadedState = _ref$preloadedState === void 0 ? undefined : _ref$preloadedState, | ||
| _ref$enhancers = _ref.enhancers, | ||
| enhancers = _ref$enhancers === void 0 ? undefined : _ref$enhancers; | ||
| var rootReducer; | ||
| if (typeof reducer === 'function') { | ||
| rootReducer = reducer; | ||
| } else if (isPlainObject(reducer)) { | ||
| rootReducer = combineReducers(reducer); | ||
| } else { | ||
| throw new Error('"reducer" is a required argument, and must be a function or an object of functions that can be passed to combineReducers'); | ||
| } | ||
| var middlewareEnhancer = applyMiddleware.apply(void 0, middleware); | ||
| var finalCompose = compose; | ||
| if (devTools) { | ||
| finalCompose = composeWithDevTools(_extends({ | ||
| // Enable capture of stack traces for dispatched Redux actions | ||
| trace: !IS_PRODUCTION | ||
| }, typeof devTools === 'object' && devTools)); | ||
| } | ||
| var storeEnhancers = [middlewareEnhancer]; | ||
| if (Array.isArray(enhancers)) { | ||
| storeEnhancers = [middlewareEnhancer].concat(enhancers); | ||
| } else if (typeof enhancers === 'function') { | ||
| storeEnhancers = enhancers(storeEnhancers); | ||
| } | ||
| var composedEnhancer = finalCompose.apply(void 0, storeEnhancers); | ||
| return createStore(rootReducer, preloadedState, composedEnhancer); | ||
| } | ||
| function createAction(type, prepareAction) { | ||
| function actionCreator() { | ||
| if (prepareAction) { | ||
| var prepared = prepareAction.apply(void 0, arguments); | ||
| if (!prepared) { | ||
| throw new Error('prepareAction did not return an object'); | ||
| } | ||
| return _extends({ | ||
| type: type, | ||
| payload: prepared.payload | ||
| }, 'meta' in prepared && { | ||
| meta: prepared.meta | ||
| }, {}, 'error' in prepared && { | ||
| error: prepared.error | ||
| }); | ||
| } | ||
| return { | ||
| type: type, | ||
| payload: arguments.length <= 0 ? undefined : arguments[0] | ||
| }; | ||
| } | ||
| actionCreator.toString = function () { | ||
| return "" + type; | ||
| }; | ||
| actionCreator.type = type; | ||
| actionCreator.match = function (action) { | ||
| return action.type === type; | ||
| }; | ||
| return actionCreator; | ||
| } | ||
| /** | ||
| * Returns the action type of the actions created by the passed | ||
| * `createAction()`-generated action creator (arbitrary action creators | ||
| * are not supported). | ||
| * | ||
| * @param action The action creator whose action type to get. | ||
| * @returns The action type used by the action creator. | ||
| */ | ||
| function getType(actionCreator) { | ||
| return "" + actionCreator; | ||
| } | ||
| /** | ||
| * A utility function that allows defining a reducer as a mapping from action | ||
| * type to *case reducer* functions that handle these action types. The | ||
| * reducer's initial state is passed as the first argument. | ||
| * | ||
| * The body of every case reducer is implicitly wrapped with a call to | ||
| * `produce()` from the [immer](https://github.com/mweststrate/immer) library. | ||
| * This means that rather than returning a new state object, you can also | ||
| * mutate the passed-in state object directly; these mutations will then be | ||
| * automatically and efficiently translated into copies, giving you both | ||
| * convenience and immutability. | ||
| * | ||
| * @param initialState The initial state to be returned by the reducer. | ||
| * @param actionsMap A mapping from action types to action-type-specific | ||
| * case redeucers. | ||
| */ | ||
| function createReducer(initialState, actionsMap) { | ||
| return function (state, action) { | ||
| if (state === void 0) { | ||
| state = initialState; | ||
| } | ||
| // @ts-ignore createNextState() produces an Immutable<Draft<S>> rather | ||
| // than an Immutable<S>, and TypeScript cannot find out how to reconcile | ||
| // these two types. | ||
| return createNextState(state, function (draft) { | ||
| var caseReducer = actionsMap[action.type]; | ||
| return caseReducer ? caseReducer(draft, action) : undefined; | ||
| }); | ||
| }; | ||
| } | ||
| function getType$1(slice, actionKey) { | ||
| return slice + "/" + actionKey; | ||
| } // internal definition is a little less restrictive | ||
| function createSlice(options) { | ||
| var name = options.name, | ||
| initialState = options.initialState; | ||
| if (!name) { | ||
| throw new Error('`name` is a required option for createSlice'); | ||
| } | ||
| var reducers = options.reducers || {}; | ||
| var extraReducers = options.extraReducers || {}; | ||
| var reducerNames = Object.keys(reducers); | ||
| var sliceCaseReducersByName = {}; | ||
| var sliceCaseReducersByType = {}; | ||
| var actionCreators = {}; | ||
| reducerNames.forEach(function (reducerName) { | ||
| var maybeReducerWithPrepare = reducers[reducerName]; | ||
| var type = getType$1(name, reducerName); | ||
| var caseReducer; | ||
| var prepareCallback; | ||
| if (typeof maybeReducerWithPrepare === 'function') { | ||
| caseReducer = maybeReducerWithPrepare; | ||
| } else { | ||
| caseReducer = maybeReducerWithPrepare.reducer; | ||
| prepareCallback = maybeReducerWithPrepare.prepare; | ||
| } | ||
| sliceCaseReducersByName[reducerName] = caseReducer; | ||
| sliceCaseReducersByType[type] = caseReducer; | ||
| actionCreators[reducerName] = prepareCallback ? createAction(type, prepareCallback) : createAction(type); | ||
| }); | ||
| var finalCaseReducers = _extends({}, extraReducers, {}, sliceCaseReducersByType); | ||
| var reducer = createReducer(initialState, finalCaseReducers); | ||
| return { | ||
| name: name, | ||
| reducer: reducer, | ||
| actions: actionCreators, | ||
| caseReducers: sliceCaseReducersByName | ||
| }; | ||
| } | ||
| export { configureStore, createAction, createReducer, createSerializableStateInvariantMiddleware, createSlice, findNonSerializableValue, getDefaultMiddleware, getType, isPlain }; | ||
| throw new Error('🚨 redux-starter-kit has been renamed to @reduxjs/toolkit. Please uninstall redux-starter-kit and install @reduxjs/toolkit instead. Learn more about this change here: https://github.com/reduxjs/redux-toolkit/releases/tag/v1.0.4 . Thanks! :)'); | ||
| //# sourceMappingURL=redux-starter-kit.esm.js.map |
@@ -1,2 +0,2 @@ | ||
| !function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e=e||self).RSK={})}(this,(function(e){"use strict";var t=function(e){var t,r=("undefined"!=typeof self?self:"undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof module?module:Function("return this")()).Symbol;return"function"==typeof r?r.observable?t=r.observable:(t=r("observable"),r.observable=t):t="@@observable",t}(),r=function(){return Math.random().toString(36).substring(7).split("").join(".")},n={INIT:"@@redux/INIT"+r(),REPLACE:"@@redux/REPLACE"+r(),PROBE_UNKNOWN_ACTION:function(){return"@@redux/PROBE_UNKNOWN_ACTION"+r()}};function o(e,r,i){var a;if("function"==typeof r&&"function"==typeof i||"function"==typeof i&&"function"==typeof arguments[3])throw new Error("It looks like you are passing several store enhancers to createStore(). This is not supported. Instead, compose them together to a single function");if("function"==typeof r&&void 0===i&&(i=r,r=void 0),void 0!==i){if("function"!=typeof i)throw new Error("Expected the enhancer to be a function.");return i(o)(e,r)}if("function"!=typeof e)throw new Error("Expected the reducer to be a function.");var u=e,c=r,f=[],s=f,l=!1;function p(){s===f&&(s=f.slice())}function d(){if(l)throw new Error("You may not call store.getState() while the reducer is executing. The reducer has already received the state as an argument. Pass it down from the top reducer instead of reading it from the store.");return c}function h(e){if("function"!=typeof e)throw new Error("Expected the listener to be a function.");if(l)throw new Error("You may not call store.subscribe() while the reducer is executing. If you would like to be notified after the store has been updated, subscribe from a component and invoke store.getState() in the callback to access the latest state. See https://redux.js.org/api-reference/store#subscribe(listener) for more details.");var t=!0;return p(),s.push(e),function(){if(t){if(l)throw new Error("You may not unsubscribe from a store listener while the reducer is executing. See https://redux.js.org/api-reference/store#subscribe(listener) for more details.");t=!1,p();var r=s.indexOf(e);s.splice(r,1)}}}function y(e){if(!function(e){if("object"!=typeof e||null===e)return!1;for(var t=e;null!==Object.getPrototypeOf(t);)t=Object.getPrototypeOf(t);return Object.getPrototypeOf(e)===t}(e))throw new Error("Actions must be plain objects. Use custom middleware for async actions.");if(void 0===e.type)throw new Error('Actions may not have an undefined "type" property. Have you misspelled a constant?');if(l)throw new Error("Reducers may not dispatch actions.");try{l=!0,c=u(c,e)}finally{l=!1}for(var t=f=s,r=0;r<t.length;r++)(0,t[r])();return e}return y({type:n.INIT}),(a={dispatch:y,subscribe:h,getState:d,replaceReducer:function(e){if("function"!=typeof e)throw new Error("Expected the nextReducer to be a function.");u=e,y({type:n.REPLACE})}})[t]=function(){var e,r=h;return(e={subscribe:function(e){if("object"!=typeof e||null===e)throw new TypeError("Expected the observer to be an object.");function t(){e.next&&e.next(d())}return t(),{unsubscribe:r(t)}}})[t]=function(){return this},e},a}function i(e,t){var r=t&&t.type;return"Given "+(r&&'action "'+String(r)+'"'||"an action")+', reducer "'+e+'" returned undefined. To ignore an action, you must explicitly return the previous state. If you want this reducer to hold no value, you can return null instead of undefined.'}function a(e){for(var t=Object.keys(e),r={},o=0;o<t.length;o++){var a=t[o];"function"==typeof e[a]&&(r[a]=e[a])}var u,c=Object.keys(r);try{!function(e){Object.keys(e).forEach((function(t){var r=e[t];if(void 0===r(void 0,{type:n.INIT}))throw new Error('Reducer "'+t+"\" returned undefined during initialization. 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.");if(void 0===r(void 0,{type:n.PROBE_UNKNOWN_ACTION()}))throw new Error('Reducer "'+t+"\" returned undefined when probed with a random type. Don't try to handle "+n.INIT+' or other actions in "redux/*" namespace. They are considered private. Instead, you must return the current state for any unknown actions, unless it is undefined, in which case you must return the initial state, regardless of the action type. The initial state may not be undefined, but can be null.')}))}(r)}catch(e){u=e}return function(e,t){if(void 0===e&&(e={}),u)throw u;for(var n=!1,o={},a=0;a<c.length;a++){var f=c[a],s=e[f],l=(0,r[f])(s,t);if(void 0===l){var p=i(f,t);throw new Error(p)}o[f]=l,n=n||l!==s}return n?o:e}}function u(e,t){return function(){return t(e.apply(this,arguments))}}function c(e,t,r){return t in e?Object.defineProperty(e,t,{value:r,enumerable:!0,configurable:!0,writable:!0}):e[t]=r,e}function f(e){for(var t=1;t<arguments.length;t++){var r=null!=arguments[t]?arguments[t]:{},n=Object.keys(r);"function"==typeof Object.getOwnPropertySymbols&&(n=n.concat(Object.getOwnPropertySymbols(r).filter((function(e){return Object.getOwnPropertyDescriptor(r,e).enumerable})))),n.forEach((function(t){c(e,t,r[t])}))}return e}function s(){for(var e=arguments.length,t=new Array(e),r=0;r<e;r++)t[r]=arguments[r];return 0===t.length?function(e){return e}:1===t.length?t[0]:t.reduce((function(e,t){return function(){return e(t.apply(void 0,arguments))}}))}function l(){for(var e=arguments.length,t=new Array(e),r=0;r<e;r++)t[r]=arguments[r];return function(e){return function(){var r=e.apply(void 0,arguments),n=function(){throw new Error("Dispatching while constructing your middleware is not allowed. Other middleware would not be applied to this dispatch.")},o={getState:r.getState,dispatch:function(){return n.apply(void 0,arguments)}},i=t.map((function(e){return e(o)}));return f({},r,{dispatch:n=s.apply(void 0,i)(r.dispatch)})}}}var p,d=s,h="undefined"!=typeof Symbol?Symbol("immer-nothing"):((p={})["immer-nothing"]=!0,p),y="undefined"!=typeof Symbol&&Symbol.for?Symbol.for("immer-draftable"):"__$immer_draftable",v="undefined"!=typeof Symbol&&Symbol.for?Symbol.for("immer-state"):"__$immer_state";function b(e){return!!e&&!!e[v]}function g(e){return!!e&&(function(e){if(!e||"object"!=typeof e)return!1;if(Array.isArray(e))return!0;var t=Object.getPrototypeOf(e);return!t||t===Object.prototype}(e)||!!e[y]||!!e.constructor[y])}var m=Object.assign||function(e,t){for(var r in t)P(t,r)&&(e[r]=t[r]);return e},w="undefined"!=typeof Reflect&&Reflect.ownKeys?Reflect.ownKeys:void 0!==Object.getOwnPropertySymbols?function(e){return Object.getOwnPropertyNames(e).concat(Object.getOwnPropertySymbols(e))}:Object.getOwnPropertyNames;function O(e,t){if(void 0===t&&(t=!1),Array.isArray(e))return e.slice();var r=Object.create(Object.getPrototypeOf(e));return w(e).forEach((function(n){if(n!==v){var o=Object.getOwnPropertyDescriptor(e,n),i=o.value;if(o.get){if(!t)throw new Error("Immer drafts cannot have computed properties");i=o.get.call(e)}o.enumerable?r[n]=i:Object.defineProperty(r,n,{value:i,writable:!0,configurable:!0})}})),r}function E(e,t){if(Array.isArray(e))for(var r=0;r<e.length;r++)t(r,e[r],e);else w(e).forEach((function(r){return t(r,e[r],e)}))}function j(e,t){var r=Object.getOwnPropertyDescriptor(e,t);return!!r&&r.enumerable}function P(e,t){return Object.prototype.hasOwnProperty.call(e,t)}function A(e,t){return e===t?0!==e||1/e==1/t:e!=e&&t!=t}function z(e){if(!g(e))return e;if(Array.isArray(e))return e.map(z);var t=Object.create(Object.getPrototypeOf(e));for(var r in e)t[r]=z(e[r]);return t}function x(e){if(g(e)&&!b(e)&&!Object.isFrozen(e))if(Object.freeze(e),Array.isArray(e))e.forEach(x);else for(var t in e)x(e[t])}var S=function(e){this.drafts=[],this.parent=e,this.canAutoFreeze=!0,this.patches=null};function _(e){e[v].revoke()}S.prototype.usePatches=function(e){e&&(this.patches=[],this.inversePatches=[],this.patchListener=e)},S.prototype.revoke=function(){this.leave(),this.drafts.forEach(_),this.drafts=null},S.prototype.leave=function(){this===S.current&&(S.current=this.parent)},S.current=null,S.enter=function(){return this.current=new S(this.current)};var k={};function T(){this.revoked=!0}function N(e){return e.copy||e.base}function D(e,t){var r=e[v];if(r&&!r.finalizing){r.finalizing=!0;var n=e[t];return r.finalizing=!1,n}return e[t]}function I(e){e.modified||(e.modified=!0,e.parent&&I(e.parent))}function R(e){e.copy||(e.copy=F(e.base))}function F(e){var t=e&&e[v];if(t){t.finalizing=!0;var r=O(t.draft,!0);return t.finalizing=!1,r}return O(e)}function C(e){if(!0===e.revoked)throw new Error("Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? "+JSON.stringify(N(e)))}function U(e){for(var t=e.length-1;t>=0;t--){var r=e[t][v];r.modified||(Array.isArray(r.base)?L(r)&&I(r):M(r)&&I(r))}}function M(e){for(var t=e.base,r=e.draft,n=Object.keys(r),o=n.length-1;o>=0;o--){var i=n[o],a=t[i];if(void 0===a&&!P(t,i))return!0;var u=r[i],c=u&&u[v];if(c?c.base!==a:!A(u,a))return!0}return n.length!==Object.keys(t).length}function L(e){var t=e.draft;if(t.length!==e.base.length)return!0;var r=Object.getOwnPropertyDescriptor(t,t.length-1);return!(!r||r.get)}var W=Object.freeze({willFinalize:function(e,t,r){e.drafts.forEach((function(e){e[v].finalizing=!0})),r?b(t)&&t[v].scope===e&&U(e.drafts):(e.patches&&function e(t){if(t&&"object"==typeof t){var r=t[v];if(r){var n=r.base,o=r.draft,i=r.assigned;if(Array.isArray(t)){if(L(r)){if(I(r),i.length=!0,o.length<n.length)for(var a=o.length;a<n.length;a++)i[a]=!1;else for(var u=n.length;u<o.length;u++)i[u]=!0;for(var c=0;c<o.length;c++)void 0===i[c]&&e(o[c])}}else Object.keys(o).forEach((function(t){void 0!==n[t]||P(n,t)?i[t]||e(o[t]):(i[t]=!0,I(r))})),Object.keys(n).forEach((function(e){void 0!==o[e]||P(o,e)||(i[e]=!1,I(r))}))}}}(e.drafts[0]),U(e.drafts))},createProxy:function e(t,r){var n=Array.isArray(t),o=F(t);E(o,(function(r){!function(t,r,n){var o=k[r];o?o.enumerable=n:k[r]=o={configurable:!0,enumerable:n,get:function(){return function(t,r){C(t);var n=D(N(t),r);return t.finalizing?n:n===D(t.base,r)&&g(n)?(R(t),t.copy[r]=e(n,t)):n}(this[v],r)},set:function(e){!function(e,t,r){if(C(e),e.assigned[t]=!0,!e.modified){if(A(r,D(N(e),t)))return;I(e),R(e)}e.copy[t]=r}(this[v],r,e)}},Object.defineProperty(t,r,o)}(o,r,n||j(t,r))}));var i=r?r.scope:S.current;return Object.defineProperty(o,v,{value:{scope:i,modified:!1,finalizing:!1,finalized:!1,assigned:{},parent:r,base:t,draft:o,copy:null,revoke:T,revoked:!1},enumerable:!1,writable:!0}),i.drafts.push(o),o}});function K(e,t){var r=t?t.scope:S.current,n={scope:r,modified:!1,finalized:!1,assigned:{},parent:t,base:e,draft:null,drafts:{},copy:null,revoke:null},o=Array.isArray(e)?Proxy.revocable([n],V):Proxy.revocable(n,X),i=o.revoke,a=o.proxy;return n.draft=a,n.revoke=i,r.drafts.push(a),a}var X={get:function(e,t){if(t===v)return e;var r=e.drafts;if(!e.modified&&P(r,t))return r[t];var n=q(e)[t];if(e.finalized||!g(n))return n;if(e.modified){if(n!==B(e.base,t))return n;r=e.copy}return r[t]=K(n,e)},has:function(e,t){return t in q(e)},ownKeys:function(e){return Reflect.ownKeys(q(e))},set:function(e,t,r){if(!e.modified){var n=B(e.base,t);if(r?A(n,r)||r===e.drafts[t]:A(n,r)&&t in e.base)return!0;Y(e)}return e.assigned[t]=!0,e.copy[t]=r,!0},deleteProperty:function(e,t){return void 0!==B(e.base,t)||t in e.base?(e.assigned[t]=!1,Y(e)):e.assigned[t]&&delete e.assigned[t],e.copy&&delete e.copy[t],!0},getOwnPropertyDescriptor:function(e,t){var r=q(e),n=Reflect.getOwnPropertyDescriptor(r,t);return n&&(n.writable=!0,n.configurable=!Array.isArray(r)||"length"!==t),n},defineProperty:function(){throw new Error("Object.defineProperty() cannot be used on an Immer draft")},getPrototypeOf:function(e){return Object.getPrototypeOf(e.base)},setPrototypeOf:function(){throw new Error("Object.setPrototypeOf() cannot be used on an Immer draft")}},V={};function q(e){return e.copy||e.base}function B(e,t){var r=e[v],n=Reflect.getOwnPropertyDescriptor(r?q(r):e,t);return n&&n.value}function Y(e){e.modified||(e.modified=!0,e.copy=m(O(e.base),e.drafts),e.drafts=null,e.parent&&Y(e.parent))}E(X,(function(e,t){V[e]=function(){return arguments[0]=arguments[0][0],t.apply(this,arguments)}})),V.deleteProperty=function(e,t){if(isNaN(parseInt(t)))throw new Error("Immer only supports deleting array indices");return X.deleteProperty.call(this,e[0],t)},V.set=function(e,t,r){if("length"!==t&&isNaN(parseInt(t)))throw new Error("Immer only supports setting array indices and the 'length' property");return X.set.call(this,e[0],t,r)};var $=Object.freeze({willFinalize:function(){},createProxy:K}),G=function(e,t){for(var r=0,n=t;r<n.length;r+=1){var o=n[r],i=o.path,a=o.op,u=z(o.value);if(!i.length)throw new Error("Illegal state");for(var c=e,f=0;f<i.length-1;f++)if(!(c=c[i[f]])||"object"!=typeof c)throw new Error("Cannot apply patch, path doesn't resolve: "+i.join("/"));var s=i[i.length-1];switch(a){case"replace":c[s]=u;break;case"add":Array.isArray(c)?c.splice(s,0,u):c[s]=u;break;case"remove":Array.isArray(c)?c.splice(s,1):delete c[s];break;default:throw new Error("Unsupported patch operation: "+a)}}return e},H={useProxies:"undefined"!=typeof Proxy&&void 0!==Proxy.revocable&&"undefined"!=typeof Reflect,autoFreeze:"undefined"==typeof process&&"verifyMinified"===function(){}.name,onAssign:null,onDelete:null,onCopy:null},J=function(e){m(this,H,e),this.setUseProxies(this.useProxies),this.produce=this.produce.bind(this)};J.prototype.produce=function(e,t,r){var n,o=this;if("function"==typeof e&&"function"!=typeof t){var i=t;t=e;var a=this;return function(e){var r=this;void 0===e&&(e=i);for(var n=[],o=arguments.length-1;o-- >0;)n[o]=arguments[o+1];return a.produce(e,(function(e){return t.call.apply(t,[r,e].concat(n))}))}}if("function"!=typeof t)throw new Error("The first or second argument to `produce` must be a function");if(void 0!==r&&"function"!=typeof r)throw new Error("The third argument to `produce` must be a function or undefined");if(g(e)){var u=S.enter(),c=this.createProxy(e),f=!0;try{n=t(c),f=!1}finally{f?u.revoke():u.leave()}return n instanceof Promise?n.then((function(e){return u.usePatches(r),o.processResult(e,u)}),(function(e){throw u.revoke(),e})):(u.usePatches(r),this.processResult(n,u))}if((n=t(e))!==h)return void 0===n&&(n=e),this.maybeFreeze(n,!0),n},J.prototype.produceWithPatches=function(e,t,r){var n,o,i=this;if("function"==typeof e)return function(t){for(var r=[],n=arguments.length-1;n-- >0;)r[n]=arguments[n+1];return i.produceWithPatches(t,(function(t){return e.apply(void 0,[t].concat(r))}))};if(r)throw new Error("A patch listener cannot be passed to produceWithPatches");return[this.produce(e,t,(function(e,t){n=e,o=t})),n,o]},J.prototype.createDraft=function(e){if(!g(e))throw new Error("First argument to `createDraft` must be a plain object, an array, or an immerable object");var t=S.enter(),r=this.createProxy(e);return r[v].isManual=!0,t.leave(),r},J.prototype.finishDraft=function(e,t){var r=e&&e[v];if(!r||!r.isManual)throw new Error("First argument to `finishDraft` must be a draft returned by `createDraft`");if(r.finalized)throw new Error("The given draft is already finalized");var n=r.scope;return n.usePatches(t),this.processResult(void 0,n)},J.prototype.setAutoFreeze=function(e){this.autoFreeze=e},J.prototype.setUseProxies=function(e){this.useProxies=e,m(this,e?$:W)},J.prototype.applyPatches=function(e,t){var r;for(r=t.length-1;r>=0;r--){var n=t[r];if(0===n.path.length&&"replace"===n.op){e=n.value;break}}return b(e)?G(e,t):this.produce(e,(function(e){return G(e,t.slice(r+1))}))},J.prototype.processResult=function(e,t){var r=t.drafts[0],n=void 0!==e&&e!==r;if(this.willFinalize(t,e,n),n){if(r[v].modified)throw t.revoke(),new Error("An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.");g(e)&&(e=this.finalize(e,null,t),this.maybeFreeze(e)),t.patches&&(t.patches.push({op:"replace",path:[],value:e}),t.inversePatches.push({op:"replace",path:[],value:r[v].base}))}else e=this.finalize(r,[],t);return t.revoke(),t.patches&&t.patchListener(t.patches,t.inversePatches),e!==h?e:void 0},J.prototype.finalize=function(e,t,r){var n=this,o=e[v];if(!o)return Object.isFrozen(e)?e:this.finalizeTree(e,null,r);if(o.scope!==r)return e;if(!o.modified)return this.maybeFreeze(o.base,!0),o.base;if(!o.finalized){if(o.finalized=!0,this.finalizeTree(o.draft,t,r),this.onDelete)if(this.useProxies){var i=o.assigned;for(var a in i)i[a]||this.onDelete(o,a)}else{var u=o.copy;E(o.base,(function(e){P(u,e)||n.onDelete(o,e)}))}this.onCopy&&this.onCopy(o),this.autoFreeze&&r.canAutoFreeze&&Object.freeze(o.copy),t&&r.patches&&function(e,t,r,n){Array.isArray(e.base)?function(e,t,r,n){var o,i,a=e.base,u=e.copy,c=e.assigned;u.length<a.length&&(a=(o=[u,a])[0],u=o[1],r=(i=[n,r])[0],n=i[1]);for(var f=u.length-a.length,s=0;a[s]===u[s]&&s<a.length;)++s;for(var l=a.length;l>s&&a[l-1]===u[l+f-1];)--l;for(var p=s;p<l;++p)if(c[p]&&u[p]!==a[p]){var d=t.concat([p]);r.push({op:"replace",path:d,value:u[p]}),n.push({op:"replace",path:d,value:a[p]})}for(var h=r.length,y=l+f-1;y>=l;--y){var v=t.concat([y]);r[h+y-l]={op:"add",path:v,value:u[y]},n.push({op:"remove",path:v})}}(e,t,r,n):function(e,t,r,n){var o=e.base,i=e.copy;E(e.assigned,(function(e,a){var u=o[e],c=i[e],f=a?e in o?"replace":"add":"remove";if(u!==c||"replace"!==f){var s=t.concat(e);r.push("remove"===f?{op:f,path:s}:{op:f,path:s,value:c}),n.push("add"===f?{op:"remove",path:s}:"remove"===f?{op:"add",path:s,value:u}:{op:"replace",path:s,value:u})}}))}(e,t,r,n)}(o,t,r.patches,r.inversePatches)}return o.copy},J.prototype.finalizeTree=function(e,t,r){var n=this,o=e[v];o&&(this.useProxies||(o.copy=O(o.draft,!0)),e=o.copy);var i=!!t&&!!r.patches,a=function(u,c,f){if(c===f)throw Error("Immer forbids circular references");var s=!!o&&f===e;if(b(c)){var l=s&&i&&!o.assigned[u]?t.concat(u):null;if(b(c=n.finalize(c,l,r))&&(r.canAutoFreeze=!1),Array.isArray(f)||j(f,u)?f[u]=c:Object.defineProperty(f,u,{value:c}),s&&c===o.base[u])return}else{if(s&&A(c,o.base[u]))return;g(c)&&!Object.isFrozen(c)&&(E(c,a),n.maybeFreeze(c))}s&&n.onAssign&&n.onAssign(o,u,c)};return E(e,a),e},J.prototype.maybeFreeze=function(e,t){void 0===t&&(t=!1),this.autoFreeze&&!b(e)&&(t?x(e):Object.freeze(e))};var Q=new J,Z=Q.produce;function ee(e,t){return e===t}function te(e,t,r){if(null===t||null===r||t.length!==r.length)return!1;for(var n=t.length,o=0;o<n;o++)if(!e(t[o],r[o]))return!1;return!0}function re(e){var t=Array.isArray(e[0])?e[0]:e;if(!t.every((function(e){return"function"==typeof e}))){var r=t.map((function(e){return typeof e})).join(", ");throw new Error("Selector creators expect all input-selectors to be functions, instead received the following types: ["+r+"]")}return t}Q.produceWithPatches.bind(Q),Q.setAutoFreeze.bind(Q),Q.setUseProxies.bind(Q),Q.applyPatches.bind(Q),Q.createDraft.bind(Q),Q.finishDraft.bind(Q);var ne=function(e){for(var t=arguments.length,r=Array(t>1?t-1:0),n=1;n<t;n++)r[n-1]=arguments[n];return function(){for(var t=arguments.length,n=Array(t),o=0;o<t;o++)n[o]=arguments[o];var i=0,a=n.pop(),u=re(n),c=e.apply(void 0,[function(){return i++,a.apply(null,arguments)}].concat(r)),f=e((function(){for(var e=[],t=u.length,r=0;r<t;r++)e.push(u[r].apply(null,arguments));return c.apply(null,e)}));return f.resultFunc=a,f.dependencies=u,f.recomputations=function(){return i},f.resetRecomputations=function(){return i=0},f}}((function(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:ee,r=null,n=null;return function(){return te(t,r,arguments)||(n=e.apply(null,arguments)),r=arguments,n}}));function oe(){return(oe=Object.assign||function(e){for(var t=1;t<arguments.length;t++){var r=arguments[t];for(var n in r)Object.prototype.hasOwnProperty.call(r,n)&&(e[n]=r[n])}return e}).apply(this,arguments)}var ie,ae=function(e,t){return function(e,t){var r=d;t.__esModule=!0,t.composeWithDevTools="undefined"!=typeof window&&window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__?window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__:function(){if(0!==arguments.length)return"object"==typeof arguments[0]?r:r.apply(null,arguments)},t.devToolsEnhancer="undefined"!=typeof window&&window.__REDUX_DEVTOOLS_EXTENSION__?window.__REDUX_DEVTOOLS_EXTENSION__:function(){return function(e){return e}}}(t={exports:{}},t.exports),t.exports}();(ie=ae)&&ie.__esModule&&Object.prototype.hasOwnProperty.call(ie,"default");var ue=ae.composeWithDevTools;function ce(e){if("object"!=typeof e||null===e)return!1;for(var t=e;null!==Object.getPrototypeOf(t);)t=Object.getPrototypeOf(t);return Object.getPrototypeOf(e)===t}function fe(e){return function(t){var r=t.dispatch,n=t.getState;return function(t){return function(o){return"function"==typeof o?o(r,n,e):t(o)}}}}var se=fe();function le(e){return null==e||"string"==typeof e||"boolean"==typeof e||"number"==typeof e||Array.isArray(e)||ce(e)}se.withExtraArgument=fe;var pe=["A non-serializable value was detected in the state, in the path: `%s`. Value: %o","Take a look at the reducer(s) handling this action type: %s.","(See https://redux.js.org/faq/organizing-state#can-i-put-functions-promises-or-other-non-serializable-items-in-my-store-state)"].join("\n"),de=["A non-serializable value was detected in an action, in the path: `%s`. Value: %o","Take a look at the logic that dispatched this action: %o.","(See https://redux.js.org/faq/actions#why-should-type-be-a-string-or-at-least-serializable-why-should-my-action-types-be-constants)"].join("\n");function he(e,t,r,n){var o;if(void 0===t&&(t=[]),void 0===r&&(r=le),!r(e))return{keyPath:t.join(".")||"<root>",value:e};if("object"!=typeof e||null===e)return!1;var i=null!=n?n(e):Object.entries(e),a=Array.isArray(i),u=0;for(i=a?i:i[Symbol.iterator]();;){var c;if(a){if(u>=i.length)break;c=i[u++]}else{if((u=i.next()).done)break;c=u.value}var f=c[1],s=t.concat(c[0]);if(!r(f))return{keyPath:s.join("."),value:f};if("object"==typeof f&&(o=he(f,s,r,n)))return o}return!1}function ye(e){void 0===e&&(e={});var t=e.thunk,r=void 0===t||t,n=[];return r&&(function(e){return"boolean"==typeof e}(r)?n.push(se):n.push(se.withExtraArgument(r.extraArgument))),n}function ve(e,t){function r(){if(t){var r=t.apply(void 0,arguments);if(!r)throw new Error("prepareAction did not return an object");return oe({type:e,payload:r.payload},"meta"in r&&{meta:r.meta},{},"error"in r&&{error:r.error})}return{type:e,payload:arguments.length<=0?void 0:arguments[0]}}return r.toString=function(){return""+e},r.type=e,r.match=function(t){return t.type===e},r}function be(e,t){return function(r,n){return void 0===r&&(r=e),Z(r,(function(e){var r=t[n.type];return r?r(e,n):void 0}))}}e.__DO_NOT_USE__ActionTypes=n,e.applyMiddleware=l,e.bindActionCreators=function(e,t){if("function"==typeof e)return u(e,t);if("object"!=typeof e||null===e)throw new Error("bindActionCreators expected an object or a function, instead received "+(null===e?"null":typeof e)+'. Did you write "import ActionCreators from" instead of "import * as ActionCreators from"?');for(var r=Object.keys(e),n={},o=0;o<r.length;o++){var i=r[o],a=e[i];"function"==typeof a&&(n[i]=u(a,t))}return n},e.combineReducers=a,e.compose=s,e.configureStore=function(e){var t,r=e||{},n=r.reducer,i=void 0===n?void 0:n,u=r.middleware,c=void 0===u?ye():u,f=r.devTools,p=void 0===f||f,d=r.preloadedState,h=void 0===d?void 0:d,y=r.enhancers,v=void 0===y?void 0:y;if("function"==typeof i)t=i;else{if(!ce(i))throw new Error('"reducer" is a required argument, and must be a function or an object of functions that can be passed to combineReducers');t=a(i)}var b=l.apply(void 0,c),g=s;p&&(g=ue(oe({trace:!1},"object"==typeof p&&p)));var m=[b];return Array.isArray(v)?m=[b].concat(v):"function"==typeof v&&(m=v(m)),o(t,h,g.apply(void 0,m))},e.createAction=ve,e.createNextState=Z,e.createReducer=be,e.createSelector=ne,e.createSerializableStateInvariantMiddleware=function(e){void 0===e&&(e={});var t=e.isSerializable,r=void 0===t?le:t,n=e.getEntries,o=e.ignoredActions,i=void 0===o?[]:o;return function(e){return function(t){return function(o){if(i.length&&-1!==i.indexOf(o.type))return t(o);var a=he(o,[],r,n);a&&console.error(de,a.keyPath,a.value,o);var u=t(o),c=he(e.getState(),[],r,n);return c&&console.error(pe,c.keyPath,c.value,o.type),u}}}},e.createSlice=function(e){var t=e.name,r=e.initialState;if(!t)throw new Error("`name` is a required option for createSlice");var n=e.reducers||{},o=e.extraReducers||{},i=Object.keys(n),a={},u={},c={};i.forEach((function(e){var r,o,i=n[e],f=t+"/"+e;"function"==typeof i?r=i:(r=i.reducer,o=i.prepare),a[e]=r,u[f]=r,c[e]=o?ve(f,o):ve(f)}));var f=be(r,oe({},o,{},u));return{name:t,reducer:f,actions:c,caseReducers:a}},e.createStore=o,e.findNonSerializableValue=he,e.getDefaultMiddleware=ye,e.getType=function(e){return""+e},e.isPlain=le})); | ||
| !function(e){"function"==typeof define&&define.amd?define(e):e()}((function(){"use strict";throw new Error("🚨 redux-starter-kit has been renamed to @reduxjs/toolkit. Please uninstall redux-starter-kit and install @reduxjs/toolkit instead. Learn more about this change here: https://github.com/reduxjs/redux-toolkit/releases/tag/v1.0.4 . Thanks! :)")})); | ||
| //# sourceMappingURL=redux-starter-kit.umd.min.js.map |
| { | ||
| "name": "redux-starter-kit", | ||
| "version": "1.0.1", | ||
| "version": "2.0.0", | ||
| "description": "A simple set of tools to make using Redux easier", | ||
@@ -5,0 +5,0 @@ "repository": "https://github.com/reduxjs/redux-starter-kit", |
@@ -1,41 +0,3 @@ | ||
| # Redux Starter Kit | ||
| # `redux-starter-kit` has moved to `@reduxjs/toolkit`. Please uninstall `redux-starter-kit` and install `@reduxjs/toolkit` instead. | ||
| [](https://travis-ci.org/reduxjs/redux-starter-kit) | ||
| [](https://www.npmjs.com/package/redux-starter-kit) | ||
| [](https://www.npmjs.com/package/redux-starter-kit) | ||
| **A simple set of tools to make using Redux easier** | ||
| `npm install redux-starter-kit` | ||
| (Special thanks to Github user @shotak for donating to the package name.) | ||
| ### Purpose | ||
| The Redux Starter Kit package is intended to help address three common concerns about Redux: | ||
| - "Configuring a Redux store is too complicated" | ||
| - "I have to add a lot of packages to get Redux to do anything useful" | ||
| - "Redux requires too much boilerplate code" | ||
| We can't solve every use case, but in the spirit of [`create-react-app`](https://github.com/facebook/create-react-app) and [`apollo-boost`](https://dev-blog.apollodata.com/zero-config-graphql-state-management-27b1f1b3c2c3), we can try to provide some tools that abstract over the setup process and handle the most common use cases, as well as include some useful utilities that will let the user simplify their application code. | ||
| This package is _not_ intended to solve every possible concern about Redux, and is deliberately limited in scope. It does _not_ address concepts like "reusable encapsulated Redux modules", data fetching, folder or file structures, managing entity relationships in the store, and so on. | ||
| ### What's Included | ||
| Redux Starter Kit includes: | ||
| - A `configureStore()` function with simplified configuration options. It can automatically combine your slice reducers, adds whatever Redux middleware you supply, includes `redux-thunk` by default, and enables use of the Redux DevTools Extension. | ||
| - A `createReducer()` utility that lets you supply a lookup table of action types to case reducer functions, rather than writing switch statements. In addition, it automatically uses the [`immer` library](https://github.com/mweststrate/immer) to let you write simpler immutable updates with normal mutative code, like `state.todos[3].completed = true`. | ||
| - A `createAction()` utility that returns an action creator function for the given action type string. The function itself has `toString()` defined, so that it can be used in place of the type constant. | ||
| - A `createSlice()` function that accepts a set of reducer functions, a slice name, and an initial state value, and automatically generates corresponding action creators, types, and simple selector functions. | ||
| - The `createSelector` utility from the [Reselect](https://github.com/reduxjs/reselect) library, re-exported for ease of use. | ||
| ## Documentation | ||
| The Redux Starter Kit docs are now published at **https://redux-starter-kit.js.org**. | ||
| We're currently expanding and rewriting our docs content - check back soon for more updates! | ||
| ## Learn more about this change here: https://github.com/reduxjs/redux-toolkit/releases/tag/v1.0.4 Thanks! :) |
@@ -1,10 +0,3 @@ | ||
| export * from 'redux' | ||
| export { default as createNextState } from 'immer' | ||
| export { createSelector } from 'reselect' | ||
| export * from './configureStore' | ||
| export * from './createAction' | ||
| export * from './createReducer' | ||
| export * from './createSlice' | ||
| export * from './serializableStateInvariantMiddleware' | ||
| export * from './getDefaultMiddleware' | ||
| throw new Error( | ||
| '🚨 redux-starter-kit has been renamed to @reduxjs/toolkit. Please uninstall redux-starter-kit and install @reduxjs/toolkit instead. Learn more about this change here: https://github.com/reduxjs/redux-toolkit/releases/tag/v1.0.4 . Thanks! :)' | ||
| ) |
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is too big to display
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
New alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Major refactor
Supply chain riskPackage has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.
Found 1 instance in 1 package
Fixed alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Deprecated
MaintenanceThe maintainer of the package marked it as deprecated. This could indicate that a single version should not be used, or that the package is no longer maintained and any new vulnerabilities will not be fixed.
Found 1 instance in 1 package
Minified code
QualityThis package contains minified code. This may be harmless in some cases where minified code is included in packaged libraries, however packages on npm should not minify code.
Found 1 instance in 1 package
Improved metrics
- Number of medium maintenance alerts
- decreased by-100%
0
- Number of low quality alerts
- decreased by-50%
1
- Number of low supply chain risk alerts
- decreased by-50%
2
Worsened metrics
- Total package byte prevSize
- decreased by-98.69%
7829
- Number of package files
- decreased by-45.16%
17
- Lines of code
- decreased by-99.35%
33
- Number of lines in readme file
- decreased by-90.48%
4
- Number of medium supply chain risk alerts
- increased byInfinity%
1
No dependency changes