@tramvai/state 2.70.0 → 2.72.0

package/lib/index.js

@@ -2,1290 +2,45 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var compose = require('@tinkoff/utils/function/compose');
-var isString = require('@tinkoff/utils/is/string');
-var identity = require('@tinkoff/utils/function/identity');
-var pick = require('@tinkoff/utils/object/pick');
-var shallowEqual = require('@tinkoff/utils/is/shallowEqual');
-var strictEqual = require('@tinkoff/utils/is/strictEqual');
-var jsxRuntime = require('react/jsx-runtime');
-var noop = require('@tinkoff/utils/function/noop');
-var hoistStatics = require('hoist-non-react-statics');
-var invariant = require('invariant');
-var React = require('react');
-var reactIs = require('react-is');
-var shim = require('use-sync-external-store/shim');
-var isArray = require('@tinkoff/utils/is/array');
+var index = require('./devTools/index.js');
+var dispatcher = require('./dispatcher/dispatcher.js');
+var dispatcherContext = require('./dispatcher/dispatcherContext.js');
+var childDispatcherContext = require('./dispatcher/childDispatcherContext.js');
+var createEvent = require('./createEvent/createEvent.js');
+var createReducer = require('./createReducer/createReducer.js');
+var BaseStore = require('./stores/BaseStore.js');
+var index$1 = require('./connect/index.js');
+var Subscription = require('./connect/Subscription.js');
+var Provider = require('./connect/Provider.js');
+var useConsumerContext = require('./connect/hooks/useConsumerContext.js');
+var useActions = require('./connect/hooks/useActions.js');
+var useStore = require('./connect/hooks/useStore.js');
+var useSelector = require('./connect/hooks/useSelector.js');
+var useStoreSelector = require('./connect/hooks/useStoreSelector.js');
 var reactHooks = require('@tinkoff/react-hooks');
