@tramvai/state 2.70.0 → 2.72.0

package/lib/connect/toProps/mergeProps.es.js

@@ -0,0 +1,36 @@
+import { verifyPlainObject } from '../utils/verifyPlainObject.es.js';
+
+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];
+
+export { mergePropsFactories, whenMergePropsIsFunction, whenMergePropsIsOmitted };

package/lib/connect/toProps/mergeProps.js

@@ -0,0 +1,42 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var verifyPlainObject = require('../utils/verifyPlainObject.js');
+
+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.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];
+
+exports.mergePropsFactories = mergePropsFactories;
+exports.whenMergePropsIsFunction = whenMergePropsIsFunction;
+exports.whenMergePropsIsOmitted = whenMergePropsIsOmitted;

package/lib/connect/toProps/wrapMapToProps.es.js

@@ -0,0 +1,73 @@
+import always from '@tinkoff/utils/function/always';
+import mapObject from '@tinkoff/utils/object/map';
+import { verifyPlainObject } from '../utils/verifyPlainObject.es.js';
+import { verifyFunction } from '../utils/verifyFunction.es.js';
+
+function wrapMapToPropsConstant(getConstant) {
+    return function initConstantSelector(context, options) {
+        const constantSelector = always(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((action, actionName) => {
+            if (process.env.NODE_ENV !== 'production') {
+                verifyFunction(action, displayName, actionName);
+            }
+            return (params) => executeAction(action, params);
+        }, actionsObject);
+    }
+    return wrapMapToPropsConstant(getConstant);
+}
+
+export { getDependsOnOwnProps, wrapMapToPropsConstant, wrapMapToPropsFunc, wrapMapToPropsObject };

package/lib/connect/toProps/wrapMapToProps.js

@@ -0,0 +1,85 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var always = require('@tinkoff/utils/function/always');
+var mapObject = require('@tinkoff/utils/object/map');
+var verifyPlainObject = require('../utils/verifyPlainObject.js');
+var verifyFunction = require('../utils/verifyFunction.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var always__default = /*#__PURE__*/_interopDefaultLegacy(always);
+var mapObject__default = /*#__PURE__*/_interopDefaultLegacy(mapObject);
+
+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.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.verifyFunction(action, displayName, actionName);
+            }
+            return (params) => executeAction(action, params);
+        }, actionsObject);
+    }
+    return wrapMapToPropsConstant(getConstant);
+}
+
+exports.getDependsOnOwnProps = getDependsOnOwnProps;
+exports.wrapMapToPropsConstant = wrapMapToPropsConstant;
+exports.wrapMapToPropsFunc = wrapMapToPropsFunc;
+exports.wrapMapToPropsObject = wrapMapToPropsObject;

package/lib/connect/utils/verifyFunction.es.js

@@ -0,0 +1,10 @@
+import isFunction from '@tinkoff/utils/is/function';
+import { getLogger } from '../../logger.es.js';
+
+function verifyFunction(value, displayName, methodName) {
+    if (!isFunction(value)) {
+        getLogger().debug(`${methodName}() in ${displayName} must be a function. Instead received ${JSON.stringify(value)}.`);
+    }
+}
+
+export { verifyFunction };

