@tramvai/state 2.70.0 → 2.72.0

package/lib/connect/Provider.es.js

@@ -0,0 +1,8 @@
+import { jsx } from 'react/jsx-runtime';
+import { ConnectContext, ServerStateContext } from './context.es.js';
+
+const Provider = ({ context, children, serverState, }) => {
+    return (jsx(ConnectContext.Provider, { value: context, children: jsx(ServerStateContext.Provider, { value: serverState, children: children }) }));
+};
+
+export { Provider };

package/lib/connect/Provider.js

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsxRuntime = require('react/jsx-runtime');
+var context = require('./context.js');
+
+const Provider = ({ context: context$1, children, serverState, }) => {
+    return (jsxRuntime.jsx(context.ConnectContext.Provider, { value: context$1, children: jsxRuntime.jsx(context.ServerStateContext.Provider, { value: serverState, children: children }) }));
+};
+
+exports.Provider = Provider;

package/lib/connect/Subscription.es.js

@@ -0,0 +1,37 @@
+// 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;
+    }
+}
+
+export { Subscription };

package/lib/connect/Subscription.js

@@ -0,0 +1,41 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+// 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;
+    }
+}
+
+exports.Subscription = Subscription;

package/lib/connect/connectAdvanced.es.js

@@ -0,0 +1,159 @@
+import { jsx } from 'react/jsx-runtime';
+import noop from '@tinkoff/utils/function/noop';
+import hoistStatics from 'hoist-non-react-statics';
+import invariant from 'invariant';
+import React, { useMemo, useContext, useRef, useCallback } from 'react';
+import { isValidElementType } from 'react-is';
+import { useSyncExternalStore } from 'use-sync-external-store/shim';
+import { Subscription } from './Subscription.es.js';
+import { useConsumerContext } from './hooks/useConsumerContext.es.js';
+import '@tinkoff/utils/is/array';
+import '@tinkoff/react-hooks';
+import { ServerStateContext } from './context.es.js';
+import '@tinkoff/utils/is/shallowEqual';
+import '@tinkoff/utils/array/toArray';
+import 'use-sync-external-store/shim/with-selector';
+
+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(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] = 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 = useContext(ServerStateContext);
+            invariant(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 = 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 = useMemo(() => {
+                if (!shouldHandleStateChanges)
+                    return null;
+                return new Subscription(stores.map((store) => contextValue.getStore(store)));
+            }, [contextValue]);
+            useMemo(() => {
+                if (subscription && typeof window !== 'undefined') {
+                    subscription.trySubscribe();
+                }
+            }, [subscription]);
+            const renderIsScheduled = useRef(false);
+            const actualChildPropsSelector = useCallback(() => {
+                return childPropsSelector(contextValue.getState(), wrapperProps);
+            }, [contextValue, wrapperProps, childPropsSelector]);
+            // Our re-subscribe logic only runs when the store/subscription setup changes
+            const subscribe = useCallback((reactUpdate) => {
+                if (!subscription) {
+                    return noop;
+                }
+                subscription.setOnStateChange(() => {
+                    if (!renderIsScheduled.current) {
+                        renderIsScheduled.current = true;
+                        schedule(() => {
+                            reactUpdate();
+                            renderIsScheduled.current = false;
+                        });
+                    }
+                });
+                return () => {
+                    return subscription.tryUnsubscribe();
+                };
+            }, [subscription]);
+            const actualChildProps = 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 = useMemo(
+            // eslint-disable-next-line react/jsx-props-no-spreading
+            () => 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.memo(ConnectFunction) : ConnectFunction;
+        Connect.WrappedComponent = WrappedComponent;
+        Connect.displayName = displayName;
+        if (forwardRef) {
+            const forwarded = React.forwardRef(function forwardConnectRef(props, ref) {
+                // eslint-disable-next-line react/jsx-props-no-spreading
+                return jsx(Connect, { ...props, forwardedRef: ref });
+            });
+            forwarded.displayName = displayName;
+            forwarded.WrappedComponent = WrappedComponent;
+            return hoistStatics(forwarded, WrappedComponent);
+        }
+        return hoistStatics(Connect, WrappedComponent);
+    };
+}
+
+export { connectAdvanced };

package/lib/connect/connectAdvanced.js

@@ -0,0 +1,170 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+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 Subscription = require('./Subscription.js');
+var useConsumerContext = require('./hooks/useConsumerContext.js');
+require('@tinkoff/utils/is/array');
+require('@tinkoff/react-hooks');
+var context = require('./context.js');
+require('@tinkoff/utils/is/shallowEqual');
+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 noop__default = /*#__PURE__*/_interopDefaultLegacy(noop);
+var hoistStatics__default = /*#__PURE__*/_interopDefaultLegacy(hoistStatics);
+var invariant__default = /*#__PURE__*/_interopDefaultLegacy(invariant);
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+
+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.useConsumerContext();
+            const serverState = React.useContext(context.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.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);
+    };
+}
+
+exports.connectAdvanced = connectAdvanced;

package/lib/connect/context.es.js

@@ -0,0 +1,6 @@
+import { createContext } from 'react';
+
+const ConnectContext = /* #__PURE__*/ createContext(null);
+const ServerStateContext = /* #__PURE__*/ createContext(null);
+
+export { ConnectContext, ServerStateContext };

