@tramvai/state 2.70.0 → 2.72.0

package/lib/connect/hooks/useStore.es.js

@@ -0,0 +1,37 @@
+import { useContext, useRef, useCallback } from 'react';
+import { useSyncExternalStore } from 'use-sync-external-store/shim';
+import { ServerStateContext } from '../context.es.js';
+import { useConsumerContext } from './useConsumerContext.es.js';
+
+function useStore(reducer) {
+    const context = useConsumerContext();
+    const serverState = useContext(ServerStateContext);
+    const reducerRef = useRef(reducer);
+    const addedReducerRef = useRef(null);
+    // если текущий редьюсер не зарегистрирован в диспетчере,
+    // регистрируем его вручную, что бы гарантировать работоспособность `context.getState(reducer)`,
+    // и сохраняем в `addedReducerRef`, что бы удалить при unmount
+    if (!context.hasStore(reducer)) {
+        context.registerStore(reducer);
+        addedReducerRef.current = reducer.storeName;
+    }
+    const subscribe = 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 useSyncExternalStore(subscribe, () => context.getState(reducer), serverState ? () => serverState[reducer.storeName] : () => context.getState(reducer));
+}
+
+export { useStore };

package/lib/connect/hooks/useStore.js

@@ -0,0 +1,41 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var shim = require('use-sync-external-store/shim');
+var context = require('../context.js');
+var useConsumerContext = require('./useConsumerContext.js');
+
+function useStore(reducer) {
+    const context$1 = useConsumerContext.useConsumerContext();
+    const serverState = React.useContext(context.ServerStateContext);
+    const reducerRef = React.useRef(reducer);
+    const addedReducerRef = React.useRef(null);
+    // если текущий редьюсер не зарегистрирован в диспетчере,
+    // регистрируем его вручную, что бы гарантировать работоспособность `context.getState(reducer)`,
+    // и сохраняем в `addedReducerRef`, что бы удалить при unmount
+    if (!context$1.hasStore(reducer)) {
+        context$1.registerStore(reducer);
+        addedReducerRef.current = reducer.storeName;
+    }
+    const subscribe = React.useCallback((reactUpdate) => {
+        const unsubscribe = context$1.subscribe(reducer, reactUpdate);
+        // заменяем текущий редьюсер
+        reducerRef.current = reducer;
+        return () => {
+            // гарантируем отписку от обновлений текущего редьюсера,
+            // при анмаунте компонента
+            unsubscribe();
+            // если текущий редьюсер был зарегистрирован в диспетчере в этом хуке,
+            // удаляем его из диспетчера
+            if (addedReducerRef.current) {
+                context$1.unregisterStore(reducerRef.current);
+                addedReducerRef.current = null;
+            }
+        };
+    }, [reducer, context$1]);
+    return shim.useSyncExternalStore(subscribe, () => context$1.getState(reducer), serverState ? () => serverState[reducer.storeName] : () => context$1.getState(reducer));
+}
+
+exports.useStore = useStore;

package/lib/connect/hooks/useStoreSelector.es.js

@@ -0,0 +1,11 @@
+import { useCallback } from 'react';
+import { useSelector } from './useSelector.es.js';
+
+const useStoreSelector = (store, selector) => {
+    const memoizedSelector = useCallback((stores) => {
+        return selector(stores[store.storeName]);
+    }, [store, selector]);
+    return useSelector(store, memoizedSelector);
+};
+
+export { useStoreSelector };

package/lib/connect/hooks/useStoreSelector.js

@@ -0,0 +1,15 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var useSelector = require('./useSelector.js');
+
+const useStoreSelector = (store, selector) => {
+    const memoizedSelector = React.useCallback((stores) => {
+        return selector(stores[store.storeName]);
+    }, [store, selector]);
+    return useSelector.useSelector(store, memoizedSelector);
+};
+
+exports.useStoreSelector = useStoreSelector;

package/lib/connect/index.es.js