-var toArray = require('@tinkoff/utils/array/toArray');
-var withSelector = require('use-sync-external-store/shim/with-selector');
-var always = require('@tinkoff/utils/function/always');
-var mapObject = require('@tinkoff/utils/object/map');
-var isPlainObject = require('@tinkoff/utils/is/plainObject');
-var isFunction = require('@tinkoff/utils/is/function');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-var compose__default = /*#__PURE__*/_interopDefaultLegacy(compose);
-var isString__default = /*#__PURE__*/_interopDefaultLegacy(isString);
-var identity__default = /*#__PURE__*/_interopDefaultLegacy(identity);
-var pick__default = /*#__PURE__*/_interopDefaultLegacy(pick);
-var shallowEqual__default = /*#__PURE__*/_interopDefaultLegacy(shallowEqual);
-var strictEqual__default = /*#__PURE__*/_interopDefaultLegacy(strictEqual);
-var noop__default = /*#__PURE__*/_interopDefaultLegacy(noop);
-var hoistStatics__default = /*#__PURE__*/_interopDefaultLegacy(hoistStatics);
-var invariant__default = /*#__PURE__*/_interopDefaultLegacy(invariant);
-var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
-var isArray__default = /*#__PURE__*/_interopDefaultLegacy(isArray);
-var toArray__default = /*#__PURE__*/_interopDefaultLegacy(toArray);
-var always__default = /*#__PURE__*/_interopDefaultLegacy(always);
-var mapObject__default = /*#__PURE__*/_interopDefaultLegacy(mapObject);
-var isPlainObject__default = /*#__PURE__*/_interopDefaultLegacy(isPlainObject);
-var isFunction__default = /*#__PURE__*/_interopDefaultLegacy(isFunction);
-
-/*
-### TODO
-
-Монорепозиторий экосистемы [redux-devtools](https://github.com/reduxjs/redux-devtools)
-
-Пример кастомной [интеграции redux-devtools с mobx](https://github.com/zalmoxisus/mobx-remotedev/blob/master/src/monitorActions.js)
-
-Интегрированный в DevTools функционал:
-
-1. Лог экшенов
-2. Состояние стейта
-3. Dispatch
-4. ~~Time Traveling~~
- */
-// eslint-disable-next-line import/no-mutable-exports
-let middleware = () => () => (next) => (event) => next(event);
-if (process.env.NODE_ENV !== 'production') {
-    middleware = require('./index_middleware.js').middleware;
-}
-
-var index = {
-    __proto__: null,
-    get middleware () { return middleware; }
-};
-
-const subscribe = (store, handler) => {
-    // подписываемся на изменения
-    store.on('change', handler);
-    // вызываем сразу, чтобы заполнить начальное состояние
-    handler();
-};
-
-class SimpleEmitter {
-    constructor() {
-        this.listeners = [];
-    }
-    emit(name) {
-        this.listeners.forEach((listener) => {
-            listener();
-        });
-    }
-    addListener(event, fn) {
-        this.listeners.push(fn);
-    }
-    on(event, fn) {
-        this.addListener(event, fn);
-    }
-    removeListener(event, fn) {
-        const listeners = [];
-        for (let i = 0; i < this.listeners.length; i++) {
-            if (this.listeners[i] !== fn) {
-                listeners.push(this.listeners[i]);
-            }
-        }
-        this.listeners = listeners;
-    }
-    off(event, fn) {
-        this.removeListener(event, fn);
-    }
-}
-
-const eventExecutor = (event, handlerFns) => {
-    const keys = Object.keys(handlerFns);
-    for (let index = 0; index < keys.length; index++) {
-        const storeName = keys[index];
-        const handlerFn = handlerFns[storeName];
-        if (!handlerFn) {
-            throw new Error(`${storeName} does not have a handler for action ${event.type}`);
-        }
-        handlerFn(event.payload, event.type);
-    }
-};
-// Конвертация старого типа экшенов в новый
-const convertAction = (actionOrNameEvent, payload) => {
-    if (typeof actionOrNameEvent === 'string') {
-        return {
-            payload,
-            type: actionOrNameEvent,
-            error: false,
-        };
-    }
-    return actionOrNameEvent;
-};
-// Это форкнутый вариант dispatchr
-class DispatcherContext extends SimpleEmitter {
-    /**
-     * @param context The context to be used for store instances
-     */
-    constructor(dispatcher, context, initialState, middlewares) {
-        super();
-        this.applyDispatch = (event) => {
-            const eventHandlers = this.dispatcher.handlers[event.type] || [];
-            if (!eventHandlers.length) {
-                if (process.env.NODE_ENV === 'development') {
-                    console.warn(`
-The event "${event.type}" has been dispatched, but no reducers for this event were registered.
-Have you forgot to register reducer or add event handler in existing reducer?
-`);
-                }
-                return event.payload;
-            }
-            this.applyHandlers(event, eventHandlers);
-            return event.payload;
-        };
-        this.dispatcher = dispatcher;
-        this.storeInstances = {};
-        this.storeUnsubscribeCallbacks = {};
-        this.context = context;
-        this.dispatcherInterface = {
-            getContext: () => this.context,
-            getStore: this.getStore.bind(this),
-        };
-        this.rehydratedStoreState = {};
-        this.fullState = {};
-        // Заполняем стейт данными
-        if (initialState) {
-            this.rehydrate(initialState);
-        }
-        if (middlewares === null || middlewares === void 0 ? void 0 : middlewares.length) {
-            this.applyDispatch = this.applyMiddlewares(middlewares);
-        }
-        // Инцииализируем уже имеющиеся сторы
-        Object.keys(this.dispatcher.stores).forEach((store) => {
-            this.getStore(store);
-        });
-    }
-    applyMiddlewares(middlewares) {
-        let dispatch = (...args) => {
-            throw new Error('Dispatching while constructing your middleware is not allowed. Other middleware would not be applied to this dispatch.');
-        };
-        const api = {
-            getState: this.getState.bind(this),
-            subscribe: this.subscribe.bind(this),
-            dispatch: (...args) => dispatch(...args),
-        };
-        dispatch = compose__default["default"](...middlewares.map((middleware) => middleware(api)))(this.applyDispatch);
-        return dispatch;
-    }
-    storeSubscribe(storeName, storeInstance) {
-        const subscribeHandler = () => {
-            const newState = storeInstance.getState();
-            if (newState !== this.fullState[storeName]) {
-                this.fullState = {
-                    ...this.fullState,
-                    [storeName]: newState,
-                };
-                this.emit('change');
-            }
-        };
-        subscribe(storeInstance, subscribeHandler);
-        const unsubscribe = () => {
-            storeInstance.off('change', subscribeHandler);
-        };
-        this.storeUnsubscribeCallbacks[storeName] = unsubscribe;
-    }
-    // eslint-disable-next-line max-statements
-    getStore(storeClass) {
-        let storeClassPrepared;
-        let optional = false;
-        if (typeof storeClass === 'object') {
-            storeClassPrepared = storeClass.store;
-            optional = storeClass.optional;
-        }
-        else {
-            storeClassPrepared = storeClass;
-        }
-        const storeName = this.dispatcher.getStoreName(storeClassPrepared);
-        if (!this.storeInstances[storeName]) {
-            let Store = this.dispatcher.stores[storeName];
-            if (!Store) {
-                if (typeof storeClassPrepared === 'function') {
-                    this.dispatcher.registerStore(storeClassPrepared);
-                    Store = storeClassPrepared;
-                }
-                else {
-                    if (optional) {
-                        return null;
-                    }
-                    throw new Error(`Store ${storeName} was not registered.`);
-                }
-            }
-            const storeInstance = new Store(this.dispatcherInterface);
-            this.storeInstances[storeName] = storeInstance;
-            if (this.rehydratedStoreState && this.rehydratedStoreState[storeName]) {
-                const state = this.rehydratedStoreState[storeName];
-                if (storeInstance.rehydrate) {
-                    storeInstance.rehydrate(state);
-                }
-                this.rehydratedStoreState[storeName] = null;
-            }
-            this.storeSubscribe(storeName, storeInstance);
-            // TODO: убрать после того отпадёт надобность связывать сторы router и application
-            if (Store.dependencies) {
-                Store.dependencies.forEach((dependencyStoreClass) => {
-                    const dependency = this.getStore(dependencyStoreClass);
-                    subscribe(dependency, () => {
-                        storeInstance.emit('change');
-                    });
-                });
-            }
-        }
-        return this.storeInstances[storeName];
-    }
-    /**
-     * Dispatches a new action or throws if one is already in progress
-     * @param eventOrType Name of the event to be dispatched
-     * @param payload Parameters to describe the action
-     * @throws {Error} if store has handler registered that does not exist
-     */
-    dispatch(eventOrType, payload) {
-        if (!eventOrType) {
-            throw new Error(`eventOrType parameter ${eventOrType} is invalid.`);
-        }
-        // конвертим старый тип экшенов
-        const event = convertAction(eventOrType, payload);
-        return this.applyDispatch(event);
-    }
-    applyHandlers(action, handlers) {
-        const handlerFns = {};
-        const storeInstanceGet = (store) => {
-            if (handlerFns[store.name]) {
-                // Don't call the default if the store has an explicit action handler
-                return;
-            }
-            const storeInstance = this.getStore(store.name);
-            if (!storeInstance) {
-                return;
-            }
-            if (typeof store.handler === 'function') {
-                handlerFns[store.name] = store.handler.bind(storeInstance);
-            }
-            else {
-                if (process.env.NODE_ENV !== 'production') {
-                    if (!storeInstance[store.handler]) {
-                        throw new Error(`${store.name} does not have a method called ${store.handler}`);
-                    }
-                }
-                handlerFns[store.name] = storeInstance[store.handler].bind(storeInstance);
-            }
-        };
-        const handlersLength = handlers.length;
-        for (let index = 0; index < handlersLength; index++) {
-            storeInstanceGet(handlers[index]);
-        }
-        return eventExecutor(action, handlerFns);
-    }
-    /**
-     * Returns a raw data object representation of the current state of the
-     * dispatcher and all store instances. If the store implements a shouldDehdyrate
-     * function, then it will be called and only dehydrate if the method returns `true`
-     * @method dehydrate
-     * @returns dehydrated dispatcher data
-     */
-    dehydrate() {
-        const stores = {};
-        const keys = Object.keys(this.storeInstances);
-        for (let i = 0; i < keys.length; i++) {
-            const storeName = keys[i];
-            const store = this.storeInstances[storeName];
-            if (!store.dehydrate()) {
-                continue;
-            }
-            stores[storeName] = store.dehydrate();
-        }
-        return {
-            stores,
-        };
-    }
-    /**
-     * Takes a raw data object and rehydrates the dispatcher and store instances
-     * @method rehydrate
-     * @param dispatcherState raw state typically retrieved from `dehydrate` method
-     */
-    rehydrate(dispatcherState) {
-        if (dispatcherState.stores) {
-            const keys = Object.keys(dispatcherState.stores);
-            for (let index = 0; index < keys.length; index++) {
-                const storeName = keys[index];
-                this.rehydratedStoreState[storeName] = dispatcherState.stores[storeName];
-            }
-        }
-    }
-    subscribe(...args) {
-        if ('storeName' in args[0]) {
-            const reducer = args[0];
-            const callback = args[1];
-            const reducerInstance = this.getStore(reducer);
-            const listener = () => {
-                const state = this.getState(reducer);
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                callback(state);
-            };
-            reducerInstance.on('change', listener);
-            return () => {
-                reducerInstance.off('change', listener);
-            };
-        }
-        const callback = args[0];
-        const listener = () => {
-            const state = this.getState();
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            callback(state);
-        };
-        this.on('change', listener);
-        return () => {
-            this.off('change', listener);
-        };
-    }
-    getState(reducer) {
-        if (reducer) {
-            return this.fullState[reducer.storeName];
-        }
-        return this.fullState;
-    }
-    // Для отложенной инициализации контекста, в будующем нужно удалить
-    setContext(context) {
-        this.context = context;
-    }
-    hasStore(store) {
-        return store.storeName in this.storeInstances && this.dispatcher.hasStore(store);
-    }
-    registerStore(store) {
-        this.dispatcher.registerStore(store);
-        this.getStore(store);
-    }
-    unregisterStore(store) {
-        const { storeName } = store;
-        this.dispatcher.unregisterStore(store);
-        this.storeUnsubscribeCallbacks[storeName]();
-        delete this.storeUnsubscribeCallbacks[storeName];
-        delete this.rehydratedStoreState[storeName];
-        delete this.storeInstances[storeName];
-    }
-}
-
-class Dispatcher {
-    /**
-     * @class Dispatcher
-     * @param options Dispatcher options
-     * @param options.stores Array of stores to register
-     * @constructor
-     */
-    constructor(options) {
-        // eslint-disable-next-line no-param-reassign
-        options = options || {};
-        // eslint-disable-next-line no-param-reassign
-        options.stores = options.stores || [];
-        this.stores = {};
-        this.handlers = {};
-        options.stores.forEach((store) => {
-            this.registerStore(store);
-        });
-    }
-    createContext(context, initialState, middlewares) {
-        return new DispatcherContext(this, context, initialState, middlewares);
-    }
-    hasStore(store) {
-        return !!this.stores[store.storeName];
-    }
-    /**
-     * Registers a store so that it can handle actions.ß
-     * @param store A store class to be registered. The store should have a static
-     *      `storeName` property so that it can be loaded later.
-     * @throws {Error} if store is invalid
-     * @throws {Error} if store is already registered
-     */
-    registerStore(store) {
-        const { storeName } = store;
-        if (this.stores[storeName]) {
-            if (this.stores[storeName] === store) {
-                // Store is already registered, nothing to do
-                return;
-            }
-            if (process.env.NODE_ENV !== 'production') {
-                throw new Error(`Store with name '${storeName}' has already been registered.
-                Make sure you do not have multiple copies of the store installed.
-                exist ${this.stores[storeName]}
-                try ${store}`);
-            }
-        }
-        this.stores[storeName] = store;
-        if (store.handlers) {
-            Object.keys(store.handlers).forEach((action) => {
-                const handler = store.handlers[action];
-                this.registerHandler(action, storeName, handler);
-            });
-        }
-    }
-    unregisterStore(store) {
-        const { storeName } = store;
-        if (!this.stores[storeName]) {
-            return;
-        }
-        delete this.stores[storeName];
-        if (store.handlers) {
-            Object.keys(store.handlers).forEach((action) => {
-                const handler = store.handlers[action];
-                this.unregisterHandler(action, storeName, handler);
-            });
-        }
-    }
-    /**
-     * Gets a name from a store
-     * @param {String|Object} store The store name or class from which to extract
-     */
-    // eslint-disable-next-line class-methods-use-this
-    getStoreName(store) {
-        if (typeof store === 'string') {
-            return store;
-        }
-        return store.storeName;
-    }
-    /**
-     * Adds a handler function to be called for the given action
-     * @param action Name of the action
-     * @param name Name of the store that handles the action
-     * @param handler The function or name of the method that handles the action
-     */
-    registerHandler(action, name, handler) {
-        this.handlers[action] = this.handlers[action] || [];
-        this.handlers[action].push({
-            name,
-            handler,
-        });
-    }
-    unregisterHandler(action, name, handler) {
-        if (Array.isArray(this.handlers[action])) {
-            this.handlers[action] = this.handlers[action].filter((actionHandlers) => {
-                return !(actionHandlers.name === name && actionHandlers.handler === handler);
-            });
-        }
-    }
-}
-function createDispatcher(options) {
-    return new Dispatcher(options);
-}
-
-class ChildDispatcherContext extends DispatcherContext {
-    /**
-     * @param context The context to be used for store instances
-     */
-    constructor({ dispatcher, context, initialState, parentDispatcherContext, middlewares, parentAllowedStores, }) {
-        super(dispatcher, context, initialState, middlewares);
-        this.allowedParentStores = new Set();
-        this.parentDispatcherContext = parentDispatcherContext;
-        parentAllowedStores === null || parentAllowedStores === void 0 ? void 0 : parentAllowedStores.forEach((store) => {
-            const storeName = this.dispatcher.getStoreName(typeof store === 'object' ? store.store : store);
-            this.allowedParentStores.add(storeName);
-            // use just storeName to prevent store initialization on the root-app side
-            this.getStore({ store: storeName, optional: true });
-        });
-    }
-    getStore(storeClass) {
-        let storeClassPrepared;
-        if (typeof storeClass === 'object') {
-            storeClassPrepared = storeClass.store;
-        }
-        else {
-            storeClassPrepared = storeClass;
-        }
-        const storeName = this.dispatcher.getStoreName(storeClassPrepared);
-        if (this.dispatcher.stores[storeName]) {
-            return super.getStore(storeClass);
-        }
-        if (this.allowedParentStores.has(storeName)) {
-            // use just storeName to prevent store initialization on the root-app side
-            const storeInstance = this.parentDispatcherContext.getStore({
-                store: storeName,
-                optional: true,
-            });
-            if (!storeInstance) {
-                return null;
-            }
-            this.storeSubscribe(storeName, storeInstance);
-            return storeInstance;
-        }
-        return super.getStore(storeClass);
-    }
-}
-
-function createEvent(eventName, payloadCreator = identity__default["default"]) {
-    if (process.env.NODE_ENV !== 'production') {
-        if (!isString__default["default"](eventName) || !eventName.length) {
-            throw new Error(`eventName should be not empty string, got '${eventName}'`);
-        }
-    }
-    const type = eventName;
-    const eventCreator = (...args) => {
-        return {
-            type,
-            payload: payloadCreator(...args),
-        };
-    };
-    eventCreator.getType = () => type;
-    eventCreator.toString = () => type;
-    return eventCreator;
-}
-
-function createReducer(name, initialState) {
-    var _a;
-    const reducers = {};
-    return _a = class ReducerStore extends SimpleEmitter {
-            constructor() {
-                super();
-                this.state = initialState;
-            }
-            static createEvents(model) {
-                const eventNames = Object.keys(model);
-                const events = {};
-                eventNames.forEach((eventName) => {
-                    const handler = model[eventName];
-                    const eventCreator = createEvent(`${eventName}`);
-                    events[eventName] = eventCreator;
-                    ReducerStore.on(eventCreator, handler);
-                });
-                return events;
-            }
-            static on(eventOrType, reducer) {
-                if (Array.isArray(eventOrType)) {
-                    eventOrType.forEach((event) => ReducerStore.on(event, reducer));
-                    return ReducerStore;
-                }
-                const type = eventOrType.toString();
-                ReducerStore.handlers[type] = 'handle';
-                reducers[type] = reducer;
-                return ReducerStore;
-            }
-            getState() {
-                return this.state;
-            }
-            setState(state) {
-                this.state = state;
-                // обновление необходимо, иначе state-manager не пересчитает состояние
-                this.emit('change');
-            }
-            dehydrate() {
-                return this.state;
-            }
-            rehydrate(state) {
-                this.state = state;
-            }
-            handle(payload, eventName) {
-                const reducer = reducers[eventName];
-                if (reducer) {
-                    this.state = reducer(this.state, payload);
-                    this.emit('change');
-                }
-            }
-        },
-        _a.storeName = name,
-        _a.handlers = {},
-        _a;
-}
-
-/**
- * @deprecated метод устарел, в замен этого API используй createReducer, который новее и лучше маштабируется
- */
-class BaseStore extends SimpleEmitter {
-    constructor() {
-        super(...arguments);
-        this.state = Object.create(null);
-        this.hydrateKeys = Object.create(null);
-    }
-    getState() {
-        return this.state;
-    }
-    dehydrate() {
-        return pick__default["default"](Object.keys(this.hydrateKeys), this.state);
-    }
-    rehydrate(state) {
-        this.setStateSilently(state);
-    }
-    writeHydrateKeys(state) {
-        Object.keys(state).forEach((key) => {
-            this.hydrateKeys[key] = true;
-        });
-    }
-    // eslint-disable-next-line class-methods-use-this
-    shouldStateUpdate(nextState) {
-        return !!Object.keys(nextState).length;
-    }
-    setState(state, force = false) {
-        if (force || this.shouldStateUpdate(state)) {
-            this.setStateSilently(state);
-            this.emit('change');
-        }
-    }
-    setStateSilently(state) {
-        this.state = { ...this.state, ...state };
-        this.writeHydrateKeys(state);
-    }
-    replaceState(state) {
-        this.replaceStateSilently(state);
-        this.emit('change');
-    }
-    // @deprecated нужно использовать replaceState
-    replaceStateSilently(state) {
-        this.state = state;
-        this.hydrateKeys = Object.create(null);
-        this.writeHydrateKeys(state);
-    }
-}
-
-// encapsulates the subscription logic for connecting a component to the redux store, as
-// well as nesting subscriptions of descendant components, so that we can ensure the
-// ancestor components re-render before descendants
-class Subscription {
-    constructor(stores) {
-        this.handleStateChange = () => {
-            this.onStateChange && this.onStateChange();
-        };
-        this.stores = stores;
-        this.unsubscribe = undefined;
-    }
-    isSubscribed() {
-        return Boolean(this.unsubscribe);
-    }
-    setOnStateChange(onStateChange) {
-        this.onStateChange = onStateChange;
-    }
-    trySubscribe() {
-        if (!this.unsubscribe) {
-            this.unsubscribe = this.stores.filter(Boolean).map((store) => {
-                store.on('change', this.handleStateChange);
-                return () => {
-                    store.removeListener('change', this.handleStateChange);
-                };
-            });
-        }
-    }
-    tryUnsubscribe() {
-        if (this.unsubscribe) {
-            this.unsubscribe.forEach((f) => f());
-            this.unsubscribe = undefined;
-        }
-        this.onStateChange = undefined;
-    }
-}
-
-const ConnectContext = /* #__PURE__*/ React.createContext(null);
-const ServerStateContext = /* #__PURE__*/ React.createContext(null);
-
-const useConsumerContext = () => {
-    const context = React.useContext(ConnectContext);
-    if (!context) {
-        throw new Error('CONSUMER_CONTEXT not found, have you added "@tramvai/module-common"?');
-    }
-    return context;
-};
-
-function useActions(actions) {
-    const context = useConsumerContext();
-    const actionsRef = reactHooks.useShallowEqual(actions);
-    return React.useMemo(() => {
-        if (isArray__default["default"](actionsRef)) {
-            return actionsRef.map((action) => context.executeAction.bind(context, action));
-        }
-        return context.executeAction.bind(context, actionsRef);
-    }, [actionsRef, context]);
-}
-
-function useStore(reducer) {
-    const context = useConsumerContext();
-    const serverState = React.useContext(ServerStateContext);
-    const reducerRef = React.useRef(reducer);
-    const addedReducerRef = React.useRef(null);
-    // если текущий редьюсер не зарегистрирован в диспетчере,
-    // регистрируем его вручную, что бы гарантировать работоспособность `context.getState(reducer)`,
-    // и сохраняем в `addedReducerRef`, что бы удалить при unmount
-    if (!context.hasStore(reducer)) {
-        context.registerStore(reducer);
-        addedReducerRef.current = reducer.storeName;
-    }
-    const subscribe = React.useCallback((reactUpdate) => {
-        const unsubscribe = context.subscribe(reducer, reactUpdate);
-        // заменяем текущий редьюсер
-        reducerRef.current = reducer;
-        return () => {
-            // гарантируем отписку от обновлений текущего редьюсера,
-            // при анмаунте компонента
-            unsubscribe();
-            // если текущий редьюсер был зарегистрирован в диспетчере в этом хуке,
-            // удаляем его из диспетчера
-            if (addedReducerRef.current) {
-                context.unregisterStore(reducerRef.current);
-                addedReducerRef.current = null;
-            }
-        };
-    }, [reducer, context]);
-    return shim.useSyncExternalStore(subscribe, () => context.getState(reducer), serverState ? () => serverState[reducer.storeName] : () => context.getState(reducer));
-}
-
-const contextExecution = typeof window !== 'undefined' ? window : global;
-function scheduling() {
-    if ('requestAnimationFrame' in contextExecution) {
-        return requestAnimationFrame;
-    }
-    if ('setImmediate' in contextExecution) {
-        return contextExecution.setImmediate;
-    }
-    return setTimeout;
-}
-
-const schedule = /* #__PURE__*/ scheduling();
-function useSelector(storesOrStore, selector, equalityFn = shallowEqual__default["default"]) {
-    invariant__default["default"](selector, `You must pass a selector to useSelectors`);
-    const context = useConsumerContext();
-    const serverState = React.useContext(ServerStateContext);
-    const renderIsScheduled = React.useRef(false);
-    const storesRef = reactHooks.useShallowEqual(storesOrStore);
-    const subscription = React.useMemo(() => new Subscription(toArray__default["default"](storesRef).map(context.getStore)), [storesRef, context]);
-    const latestSubscriptionCallbackError = React.useRef();
-    const subscribe = React.useCallback((reactUpdate) => {
-        subscription.setOnStateChange(() => {
-            if (!renderIsScheduled.current) {
-                renderIsScheduled.current = true;
-                schedule(() => {
-                    reactUpdate();
-                    renderIsScheduled.current = false;
-                });
-            }
-        });
-        subscription.trySubscribe();
-        return () => {
-            return subscription.tryUnsubscribe();
-        };
-    }, [subscription]);
-    let selectedState;
-    try {
-        selectedState = withSelector.useSyncExternalStoreWithSelector(subscribe, context.getState, serverState ? () => serverState : context.getState, selector, equalityFn);
-    }
-    catch (err) {
-        let errorMessage = `An error occured while selecting the store state: ${err.message}.`;
-        if (latestSubscriptionCallbackError.current) {
-            errorMessage += `\nThe error may be correlated with this previous error:\n${latestSubscriptionCallbackError.current.stack}\n\nOriginal stack trace:`;
-        }
-        throw new Error(errorMessage);
-    }
-    reactHooks.useIsomorphicLayoutEffect(() => {
-        latestSubscriptionCallbackError.current = undefined;
-    });
-    return selectedState;
-}
-
-const useStoreSelector = (store, selector) => {
-    const memoizedSelector = React.useCallback((stores) => {
-        return selector(stores[store.storeName]);
-    }, [store, selector]);
-    return useSelector(store, memoizedSelector);
-};
-
-const stringifyComponent = (Comp) => {
-    try {
-        return JSON.stringify(Comp);
-    }
-    catch (err) {
-        return String(Comp);
-    }
-};
-/**
- * @deprecated
- */
-function connectAdvanced(
-/*
-  selectorFactory is a func that is responsible for returning the selector function used to
-  compute new props from state, props, and dispatch. For example:
-    export default connectAdvanced((dispatch, options) => (state, props) => ({
-      thing: state.things[props.thingId],
-      saveThing: fields => dispatch(actionCreators.saveThing(props.thingId, fields)),
-    }))(YourComponent)
-  Access to dispatch is provided to the factory so selectorFactories can bind actionCreators
-  outside of their selector as an optimization. Options passed to connectAdvanced are passed to
-  the selectorFactory, along with displayName and WrappedComponent, as the second argument.
-  Note that selectorFactory is responsible for all caching/memoization of inbound and outbound
-  props. Do not use connectAdvanced directly without memoizing results between calls to your
-  selector, otherwise the Connect component will re-render on every state or props change.
-*/
-selectorFactory, 
-// options object:
-{ 
-// the func used to compute this HOC's displayName from the wrapped component's displayName.
-// probably overridden by wrapper functions such as connect()
-getDisplayName = (name) => `ConnectAdvanced(${name})`, 
-// shown in error messages
-// probably overridden by wrapper functions such as connect()
-methodName = 'connectAdvanced', 
-// stores to connect to
-stores = [], 
-// determines whether this HOC subscribes to store changes
-shouldHandleStateChanges = true, 
-// use React's forwardRef to expose a ref of the wrapped component
-forwardRef = false, 
-// function used to schedule updates
-schedule = (fn) => fn(), 
-// is component and all toProps functions are pure, so they can be memoized
-pure = true, 
-// additional options are passed through to the selectorFactory
-...connectOptions } = {}) {
-    return function wrapWithConnect(WrappedComponent) {
-        if (process.env.NODE_ENV !== 'production') {
-            invariant__default["default"](reactIs.isValidElementType(WrappedComponent), `You must pass a component to the function returned by ` +
-                `${methodName}. Instead received ${stringifyComponent(WrappedComponent)}`);
-        }
-        const wrappedComponentName = WrappedComponent.displayName || WrappedComponent.name || 'Component';
-        const displayName = getDisplayName(wrappedComponentName);
-        const selectorFactoryOptions = {
-            ...connectOptions,
-            pure,
-            getDisplayName,
-            methodName,
-            shouldHandleStateChanges,
-            displayName,
-            wrappedComponentName,
-            WrappedComponent,
-        };
-        const ConnectFunction = (props) => {
-            const [forwardedRef, wrapperProps] = React.useMemo(() => {
-                // Distinguish between actual "data" props that were passed to the wrapper component,
-                // and values needed to control behavior (forwarded refs, alternate context instances).
-                // To maintain the wrapperProps object reference, memoize this destructuring.
-                // eslint-disable-next-line no-shadow
-                const { forwardedRef, ...wrapperProps } = props;
-                return [forwardedRef, wrapperProps];
-            }, [props]);
-            // Retrieve the store and ancestor subscription via context, if available
-            const contextValue = useConsumerContext();
-            const serverState = React.useContext(ServerStateContext);
-            invariant__default["default"](Boolean(contextValue), `Could not find context in ` +
-                `"${displayName}". Either wrap the root component in a <Provider>, ` +
-                `or pass a custom React context provider to <Provider> and the corresponding ` +
-                `React context consumer to ${displayName} in connect options.`);
-            const childPropsSelector = React.useMemo(() => {
-                // The child props selector needs the store reference as an input.
-                // Re-create this selector whenever the store changes.
-                return selectorFactory(contextValue, selectorFactoryOptions);
-            }, [contextValue]);
-            const subscription = React.useMemo(() => {
-                if (!shouldHandleStateChanges)
-                    return null;
-                return new Subscription(stores.map((store) => contextValue.getStore(store)));
-            }, [contextValue]);
-            React.useMemo(() => {
-                if (subscription && typeof window !== 'undefined') {
-                    subscription.trySubscribe();
-                }
-            }, [subscription]);
-            const renderIsScheduled = React.useRef(false);
-            const actualChildPropsSelector = React.useCallback(() => {
-                return childPropsSelector(contextValue.getState(), wrapperProps);
-            }, [contextValue, wrapperProps, childPropsSelector]);
-            // Our re-subscribe logic only runs when the store/subscription setup changes
-            const subscribe = React.useCallback((reactUpdate) => {
-                if (!subscription) {
-                    return noop__default["default"];
-                }
-                subscription.setOnStateChange(() => {
-                    if (!renderIsScheduled.current) {
-                        renderIsScheduled.current = true;
-                        schedule(() => {
-                            reactUpdate();
-                            renderIsScheduled.current = false;
-                        });
-                    }
-                });
-                return () => {
-                    return subscription.tryUnsubscribe();
-                };
-            }, [subscription]);
-            const actualChildProps = shim.useSyncExternalStore(subscribe, actualChildPropsSelector, serverState ? () => childPropsSelector(serverState, wrapperProps) : actualChildPropsSelector);
-            // Now that all that's done, we can finally try to actually render the child component.
-            // We memoize the elements for the rendered child component as an optimization.
-            const renderedWrappedComponent = React.useMemo(
-            // eslint-disable-next-line react/jsx-props-no-spreading
-            () => jsxRuntime.jsx(WrappedComponent, { ...actualChildProps, ref: forwardedRef }), [forwardedRef, actualChildProps]);
-            return renderedWrappedComponent;
-        };
-        // If we're in "pure" mode, ensure our wrapper component only re-renders when incoming props have changed.
-        const Connect = pure ? React__default["default"].memo(ConnectFunction) : ConnectFunction;
-        Connect.WrappedComponent = WrappedComponent;
-        Connect.displayName = displayName;
-        if (forwardRef) {
-            const forwarded = React__default["default"].forwardRef(function forwardConnectRef(props, ref) {
-                // eslint-disable-next-line react/jsx-props-no-spreading
-                return jsxRuntime.jsx(Connect, { ...props, forwardedRef: ref });
-            });
-            forwarded.displayName = displayName;
-            forwarded.WrappedComponent = WrappedComponent;
-            return hoistStatics__default["default"](forwarded, WrappedComponent);
-        }
-        return hoistStatics__default["default"](Connect, WrappedComponent);
-    };
-}
-
-const getLogger = () => console;
-
-function verifyPlainObject(value, displayName, methodName) {
-    if (!isPlainObject__default["default"](value)) {
-        getLogger().debug(`${methodName}() in ${displayName} must return a plain object. Instead received ${value}.`);
-    }
-}
-
-function verifyFunction(value, displayName, methodName) {
-    if (!isFunction__default["default"](value)) {
-        getLogger().debug(`${methodName}() in ${displayName} must be a function. Instead received ${JSON.stringify(value)}.`);
-    }
-}
-
-function wrapMapToPropsConstant(getConstant) {
-    return function initConstantSelector(context, options) {
-        const constantSelector = always__default["default"](getConstant(context, options));
-        constantSelector.dependsOnOwnProps = false;
-        return constantSelector;
-    };
-}
-// dependsOnOwnProps is used by createMapToPropsProxy to determine whether to pass props as args
-// to the mapToProps function being wrapped. It is also used by makePurePropsSelector to determine
-// whether mapToProps needs to be invoked when props have changed.
-//
-// A length of one signals that mapToProps does not depend on props from the parent component.
-// A length of zero is assumed to mean mapToProps is getting args via arguments or ...args and
-// therefore not reporting its length accurately..
-function getDependsOnOwnProps(mapToProps) {
-    return mapToProps.dependsOnOwnProps !== null && mapToProps.dependsOnOwnProps !== undefined
-        ? Boolean(mapToProps.dependsOnOwnProps)
-        : mapToProps.length !== 1;
-}
-// Used by whenMapStateToPropsIsFunction and whenMapDispatchToPropsIsFunction,
-// this function wraps mapToProps in a proxy function which does several things:
-//
-//  * Detects whether the mapToProps function being called depends on props, which
-//    is used by selectorFactory to decide if it should reinvoke on props changes.
-//
-//  * On first call, handles mapToProps if returns another function, and treats that
-//    new function as the true mapToProps for subsequent calls.
-//
-//  * On first call, verifies the first result is a plain object, in order to warn
-//    the developer that their mapToProps function is not returning a valid result.
-//
-function wrapMapToPropsFunc(mapToProps, methodName) {
-    return function initProxySelector(context, { displayName }) {
-        const proxy = (stateOrContext, ownProps) => proxy.dependsOnOwnProps
-            ? proxy.mapToProps(stateOrContext, ownProps)
-            : proxy.mapToProps(stateOrContext, undefined);
-        // allow detectFactoryAndVerify to get ownProps
-        proxy.dependsOnOwnProps = true;
-        proxy.mapToProps = function detectFactoryAndVerify(stateOrContext, ownProps) {
-            proxy.mapToProps = mapToProps;
-            proxy.dependsOnOwnProps = getDependsOnOwnProps(mapToProps);
-            let props = proxy(stateOrContext, ownProps);
-            if (typeof props === 'function') {
-                proxy.mapToProps = props;
-                proxy.dependsOnOwnProps = getDependsOnOwnProps(props);
-                props = proxy(stateOrContext, ownProps);
-            }
-            if (process.env.NODE_ENV !== 'production') {
-                verifyPlainObject(props, displayName, methodName);
-            }
-            return props;
-        };
-        return proxy;
-    };
-}
-function wrapMapToPropsObject(actionsObject) {
-    function getConstant({ executeAction }, { displayName }) {
-        return mapObject__default["default"]((action, actionName) => {
-            if (process.env.NODE_ENV !== 'production') {
-                verifyFunction(action, displayName, actionName);
-            }
-            return (params) => executeAction(action, params);
-        }, actionsObject);
-    }
-    return wrapMapToPropsConstant(getConstant);
-}
-
-function whenMapContextToPropsIsFunction(mapContextToProps) {
-    return typeof mapContextToProps === 'function'
-        ? wrapMapToPropsFunc(mapContextToProps, 'mapContextToProps')
-        : undefined;
-}
-function whenMapContextToPropsIsMissing(mapContextToProps) {
-    return !mapContextToProps ? wrapMapToPropsConstant(always__default["default"]({})) : undefined;
-}
-function whenMapContextToPropsIsObject(mapContextToProps) {
-    return typeof mapContextToProps === 'object' && mapContextToProps !== null
-        ? wrapMapToPropsObject(mapContextToProps)
-        : undefined;
-}
-const mapContextToPropsFactories = [
-    whenMapContextToPropsIsObject,
-    whenMapContextToPropsIsFunction,
-    whenMapContextToPropsIsMissing,
-];
-
-function whenMapStateToPropsIsFunction(mapStateToProps) {
-    return typeof mapStateToProps === 'function'
-        ? wrapMapToPropsFunc(mapStateToProps, 'mapStateToProps')
-        : undefined;
-}
-function whenMapStateToPropsIsMissing(mapStateToProps) {
-    return !mapStateToProps ? wrapMapToPropsConstant(always__default["default"]({})) : undefined;
-}
-const mapStateToPropsFactories = [
-    whenMapStateToPropsIsFunction,
-    whenMapStateToPropsIsMissing,
-];
-
-const defaultMergeProps = (stateProps, contextProps, ownProps) => {
-    return { ...ownProps, ...stateProps, ...contextProps };
-};
-function wrapMergePropsFunc(mergeProps) {
-    return function initMergePropsProxy(context, { displayName, pure, areMergedPropsEqual }) {
-        let hasRunOnce = false;
-        let mergedProps;
-        return function mergePropsProxy(stateProps, contextProps, ownProps) {
-            const nextMergedProps = mergeProps(stateProps, contextProps, ownProps);
-            if (hasRunOnce) {
-                if (!pure || !areMergedPropsEqual(nextMergedProps, mergedProps)) {
-                    mergedProps = nextMergedProps;
-                }
-            }
-            else {
-                hasRunOnce = true;
-                mergedProps = nextMergedProps;
-                if (process.env.NODE_ENV !== 'production') {
-                    verifyPlainObject(mergedProps, displayName, 'mergeProps');
-                }
-            }
-            return mergedProps;
-        };
-    };
-}
-function whenMergePropsIsFunction(mergeProps) {
-    return typeof mergeProps === 'function' ? wrapMergePropsFunc(mergeProps) : undefined;
-}
-function whenMergePropsIsOmitted(mergeProps) {
-    return !mergeProps ? () => defaultMergeProps : undefined;
-}
-const mergePropsFactories = [whenMergePropsIsFunction, whenMergePropsIsOmitted];
-
-const verifyMapToProps = (mapStateToProps, name) => {
-    function verify(state, props) {
-        const firstStateProps = mapStateToProps(state, props);
-        const secondStateProps = mapStateToProps(state, props);
-        if (!shallowEqual__default["default"](firstStateProps, secondStateProps)) {
-            getLogger().warn('Component "%s" recreate equal props %s', name, Object.keys(firstStateProps)
-                .filter((key) => firstStateProps[key] !== secondStateProps[key])
-                .map((key) => `"${key}"`)
-                .join(', '));
-        }
-        verify.dependsOnOwnProps = mapStateToProps.dependsOnOwnProps;
-        return secondStateProps;
-    }
-    return verify;
-};
-
-function impureFinalPropsSelectorFactory(mapStateToProps, mapContextToProps, mergeProps, context) {
-    return function impureFinalPropsSelector(state, ownProps) {
-        return mergeProps(mapStateToProps(state, ownProps), mapContextToProps(context, ownProps), ownProps);
-    };
-}
-// eslint-disable-next-line max-params
-function pureFinalPropsSelectorFactory(mapStateToProps, mapContextToProps, mergeProps, context, { areStatesEqual, areOwnPropsEqual, areStatePropsEqual, WrappedComponent: { defaultProps } }) {
-    let hasRunAtLeastOnce = false;
-    let state;
-    let ownProps;
-    let ownPropsWithDefault;
-    let stateProps;
-    let contextProps;
-    let mergedProps;
-    function handleFirstCall(firstState, firstOwnProps) {
-        state = firstState;
-        ownProps = firstOwnProps;
-        ownPropsWithDefault = { ...defaultProps, ...firstOwnProps }; // TODO проверить зачем мержить пропсы с defaultProps, взято из старого connect, иначе падают некоторые тесты
-        stateProps = mapStateToProps(state, ownPropsWithDefault);
-        contextProps = mapContextToProps(context, ownPropsWithDefault);
-        mergedProps = mergeProps(stateProps, contextProps, ownProps);
-        hasRunAtLeastOnce = true;
-        return mergedProps;
-    }
-    function handleNewPropsAndNewState() {
-        stateProps = mapStateToProps(state, ownPropsWithDefault);
-        if (mapContextToProps.dependsOnOwnProps) {
-            contextProps = mapContextToProps(context, ownPropsWithDefault);
-        }
-        mergedProps = mergeProps(stateProps, contextProps, ownProps);
-        return mergedProps;
-    }
-    function handleNewProps() {
-        if (mapStateToProps.dependsOnOwnProps) {
-            stateProps = mapStateToProps(state, ownPropsWithDefault);
-        }
-        if (mapContextToProps.dependsOnOwnProps) {
-            contextProps = mapContextToProps(context, ownPropsWithDefault);
-        }
-        mergedProps = mergeProps(stateProps, contextProps, ownProps);
-        return mergedProps;
-    }
-    function handleNewState() {
-        const nextStateProps = mapStateToProps(state, ownPropsWithDefault);
-        const statePropsChanged = !areStatePropsEqual(nextStateProps, stateProps);
-        stateProps = nextStateProps;
-        if (statePropsChanged) {
-            mergedProps = mergeProps(stateProps, contextProps, ownProps);
-        }
-        return mergedProps;
-    }
-    function handleSubsequentCalls(nextState, nextOwnProps) {
-        const propsChanged = !areOwnPropsEqual(nextOwnProps, ownProps);
-        const stateChanged = !areStatesEqual(nextState, state);
-        state = nextState;
-        ownProps = nextOwnProps;
-        ownPropsWithDefault = { ...defaultProps, ...nextOwnProps };
-        if (propsChanged && stateChanged) {
-            return handleNewPropsAndNewState();
-        }
-        if (propsChanged) {
-            return handleNewProps();
-        }
-        if (stateChanged) {
-            return handleNewState();
-        }
-        return mergedProps;
-    }
-    return function pureFinalPropsSelector(nextState, nextOwnProps) {
-        return hasRunAtLeastOnce
-            ? handleSubsequentCalls(nextState, nextOwnProps)
-            : handleFirstCall(nextState, nextOwnProps);
-    };
-}
-// TODO: Add more comments
-// If pure is true, the selector returned by selectorFactory will memoize its results,
-// allowing connectAdvanced's shouldComponentUpdate to return false if final
-// props have not changed. If false, the selector will always return a new
-// object and shouldComponentUpdate will always return true.
-function finalPropsSelectorFactory(context, { initMapStateToProps, initMapContextToProps, initMergeProps, ...options }) {
-    let mapStateToProps = initMapStateToProps(context, options);
-    const mapContextToProps = initMapContextToProps(context, options);
-    const mergeProps = initMergeProps(context, options);
-    if (process.env.NODE_ENV !== 'production') {
-        mapStateToProps = verifyMapToProps(mapStateToProps, options.WrappedComponent.name);
-    }
-    const selectorFactory = options.pure
-        ? pureFinalPropsSelectorFactory
-        : impureFinalPropsSelectorFactory;
-    return selectorFactory(mapStateToProps, mapContextToProps, mergeProps, context, options);
-}
-
-const Provider = ({ context, children, serverState, }) => {
-    return (jsxRuntime.jsx(ConnectContext.Provider, { value: context, children: jsxRuntime.jsx(ServerStateContext.Provider, { value: serverState, children: children }) }));
-};
-
-/*
-  connect is a facade over connectAdvanced. It turns its args into a compatible
-  selectorFactory, which has the signature:
-    (dispatch, options) => (nextState, nextOwnProps) => nextFinalProps
-
-  connect passes its args to connectAdvanced as options, which will in turn pass them to
-  selectorFactory each time a Connect component instance is instantiated or hot reloaded.
-  selectorFactory returns a final props selector from its mapStateToProps,
-  mapStateToPropsFactories, mapContextToProps, mapContextToPropsFactories, mergeProps,
-  mergePropsFactories, and pure args.
-  The resulting final props selector is called by the Connect component instance whenever
-  it receives new props or store state.
- */
-function match(arg, factories, name) {
-    for (let i = factories.length - 1; i >= 0; i--) {
-        const result = factories[i](arg);
-        if (result) {
-            return result;
-        }
-    }
-    return (context, options) => {
-        throw new Error(`Invalid value of type ${typeof arg} for ${name} argument when connecting component ${options.wrappedComponentName}.`);
-    };
-}
-// createConnect with default args builds the 'official' connect behavior. Calling it with
-// different options opens up some testing and extensibility scenarios
-/**
- * @deprecated
- */
-function createConnect({ connectHOC = connectAdvanced, mapStateToPropsFactories: mapStateToPropsFactories$1 = mapStateToPropsFactories, mapContextToPropsFactories: mapContextToPropsFactories$1 = mapContextToPropsFactories, mergePropsFactories: mergePropsFactories$1 = mergePropsFactories, selectorFactory = finalPropsSelectorFactory, schedule = scheduling(), } = {}) {
-    return (stores, mapStateToProps, mapContextToProps, mergeProps, { pure = true, areStatesEqual = strictEqual__default["default"], areOwnPropsEqual = shallowEqual__default["default"], areStatePropsEqual = shallowEqual__default["default"], areMergedPropsEqual = shallowEqual__default["default"], ...extraOptions } = {}
-    // eslint-disable-next-line max-params
-    ) => {
-        // @ts-ignore
-        const initMapStateToProps = match(mapStateToProps, mapStateToPropsFactories$1, 'mapStateToProps');
-        // @ts-ignore
-        const initMapContextToProps = match(mapContextToProps, 
-        // @ts-ignore
-        mapContextToPropsFactories$1, 'mapContextToProps');
-        // @ts-ignore
-        const initMergeProps = match(mergeProps, mergePropsFactories$1, 'mergeProps');
-        return connectHOC(selectorFactory, {
-            // @ts-ignore
-            stores,
-            // passed through to selectorFactory 2
-            // @ts-ignore
-            initMapStateToProps,
-            initMapContextToProps,
-            initMergeProps,
-            pure,
-            areStatesEqual,
-            areOwnPropsEqual,
-            areStatePropsEqual,
-            areMergedPropsEqual,
-            schedule,
-            // used in error messages
-            methodName: 'connect',
-            // used to compute Connect's displayName from the wrapped component's displayName.
-            getDisplayName: (name) => `Connect(${name})`,
-            // if mapStateToProps is falsy, the Connect component doesn't subscribe to store state changes
-            shouldHandleStateChanges: stores && stores.length > 0,
-            // any extra options args can override defaults of connect or connectAdvanced
-            ...extraOptions,
-        });
-    };
-}
-/**
- * @deprecated
- */
-const connect = /* @__PURE__ */ createConnect();
-const { Consumer } = ConnectContext;
 