package/lib/connect/utils/verifyFunction.js

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var isFunction = require('@tinkoff/utils/is/function');
+var logger = require('../../logger.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var isFunction__default = /*#__PURE__*/_interopDefaultLegacy(isFunction);
+
+function verifyFunction(value, displayName, methodName) {
+    if (!isFunction__default["default"](value)) {
+        logger.getLogger().debug(`${methodName}() in ${displayName} must be a function. Instead received ${JSON.stringify(value)}.`);
+    }
+}
+
+exports.verifyFunction = verifyFunction;

package/lib/connect/utils/verifyMapToProps.es.js

@@ -0,0 +1,20 @@
+import shallowEqual from '@tinkoff/utils/is/shallowEqual';
+import { getLogger } from '../../logger.es.js';
+
+const verifyMapToProps = (mapStateToProps, name) => {
+    function verify(state, props) {
+        const firstStateProps = mapStateToProps(state, props);
+        const secondStateProps = mapStateToProps(state, props);
+        if (!shallowEqual(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;
+};
+
+export { verifyMapToProps };

package/lib/connect/utils/verifyMapToProps.js

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var shallowEqual = require('@tinkoff/utils/is/shallowEqual');
+var logger = require('../../logger.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var shallowEqual__default = /*#__PURE__*/_interopDefaultLegacy(shallowEqual);
+
+const verifyMapToProps = (mapStateToProps, name) => {
+    function verify(state, props) {
+        const firstStateProps = mapStateToProps(state, props);
+        const secondStateProps = mapStateToProps(state, props);
+        if (!shallowEqual__default["default"](firstStateProps, secondStateProps)) {
+            logger.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;
+};
+
+exports.verifyMapToProps = verifyMapToProps;

package/lib/connect/utils/verifyPlainObject.es.js

@@ -0,0 +1,10 @@
+import isPlainObject from '@tinkoff/utils/is/plainObject';
+import { getLogger } from '../../logger.es.js';
+
+function verifyPlainObject(value, displayName, methodName) {
+    if (!isPlainObject(value)) {
+        getLogger().debug(`${methodName}() in ${displayName} must return a plain object. Instead received ${value}.`);
+    }
+}
+
+export { verifyPlainObject };

package/lib/connect/utils/verifyPlainObject.js

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var isPlainObject = require('@tinkoff/utils/is/plainObject');
+var logger = require('../../logger.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var isPlainObject__default = /*#__PURE__*/_interopDefaultLegacy(isPlainObject);
+
+function verifyPlainObject(value, displayName, methodName) {
+    if (!isPlainObject__default["default"](value)) {
+        logger.getLogger().debug(`${methodName}() in ${displayName} must return a plain object. Instead received ${value}.`);
+    }
+}
+
+exports.verifyPlainObject = verifyPlainObject;

package/lib/createEvent/createEvent.es.js

@@ -0,0 +1,22 @@
+import isString from '@tinkoff/utils/is/string';
+import identity from '@tinkoff/utils/function/identity';
+
+function createEvent(eventName, payloadCreator = identity) {
+    if (process.env.NODE_ENV !== 'production') {
+        if (!isString(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;
+}
+
+export { createEvent };

package/lib/createEvent/createEvent.js

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var isString = require('@tinkoff/utils/is/string');
+var identity = require('@tinkoff/utils/function/identity');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var isString__default = /*#__PURE__*/_interopDefaultLegacy(isString);
+var identity__default = /*#__PURE__*/_interopDefaultLegacy(identity);
+
+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;
+}
+
+exports.createEvent = createEvent;

package/lib/createReducer/createReducer.es.js

@@ -0,0 +1,60 @@
+import { createEvent } from '../createEvent/createEvent.es.js';
+import { SimpleEmitter } from '../stores/SimpleEmitter.es.js';
+
+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;
+}
+
+export { createReducer };

package/lib/createReducer/createReducer.js

@@ -0,0 +1,64 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var createEvent = require('../createEvent/createEvent.js');
+var SimpleEmitter = require('../stores/SimpleEmitter.js');
+
+function createReducer(name, initialState) {
+    var _a;
+    const reducers = {};
+    return _a = class ReducerStore extends SimpleEmitter.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.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;
+}
+
+exports.createReducer = createReducer;

package/lib/devTools/constants.es.js

@@ -0,0 +1,3 @@
+const DISPATCH = 'DISPATCH';
+
+export { DISPATCH };

package/lib/devTools/constants.js

@@ -0,0 +1,7 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const DISPATCH = 'DISPATCH';
+
+exports.DISPATCH = DISPATCH;

package/lib/{index_middleware.es.js → devTools/devTools.es.js}

@@ -1,5 +1,5 @@
-import pick from '@tinkoff/utils/object/pick';
 import noop from '@tinkoff/utils/function/noop';
+import pick from '@tinkoff/utils/object/pick';
 import startsWith from '@tinkoff/utils/string/startsWith';
 import isElement from '@tinkoff/utils/is/element';
 
@@ -33,38 +33,4 @@ if (typeof window !== 'undefined' && window.__REDUX_DEVTOOLS_EXTENSION__) {
     });
 }
 
-const DISPATCH = 'DISPATCH';
-
-const middleware = ({ pickState } = {}) => (api) => (next) => {
-    const getState = pickState && pickState.length ? () => pick(pickState, api.getState()) : api.getState;
-    // TODO: типизировать message
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    devTools.subscribe((message) => {
-        if (message.type === 'DISPATCH' && message.state) {
-            switch (message.payload.type) {
-                                // TODO: имплементировать все возможные действия из DevTools
-            }
-        }
-        else if (message.type === 'ACTION' && message.payload) {
-            try {
-                // eslint-disable-next-line no-new-func
-                const action = new Function(`return ${message.payload}`)();
-                api.dispatch(action);
-            }
-            catch (e) {
-                devTools.error(e.message);
-            }
-        }
-    });
-    devTools.init(getState());
-    return (event) => {
-        const result = next(event);
-        devTools.send({
-            type: `${DISPATCH} ${event.type}`,
-            event,
-        }, getState());
-        return result;
-    };
-};
-
-export { middleware };
+export { devTools };

package/lib/{index_middleware.js → devTools/devTools.js}

@@ -2,21 +2,21 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var pick = require('@tinkoff/utils/object/pick');
 var noop = require('@tinkoff/utils/function/noop');
+var pick = require('@tinkoff/utils/object/pick');
 var startsWith = require('@tinkoff/utils/string/startsWith');
 var isElement = require('@tinkoff/utils/is/element');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-var pick__default = /*#__PURE__*/_interopDefaultLegacy(pick);
 var noop__default = /*#__PURE__*/_interopDefaultLegacy(noop);
+var pick__default = /*#__PURE__*/_interopDefaultLegacy(pick);
 var startsWith__default = /*#__PURE__*/_interopDefaultLegacy(startsWith);
 var isElement__default = /*#__PURE__*/_interopDefaultLegacy(isElement);
 
 const elementReplacer = pick__default["default"](['tagName', 'id', 'className']);
 // eslint-disable-next-line import/no-mutable-exports
-let devTools = {
+exports.devTools = {
     init: noop__default["default"],
     send: noop__default["default"],
     subscribe: noop__default["default"],
@@ -25,7 +25,7 @@ let devTools = {
 // eslint-disable-next-line no-underscore-dangle,@typescript-eslint/no-explicit-any
 if (typeof window !== 'undefined' && window.__REDUX_DEVTOOLS_EXTENSION__) {
     // eslint-disable-next-line no-underscore-dangle,@typescript-eslint/no-explicit-any
-    devTools = window.__REDUX_DEVTOOLS_EXTENSION__.connect({
+    exports.devTools = window.__REDUX_DEVTOOLS_EXTENSION__.connect({
         name: 'Tinkoff-client',
         latency: 700,
         serialize: {
@@ -43,39 +43,3 @@ if (typeof window !== 'undefined' && window.__REDUX_DEVTOOLS_EXTENSION__) {
         },
     });
 }
-
-const DISPATCH = 'DISPATCH';
-
-const middleware = ({ pickState } = {}) => (api) => (next) => {
-    const getState = pickState && pickState.length ? () => pick__default["default"](pickState, api.getState()) : api.getState;
-    // TODO: типизировать message
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    devTools.subscribe((message) => {
-        if (message.type === 'DISPATCH' && message.state) {
-            switch (message.payload.type) {
-                                // TODO: имплементировать все возможные действия из DevTools
-            }
-        }
-        else if (message.type === 'ACTION' && message.payload) {
-            try {
-                // eslint-disable-next-line no-new-func
-                const action = new Function(`return ${message.payload}`)();
-                api.dispatch(action);
-            }
-            catch (e) {
-                devTools.error(e.message);
-            }
-        }
-    });
-    devTools.init(getState());
-    return (event) => {
-        const result = next(event);
-        devTools.send({
-            type: `${DISPATCH} ${event.type}`,
-            event,
-        }, getState());
-        return result;
-    };
-};
-
-exports.middleware = middleware;