@@ -0,0 +1,91 @@
+import shallowEqual from '@tinkoff/utils/is/shallowEqual';
+import strictEqual from '@tinkoff/utils/is/strictEqual';
+import { connectAdvanced } from './connectAdvanced.es.js';
+import { mapContextToPropsFactories } from './toProps/mapContextToProps.es.js';
+import { mapStateToPropsFactories } from './toProps/mapStateToProps.es.js';
+import { mergePropsFactories } from './toProps/mergeProps.es.js';
+import { finalPropsSelectorFactory } from './selectorFactory.es.js';
+import { ConnectContext } from './context.es.js';
+import { scheduling } from './scheduling.es.js';
+import 'react/jsx-runtime';
+import 'react';
+import '@tinkoff/utils/is/array';
+export { useIsomorphicLayoutEffect } from '@tinkoff/react-hooks';
+import 'use-sync-external-store/shim';
+import 'invariant';
+import '@tinkoff/utils/array/toArray';
+import 'use-sync-external-store/shim/with-selector';
+
+/*
+  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, areOwnPropsEqual = shallowEqual, areStatePropsEqual = shallowEqual, areMergedPropsEqual = shallowEqual, ...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;
+
+export { Consumer, connect, createConnect, connect as default };

package/lib/connect/index.js

@@ -0,0 +1,107 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var shallowEqual = require('@tinkoff/utils/is/shallowEqual');
+var strictEqual = require('@tinkoff/utils/is/strictEqual');
+var connectAdvanced = require('./connectAdvanced.js');
+var mapContextToProps = require('./toProps/mapContextToProps.js');
+var mapStateToProps = require('./toProps/mapStateToProps.js');
+var mergeProps = require('./toProps/mergeProps.js');
+var selectorFactory = require('./selectorFactory.js');
+var context = require('./context.js');
+var scheduling = require('./scheduling.js');
+require('react/jsx-runtime');
+require('react');
+require('@tinkoff/utils/is/array');
+var reactHooks = require('@tinkoff/react-hooks');
+require('use-sync-external-store/shim');
+require('invariant');
+require('@tinkoff/utils/array/toArray');
+require('use-sync-external-store/shim/with-selector');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var shallowEqual__default = /*#__PURE__*/_interopDefaultLegacy(shallowEqual);
+var strictEqual__default = /*#__PURE__*/_interopDefaultLegacy(strictEqual);
+
+/*
+  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.connectAdvanced, mapStateToPropsFactories = mapStateToProps.mapStateToPropsFactories, mapContextToPropsFactories = mapContextToProps.mapContextToPropsFactories, mergePropsFactories = mergeProps.mergePropsFactories, selectorFactory: selectorFactory$1 = selectorFactory.finalPropsSelectorFactory, schedule = scheduling.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, 'mapStateToProps');
+        // @ts-ignore
+        const initMapContextToProps = match(mapContextToProps, 
+        // @ts-ignore
+        mapContextToPropsFactories, 'mapContextToProps');
+        // @ts-ignore
+        const initMergeProps = match(mergeProps, mergePropsFactories, 'mergeProps');
+        return connectHOC(selectorFactory$1, {
+            // @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 } = context.ConnectContext;
+
+Object.defineProperty(exports, 'useIsomorphicLayoutEffect', {
+  enumerable: true,
+  get: function () { return reactHooks.useIsomorphicLayoutEffect; }
+});
+exports.Consumer = Consumer;
+exports.connect = connect;
+exports.createConnect = createConnect;
+exports["default"] = connect;

package/lib/connect/scheduling.es.js

@@ -0,0 +1,12 @@
+const contextExecution = typeof window !== 'undefined' ? window : global;
+function scheduling() {
+    if ('requestAnimationFrame' in contextExecution) {
+        return requestAnimationFrame;
+    }
+    if ('setImmediate' in contextExecution) {
+        return contextExecution.setImmediate;
+    }
+    return setTimeout;
+}
+
+export { scheduling };

package/lib/connect/scheduling.js

@@ -0,0 +1,16 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const contextExecution = typeof window !== 'undefined' ? window : global;
+function scheduling() {
+    if ('requestAnimationFrame' in contextExecution) {
+        return requestAnimationFrame;
+    }
+    if ('setImmediate' in contextExecution) {
+        return contextExecution.setImmediate;
+    }
+    return setTimeout;
+}
+
+exports.scheduling = scheduling;

package/lib/connect/selectorFactory.es.js

@@ -0,0 +1,95 @@
+import { verifyMapToProps } from './utils/verifyMapToProps.es.js';
+
+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);
+}
+
+export { finalPropsSelectorFactory, impureFinalPropsSelectorFactory, pureFinalPropsSelectorFactory };

package/lib/connect/selectorFactory.js

@@ -0,0 +1,101 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var verifyMapToProps = require('./utils/verifyMapToProps.js');
+
+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.verifyMapToProps(mapStateToProps, options.WrappedComponent.name);
+    }
+    const selectorFactory = options.pure
+        ? pureFinalPropsSelectorFactory
+        : impureFinalPropsSelectorFactory;
+    return selectorFactory(mapStateToProps, mapContextToProps, mergeProps, context, options);
+}
+
+exports.finalPropsSelectorFactory = finalPropsSelectorFactory;
+exports.impureFinalPropsSelectorFactory = impureFinalPropsSelectorFactory;
+exports.pureFinalPropsSelectorFactory = pureFinalPropsSelectorFactory;

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

@@ -0,0 +1,23 @@
+import always from '@tinkoff/utils/function/always';
+import { wrapMapToPropsFunc, wrapMapToPropsConstant, wrapMapToPropsObject } from './wrapMapToProps.es.js';
+
+function whenMapContextToPropsIsFunction(mapContextToProps) {
+    return typeof mapContextToProps === 'function'
+        ? wrapMapToPropsFunc(mapContextToProps, 'mapContextToProps')
+        : undefined;
+}
+function whenMapContextToPropsIsMissing(mapContextToProps) {
+    return !mapContextToProps ? wrapMapToPropsConstant(always({})) : undefined;
+}
+function whenMapContextToPropsIsObject(mapContextToProps) {
+    return typeof mapContextToProps === 'object' && mapContextToProps !== null
+        ? wrapMapToPropsObject(mapContextToProps)
+        : undefined;
+}
+const mapContextToPropsFactories = [
+    whenMapContextToPropsIsObject,
+    whenMapContextToPropsIsFunction,
+    whenMapContextToPropsIsMissing,
+];
+
+export { mapContextToPropsFactories, whenMapContextToPropsIsFunction, whenMapContextToPropsIsMissing, whenMapContextToPropsIsObject };

package/lib/connect/toProps/mapContextToProps.js

@@ -0,0 +1,34 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var always = require('@tinkoff/utils/function/always');
+var wrapMapToProps = require('./wrapMapToProps.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var always__default = /*#__PURE__*/_interopDefaultLegacy(always);
+
+function whenMapContextToPropsIsFunction(mapContextToProps) {
+    return typeof mapContextToProps === 'function'
+        ? wrapMapToProps.wrapMapToPropsFunc(mapContextToProps, 'mapContextToProps')
+        : undefined;
+}
+function whenMapContextToPropsIsMissing(mapContextToProps) {
+    return !mapContextToProps ? wrapMapToProps.wrapMapToPropsConstant(always__default["default"]({})) : undefined;
+}
+function whenMapContextToPropsIsObject(mapContextToProps) {
+    return typeof mapContextToProps === 'object' && mapContextToProps !== null
+        ? wrapMapToProps.wrapMapToPropsObject(mapContextToProps)
+        : undefined;
+}
+const mapContextToPropsFactories = [
+    whenMapContextToPropsIsObject,
+    whenMapContextToPropsIsFunction,
+    whenMapContextToPropsIsMissing,
+];
+
+exports.mapContextToPropsFactories = mapContextToPropsFactories;
+exports.whenMapContextToPropsIsFunction = whenMapContextToPropsIsFunction;
+exports.whenMapContextToPropsIsMissing = whenMapContextToPropsIsMissing;
+exports.whenMapContextToPropsIsObject = whenMapContextToPropsIsObject;

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