package/lib/connect/context.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+
+const ConnectContext = /* #__PURE__*/ React.createContext(null);
+const ServerStateContext = /* #__PURE__*/ React.createContext(null);
+
+exports.ConnectContext = ConnectContext;
+exports.ServerStateContext = ServerStateContext;

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

@@ -0,0 +1,17 @@
+import isArray from '@tinkoff/utils/is/array';
+import { useMemo } from 'react';
+import { useShallowEqual } from '@tinkoff/react-hooks';
+import { useConsumerContext } from './useConsumerContext.es.js';
+
+function useActions(actions) {
+    const context = useConsumerContext();
+    const actionsRef = useShallowEqual(actions);
+    return useMemo(() => {
+        if (isArray(actionsRef)) {
+            return actionsRef.map((action) => context.executeAction.bind(context, action));
+        }
+        return context.executeAction.bind(context, actionsRef);
+    }, [actionsRef, context]);
+}
+
+export { useActions };

package/lib/connect/hooks/useActions.js

@@ -0,0 +1,25 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var isArray = require('@tinkoff/utils/is/array');
+var React = require('react');
+var reactHooks = require('@tinkoff/react-hooks');
+var useConsumerContext = require('./useConsumerContext.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var isArray__default = /*#__PURE__*/_interopDefaultLegacy(isArray);
+
+function useActions(actions) {
+    const context = useConsumerContext.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]);
+}
+
+exports.useActions = useActions;

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

@@ -0,0 +1,12 @@
+import { useContext } from 'react';
+import { ConnectContext } from '../context.es.js';
+
+const useConsumerContext = () => {
+    const context = useContext(ConnectContext);
+    if (!context) {
+        throw new Error('CONSUMER_CONTEXT not found, have you added "@tramvai/module-common"?');
+    }
+    return context;
+};
+
+export { useConsumerContext };

package/lib/connect/hooks/useConsumerContext.js

@@ -0,0 +1,16 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var context = require('../context.js');
+
+const useConsumerContext = () => {
+    const context$1 = React.useContext(context.ConnectContext);
+    if (!context$1) {
+        throw new Error('CONSUMER_CONTEXT not found, have you added "@tramvai/module-common"?');
+    }
+    return context$1;
+};
+
+exports.useConsumerContext = useConsumerContext;

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

@@ -0,0 +1,53 @@
+import shallowEqual from '@tinkoff/utils/is/shallowEqual';
+import { useContext, useRef, useMemo, useCallback } from 'react';
+import { useShallowEqual, useIsomorphicLayoutEffect } from '@tinkoff/react-hooks';
+import invariant from 'invariant';
+import toArray from '@tinkoff/utils/array/toArray';
+import { useSyncExternalStoreWithSelector } from 'use-sync-external-store/shim/with-selector';
+import { useConsumerContext } from './useConsumerContext.es.js';
+import { Subscription } from '../Subscription.es.js';
+import { scheduling } from '../scheduling.es.js';
+import { ServerStateContext } from '../context.es.js';
+
+const schedule = /* #__PURE__*/ scheduling();
+function useSelector(storesOrStore, selector, equalityFn = shallowEqual) {
+    invariant(selector, `You must pass a selector to useSelectors`);
+    const context = useConsumerContext();
+    const serverState = useContext(ServerStateContext);
+    const renderIsScheduled = useRef(false);
+    const storesRef = useShallowEqual(storesOrStore);
+    const subscription = useMemo(() => new Subscription(toArray(storesRef).map(context.getStore)), [storesRef, context]);
+    const latestSubscriptionCallbackError = useRef();
+    const subscribe = 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 = 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);
+    }
+    useIsomorphicLayoutEffect(() => {
+        latestSubscriptionCallbackError.current = undefined;
+    });
+    return selectedState;
+}
+
+export { useSelector };

package/lib/connect/hooks/useSelector.js

@@ -0,0 +1,63 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var shallowEqual = require('@tinkoff/utils/is/shallowEqual');
+var React = require('react');
+var reactHooks = require('@tinkoff/react-hooks');
+var invariant = require('invariant');
+var toArray = require('@tinkoff/utils/array/toArray');
+var withSelector = require('use-sync-external-store/shim/with-selector');
+var useConsumerContext = require('./useConsumerContext.js');
+var Subscription = require('../Subscription.js');
+var scheduling = require('../scheduling.js');
+var context = require('../context.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var shallowEqual__default = /*#__PURE__*/_interopDefaultLegacy(shallowEqual);
+var invariant__default = /*#__PURE__*/_interopDefaultLegacy(invariant);
+var toArray__default = /*#__PURE__*/_interopDefaultLegacy(toArray);
+
+const schedule = /* #__PURE__*/ scheduling.scheduling();
+function useSelector(storesOrStore, selector, equalityFn = shallowEqual__default["default"]) {
+    invariant__default["default"](selector, `You must pass a selector to useSelectors`);
+    const context$1 = useConsumerContext.useConsumerContext();
+    const serverState = React.useContext(context.ServerStateContext);
+    const renderIsScheduled = React.useRef(false);
+    const storesRef = reactHooks.useShallowEqual(storesOrStore);
+    const subscription = React.useMemo(() => new Subscription.Subscription(toArray__default["default"](storesRef).map(context$1.getStore)), [storesRef, context$1]);
+    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$1.getState, serverState ? () => serverState : context$1.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;
+}
+
+exports.useSelector = useSelector;