+exports.devTools = index;
+exports.Dispatcher = dispatcher.Dispatcher;
+exports.createDispatcher = dispatcher.createDispatcher;
+exports.DispatcherContext = dispatcherContext.DispatcherContext;
+exports.convertAction = dispatcherContext.convertAction;
+exports.ChildDispatcherContext = childDispatcherContext.ChildDispatcherContext;
+exports.createEvent = createEvent.createEvent;
+exports.createReducer = createReducer.createReducer;
+exports.BaseStore = BaseStore.BaseStore;
+exports.Consumer = index$1.Consumer;
+exports.connect = index$1["default"];
+exports.createConnect = index$1.createConnect;
+exports.Subscription = Subscription.Subscription;
+exports.Provider = Provider.Provider;
+exports.useConsumerContext = useConsumerContext.useConsumerContext;
+exports.useActions = useActions.useActions;
+exports.useStore = useStore.useStore;
+exports.useSelector = useSelector.useSelector;
+exports.useStoreSelector = useStoreSelector.useStoreSelector;
 Object.defineProperty(exports, 'useIsomorphicLayoutEffect', {
-    enumerable: true,
-    get: function () { return reactHooks.useIsomorphicLayoutEffect; }
+	enumerable: true,
+	get: function () { return reactHooks.useIsomorphicLayoutEffect; }
 });
-exports.BaseStore = BaseStore;
-exports.ChildDispatcherContext = ChildDispatcherContext;
-exports.Consumer = Consumer;
-exports.Dispatcher = Dispatcher;
-exports.DispatcherContext = DispatcherContext;
-exports.Provider = Provider;
-exports.Subscription = Subscription;
-exports.connect = connect;
-exports.convertAction = convertAction;
-exports.createConnect = createConnect;
-exports.createDispatcher = createDispatcher;
-exports.createEvent = createEvent;
-exports.createReducer = createReducer;
-exports.devTools = index;
-exports.useActions = useActions;
-exports.useConsumerContext = useConsumerContext;
-exports.useSelector = useSelector;
-exports.useStore = useStore;
-exports.useStoreSelector = useStoreSelector;