@@ -0,0 +1,17 @@
+import always from '@tinkoff/utils/function/always';
+import { wrapMapToPropsFunc, wrapMapToPropsConstant } from './wrapMapToProps.es.js';
+
+function whenMapStateToPropsIsFunction(mapStateToProps) {
+    return typeof mapStateToProps === 'function'
+        ? wrapMapToPropsFunc(mapStateToProps, 'mapStateToProps')
+        : undefined;
+}
+function whenMapStateToPropsIsMissing(mapStateToProps) {
+    return !mapStateToProps ? wrapMapToPropsConstant(always({})) : undefined;
+}
+const mapStateToPropsFactories = [
+    whenMapStateToPropsIsFunction,
+    whenMapStateToPropsIsMissing,
+];
+
+export { mapStateToPropsFactories, whenMapStateToPropsIsFunction, whenMapStateToPropsIsMissing };

package/lib/connect/toProps/mapStateToProps.js

@@ -0,0 +1,27 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var always = require('@tinkoff/utils/function/always');
+var wrapMapToProps = require('./wrapMapToProps.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var always__default = /*#__PURE__*/_interopDefaultLegacy(always);
+
+function whenMapStateToPropsIsFunction(mapStateToProps) {
+    return typeof mapStateToProps === 'function'
+        ? wrapMapToProps.wrapMapToPropsFunc(mapStateToProps, 'mapStateToProps')
+        : undefined;
+}
+function whenMapStateToPropsIsMissing(mapStateToProps) {
+    return !mapStateToProps ? wrapMapToProps.wrapMapToPropsConstant(always__default["default"]({})) : undefined;
+}
+const mapStateToPropsFactories = [
+    whenMapStateToPropsIsFunction,
+    whenMapStateToPropsIsMissing,
+];
+
+exports.mapStateToPropsFactories = mapStateToPropsFactories;
+exports.whenMapStateToPropsIsFunction = whenMapStateToPropsIsFunction;
+exports.whenMapStateToPropsIsMissing = whenMapStateToPropsIsMissing;