"use strict"; var __create = Object.create; var __defProp = Object.defineProperty; var __getOwnPropDesc = Object.getOwnPropertyDescriptor; var __getOwnPropNames = Object.getOwnPropertyNames; var __getProtoOf = Object.getPrototypeOf; var __hasOwnProp = Object.prototype.hasOwnProperty; var __export = (target, all) => { for (var name in all) __defProp(target, name, { get: all[name], enumerable: true }); }; var __copyProps = (to, from, except, desc) => { if (from && typeof from === "object" || typeof from === "function") { for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); } return to; }; var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( // If the importer is in node compatibility mode or this is not an ESM // file that has been converted to a CommonJS file using a Babel- // compatible transform (i.e. "__esModule" has not been set), then set // "default" to the CommonJS "module.exports" for node compatibility. isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod )); var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); // src/index.ts var src_exports = {}; __export(src_exports, { Provider: () => Provider_default, ReactReduxContext: () => ReactReduxContext, batch: () => batch, connect: () => connect_default, createDispatchHook: () => createDispatchHook, createSelectorHook: () => createSelectorHook, createStoreHook: () => createStoreHook, shallowEqual: () => shallowEqual, useDispatch: () => useDispatch, useSelector: () => useSelector, useStore: () => useStore }); module.exports = __toCommonJS(src_exports); var React2 = __toESM(require("react")); var import_with_selector = require("use-sync-external-store/with-selector.js"); // src/utils/react.ts var ReactOriginal = __toESM(require("react")); var React = ( // prettier-ignore // @ts-ignore "default" in ReactOriginal ? ReactOriginal["default"] : ReactOriginal ); // src/components/Context.ts var ContextKey = Symbol.for(`react-redux-context`); var gT = typeof globalThis !== "undefined" ? globalThis : ( /* fall back to a per-module scope (pre-8.1 behaviour) if `globalThis` is not available */ {} ); function getContext() { if (!React.createContext) return {}; const contextMap = gT[ContextKey] ?? (gT[ContextKey] = /* @__PURE__ */ new Map()); let realContext = contextMap.get(React.createContext); if (!realContext) { realContext = React.createContext( null ); if (true) { realContext.displayName = "ReactRedux"; } contextMap.set(React.createContext, realContext); } return realContext; } var ReactReduxContext = /* @__PURE__ */ getContext(); // src/utils/useSyncExternalStore.ts var notInitialized = () => { throw new Error("uSES not initialized!"); }; // src/hooks/useReduxContext.ts function createReduxContextHook(context = ReactReduxContext) { return function useReduxContext2() { const contextValue = React.useContext(context); if (!contextValue) { throw new Error( "could not find react-redux context value; please ensure the component is wrapped in a " ); } return contextValue; }; } var useReduxContext = /* @__PURE__ */ createReduxContextHook(); // src/hooks/useSelector.ts var useSyncExternalStoreWithSelector = notInitialized; var initializeUseSelector = (fn) => { useSyncExternalStoreWithSelector = fn; }; var refEquality = (a, b) => a === b; function createSelectorHook(context = ReactReduxContext) { const useReduxContext2 = context === ReactReduxContext ? useReduxContext : createReduxContextHook(context); const useSelector2 = (selector, equalityFnOrOptions = {}) => { const { equalityFn = refEquality, devModeChecks = {} } = typeof equalityFnOrOptions === "function" ? { equalityFn: equalityFnOrOptions } : equalityFnOrOptions; if (true) { if (!selector) { throw new Error(`You must pass a selector to useSelector`); } if (typeof selector !== "function") { throw new Error(`You must pass a function as a selector to useSelector`); } if (typeof equalityFn !== "function") { throw new Error( `You must pass a function as an equality function to useSelector` ); } } const { store, subscription, getServerState, stabilityCheck, identityFunctionCheck } = useReduxContext2(); const firstRun = React.useRef(true); const wrappedSelector = React.useCallback( { [selector.name](state) { const selected = selector(state); if (true) { const { identityFunctionCheck: finalIdentityFunctionCheck, stabilityCheck: finalStabilityCheck } = { stabilityCheck, identityFunctionCheck, ...devModeChecks }; if (finalStabilityCheck === "always" || finalStabilityCheck === "once" && firstRun.current) { const toCompare = selector(state); if (!equalityFn(selected, toCompare)) { let stack = void 0; try { throw new Error(); } catch (e) { ; ({ stack } = e); } console.warn( "Selector " + (selector.name || "unknown") + " returned a different result when called with the same parameters. This can lead to unnecessary rerenders.\nSelectors that return a new reference (such as an object or an array) should be memoized: https://redux.js.org/usage/deriving-data-selectors#optimizing-selectors-with-memoization", { state, selected, selected2: toCompare, stack } ); } } if (finalIdentityFunctionCheck === "always" || finalIdentityFunctionCheck === "once" && firstRun.current) { if (selected === state) { let stack = void 0; try { throw new Error(); } catch (e) { ; ({ stack } = e); } console.warn( "Selector " + (selector.name || "unknown") + " returned the root state when called. This can lead to unnecessary rerenders.\nSelectors that return the entire state are almost certainly a mistake, as they will cause a rerender whenever *anything* in state changes.", { stack } ); } } if (firstRun.current) firstRun.current = false; } return selected; } }[selector.name], [selector, stabilityCheck, devModeChecks.stabilityCheck] ); const selectedState = useSyncExternalStoreWithSelector( subscription.addNestedSub, store.getState, getServerState || store.getState, wrappedSelector, equalityFn ); React.useDebugValue(selectedState); return selectedState; }; Object.assign(useSelector2, { withTypes: () => useSelector2 }); return useSelector2; } var useSelector = /* @__PURE__ */ createSelectorHook(); // src/utils/react-is.ts var REACT_ELEMENT_TYPE = Symbol.for("react.element"); var REACT_PORTAL_TYPE = Symbol.for("react.portal"); var REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"); var REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"); var REACT_PROFILER_TYPE = Symbol.for("react.profiler"); var REACT_PROVIDER_TYPE = Symbol.for("react.provider"); var REACT_CONTEXT_TYPE = Symbol.for("react.context"); var REACT_SERVER_CONTEXT_TYPE = Symbol.for("react.server_context"); var REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"); var REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"); var REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"); var REACT_MEMO_TYPE = Symbol.for("react.memo"); var REACT_LAZY_TYPE = Symbol.for("react.lazy"); var REACT_OFFSCREEN_TYPE = Symbol.for("react.offscreen"); var REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"); var ForwardRef = REACT_FORWARD_REF_TYPE; var Memo = REACT_MEMO_TYPE; function isValidElementType(type) { if (typeof type === "string" || typeof type === "function") { return true; } if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || type === REACT_OFFSCREEN_TYPE) { return true; } if (typeof type === "object" && type !== null) { if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || // This needs to include all possible module reference object // types supported by any Flight configuration anywhere since // we don't know which Flight build this will end up being used // with. type.$$typeof === REACT_CLIENT_REFERENCE || type.getModuleId !== void 0) { return true; } } return false; } function typeOf(object) { if (typeof object === "object" && object !== null) { const $$typeof = object.$$typeof; switch ($$typeof) { case REACT_ELEMENT_TYPE: { const type = object.type; switch (type) { case REACT_FRAGMENT_TYPE: case REACT_PROFILER_TYPE: case REACT_STRICT_MODE_TYPE: case REACT_SUSPENSE_TYPE: case REACT_SUSPENSE_LIST_TYPE: return type; default: { const $$typeofType = type && type.$$typeof; switch ($$typeofType) { case REACT_SERVER_CONTEXT_TYPE: case REACT_CONTEXT_TYPE: case REACT_FORWARD_REF_TYPE: case REACT_LAZY_TYPE: case REACT_MEMO_TYPE: case REACT_PROVIDER_TYPE: return $$typeofType; default: return $$typeof; } } } } case REACT_PORTAL_TYPE: { return $$typeof; } } } return void 0; } function isContextConsumer(object) { return typeOf(object) === REACT_CONTEXT_TYPE; } function isMemo(object) { return typeOf(object) === REACT_MEMO_TYPE; } // src/utils/warning.ts function warning(message) { if (typeof console !== "undefined" && typeof console.error === "function") { console.error(message); } try { throw new Error(message); } catch (e) { } } // src/connect/verifySubselectors.ts function verify(selector, methodName) { if (!selector) { throw new Error(`Unexpected value for ${methodName} in connect.`); } else if (methodName === "mapStateToProps" || methodName === "mapDispatchToProps") { if (!Object.prototype.hasOwnProperty.call(selector, "dependsOnOwnProps")) { warning( `The selector for ${methodName} of connect did not specify a value for dependsOnOwnProps.` ); } } } function verifySubselectors(mapStateToProps, mapDispatchToProps, mergeProps) { verify(mapStateToProps, "mapStateToProps"); verify(mapDispatchToProps, "mapDispatchToProps"); verify(mergeProps, "mergeProps"); } // src/connect/selectorFactory.ts function pureFinalPropsSelectorFactory(mapStateToProps, mapDispatchToProps, mergeProps, dispatch, { areStatesEqual, areOwnPropsEqual, areStatePropsEqual }) { let hasRunAtLeastOnce = false; let state; let ownProps; let stateProps; let dispatchProps; let mergedProps; function handleFirstCall(firstState, firstOwnProps) { state = firstState; ownProps = firstOwnProps; stateProps = mapStateToProps(state, ownProps); dispatchProps = mapDispatchToProps(dispatch, ownProps); mergedProps = mergeProps(stateProps, dispatchProps, ownProps); hasRunAtLeastOnce = true; return mergedProps; } function handleNewPropsAndNewState() { stateProps = mapStateToProps(state, ownProps); if (mapDispatchToProps.dependsOnOwnProps) dispatchProps = mapDispatchToProps(dispatch, ownProps); mergedProps = mergeProps(stateProps, dispatchProps, ownProps); return mergedProps; } function handleNewProps() { if (mapStateToProps.dependsOnOwnProps) stateProps = mapStateToProps(state, ownProps); if (mapDispatchToProps.dependsOnOwnProps) dispatchProps = mapDispatchToProps(dispatch, ownProps); mergedProps = mergeProps(stateProps, dispatchProps, ownProps); return mergedProps; } function handleNewState() { const nextStateProps = mapStateToProps(state, ownProps); const statePropsChanged = !areStatePropsEqual(nextStateProps, stateProps); stateProps = nextStateProps; if (statePropsChanged) mergedProps = mergeProps(stateProps, dispatchProps, ownProps); return mergedProps; } function handleSubsequentCalls(nextState, nextOwnProps) { const propsChanged = !areOwnPropsEqual(nextOwnProps, ownProps); const stateChanged = !areStatesEqual( nextState, state, nextOwnProps, ownProps ); state = nextState; ownProps = 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); }; } function finalPropsSelectorFactory(dispatch, { initMapStateToProps, initMapDispatchToProps, initMergeProps, ...options }) { const mapStateToProps = initMapStateToProps(dispatch, options); const mapDispatchToProps = initMapDispatchToProps(dispatch, options); const mergeProps = initMergeProps(dispatch, options); if (true) { verifySubselectors(mapStateToProps, mapDispatchToProps, mergeProps); } return pureFinalPropsSelectorFactory(mapStateToProps, mapDispatchToProps, mergeProps, dispatch, options); } // src/utils/bindActionCreators.ts function bindActionCreators(actionCreators, dispatch) { const boundActionCreators = {}; for (const key in actionCreators) { const actionCreator = actionCreators[key]; if (typeof actionCreator === "function") { boundActionCreators[key] = (...args) => dispatch(actionCreator(...args)); } } return boundActionCreators; } // src/utils/isPlainObject.ts function isPlainObject(obj) { if (typeof obj !== "object" || obj === null) return false; const proto = Object.getPrototypeOf(obj); if (proto === null) return true; let baseProto = proto; while (Object.getPrototypeOf(baseProto) !== null) { baseProto = Object.getPrototypeOf(baseProto); } return proto === baseProto; } // src/utils/verifyPlainObject.ts function verifyPlainObject(value, displayName, methodName) { if (!isPlainObject(value)) { warning( `${methodName}() in ${displayName} must return a plain object. Instead received ${value}.` ); } } // src/connect/wrapMapToProps.ts function wrapMapToPropsConstant(getConstant) { return function initConstantSelector(dispatch) { const constant = getConstant(dispatch); function constantSelector() { return constant; } constantSelector.dependsOnOwnProps = false; return constantSelector; }; } function getDependsOnOwnProps(mapToProps) { return mapToProps.dependsOnOwnProps ? Boolean(mapToProps.dependsOnOwnProps) : mapToProps.length !== 1; } function wrapMapToPropsFunc(mapToProps, methodName) { return function initProxySelector(dispatch, { displayName }) { const proxy = function mapToPropsProxy(stateOrDispatch, ownProps) { return proxy.dependsOnOwnProps ? proxy.mapToProps(stateOrDispatch, ownProps) : proxy.mapToProps(stateOrDispatch, void 0); }; proxy.dependsOnOwnProps = true; proxy.mapToProps = function detectFactoryAndVerify(stateOrDispatch, ownProps) { proxy.mapToProps = mapToProps; proxy.dependsOnOwnProps = getDependsOnOwnProps(mapToProps); let props = proxy(stateOrDispatch, ownProps); if (typeof props === "function") { proxy.mapToProps = props; proxy.dependsOnOwnProps = getDependsOnOwnProps(props); props = proxy(stateOrDispatch, ownProps); } if (true) verifyPlainObject(props, displayName, methodName); return props; }; return proxy; }; } // src/connect/invalidArgFactory.ts function createInvalidArgFactory(arg, name) { return (dispatch, options) => { throw new Error( `Invalid value of type ${typeof arg} for ${name} argument when connecting component ${options.wrappedComponentName}.` ); }; } // src/connect/mapDispatchToProps.ts function mapDispatchToPropsFactory(mapDispatchToProps) { return mapDispatchToProps && typeof mapDispatchToProps === "object" ? wrapMapToPropsConstant( (dispatch) => ( // @ts-ignore bindActionCreators(mapDispatchToProps, dispatch) ) ) : !mapDispatchToProps ? wrapMapToPropsConstant((dispatch) => ({ dispatch })) : typeof mapDispatchToProps === "function" ? ( // @ts-ignore wrapMapToPropsFunc(mapDispatchToProps, "mapDispatchToProps") ) : createInvalidArgFactory(mapDispatchToProps, "mapDispatchToProps"); } // src/connect/mapStateToProps.ts function mapStateToPropsFactory(mapStateToProps) { return !mapStateToProps ? wrapMapToPropsConstant(() => ({})) : typeof mapStateToProps === "function" ? ( // @ts-ignore wrapMapToPropsFunc(mapStateToProps, "mapStateToProps") ) : createInvalidArgFactory(mapStateToProps, "mapStateToProps"); } // src/connect/mergeProps.ts function defaultMergeProps(stateProps, dispatchProps, ownProps) { return { ...ownProps, ...stateProps, ...dispatchProps }; } function wrapMergePropsFunc(mergeProps) { return function initMergePropsProxy(dispatch, { displayName, areMergedPropsEqual }) { let hasRunOnce = false; let mergedProps; return function mergePropsProxy(stateProps, dispatchProps, ownProps) { const nextMergedProps = mergeProps(stateProps, dispatchProps, ownProps); if (hasRunOnce) { if (!areMergedPropsEqual(nextMergedProps, mergedProps)) mergedProps = nextMergedProps; } else { hasRunOnce = true; mergedProps = nextMergedProps; if (true) verifyPlainObject(mergedProps, displayName, "mergeProps"); } return mergedProps; }; }; } function mergePropsFactory(mergeProps) { return !mergeProps ? () => defaultMergeProps : typeof mergeProps === "function" ? wrapMergePropsFunc(mergeProps) : createInvalidArgFactory(mergeProps, "mergeProps"); } // src/utils/batch.ts function defaultNoopBatch(callback) { callback(); } // src/utils/Subscription.ts function createListenerCollection() { let first = null; let last = null; return { clear() { first = null; last = null; }, notify() { defaultNoopBatch(() => { let listener = first; while (listener) { listener.callback(); listener = listener.next; } }); }, get() { const listeners = []; let listener = first; while (listener) { listeners.push(listener); listener = listener.next; } return listeners; }, subscribe(callback) { let isSubscribed = true; const listener = last = { callback, next: null, prev: last }; if (listener.prev) { listener.prev.next = listener; } else { first = listener; } return function unsubscribe() { if (!isSubscribed || first === null) return; isSubscribed = false; if (listener.next) { listener.next.prev = listener.prev; } else { last = listener.prev; } if (listener.prev) { listener.prev.next = listener.next; } else { first = listener.next; } }; } }; } var nullListeners = { notify() { }, get: () => [] }; function createSubscription(store, parentSub) { let unsubscribe; let listeners = nullListeners; let subscriptionsAmount = 0; let selfSubscribed = false; function addNestedSub(listener) { trySubscribe(); const cleanupListener = listeners.subscribe(listener); let removed = false; return () => { if (!removed) { removed = true; cleanupListener(); tryUnsubscribe(); } }; } function notifyNestedSubs() { listeners.notify(); } function handleChangeWrapper() { if (subscription.onStateChange) { subscription.onStateChange(); } } function isSubscribed() { return selfSubscribed; } function trySubscribe() { subscriptionsAmount++; if (!unsubscribe) { unsubscribe = parentSub ? parentSub.addNestedSub(handleChangeWrapper) : store.subscribe(handleChangeWrapper); listeners = createListenerCollection(); } } function tryUnsubscribe() { subscriptionsAmount--; if (unsubscribe && subscriptionsAmount === 0) { unsubscribe(); unsubscribe = void 0; listeners.clear(); listeners = nullListeners; } } function trySubscribeSelf() { if (!selfSubscribed) { selfSubscribed = true; trySubscribe(); } } function tryUnsubscribeSelf() { if (selfSubscribed) { selfSubscribed = false; tryUnsubscribe(); } } const subscription = { addNestedSub, notifyNestedSubs, handleChangeWrapper, isSubscribed, trySubscribe: trySubscribeSelf, tryUnsubscribe: tryUnsubscribeSelf, getListeners: () => listeners }; return subscription; } // src/utils/useIsomorphicLayoutEffect.ts var canUseDOM = !!(typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined"); var isReactNative = typeof navigator !== "undefined" && navigator.product === "ReactNative"; var useIsomorphicLayoutEffect = canUseDOM || isReactNative ? React.useLayoutEffect : React.useEffect; // src/utils/shallowEqual.ts function is(x, y) { if (x === y) { return x !== 0 || y !== 0 || 1 / x === 1 / y; } else { return x !== x && y !== y; } } function shallowEqual(objA, objB) { if (is(objA, objB)) return true; if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) { return false; } const keysA = Object.keys(objA); const keysB = Object.keys(objB); if (keysA.length !== keysB.length) return false; for (let i = 0; i < keysA.length; i++) { if (!Object.prototype.hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) { return false; } } return true; } // src/utils/hoistStatics.ts var REACT_STATICS = { childContextTypes: true, contextType: true, contextTypes: true, defaultProps: true, displayName: true, getDefaultProps: true, getDerivedStateFromError: true, getDerivedStateFromProps: true, mixins: true, propTypes: true, type: true }; var KNOWN_STATICS = { name: true, length: true, prototype: true, caller: true, callee: true, arguments: true, arity: true }; var FORWARD_REF_STATICS = { $$typeof: true, render: true, defaultProps: true, displayName: true, propTypes: true }; var MEMO_STATICS = { $$typeof: true, compare: true, defaultProps: true, displayName: true, propTypes: true, type: true }; var TYPE_STATICS = { [ForwardRef]: FORWARD_REF_STATICS, [Memo]: MEMO_STATICS }; function getStatics(component) { if (isMemo(component)) { return MEMO_STATICS; } return TYPE_STATICS[component["$$typeof"]] || REACT_STATICS; } var defineProperty = Object.defineProperty; var getOwnPropertyNames = Object.getOwnPropertyNames; var getOwnPropertySymbols = Object.getOwnPropertySymbols; var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; var getPrototypeOf = Object.getPrototypeOf; var objectPrototype = Object.prototype; function hoistNonReactStatics(targetComponent, sourceComponent) { if (typeof sourceComponent !== "string") { if (objectPrototype) { const inheritedComponent = getPrototypeOf(sourceComponent); if (inheritedComponent && inheritedComponent !== objectPrototype) { hoistNonReactStatics(targetComponent, inheritedComponent); } } let keys = getOwnPropertyNames(sourceComponent); if (getOwnPropertySymbols) { keys = keys.concat(getOwnPropertySymbols(sourceComponent)); } const targetStatics = getStatics(targetComponent); const sourceStatics = getStatics(sourceComponent); for (let i = 0; i < keys.length; ++i) { const key = keys[i]; if (!KNOWN_STATICS[key] && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) { const descriptor = getOwnPropertyDescriptor(sourceComponent, key); try { defineProperty(targetComponent, key, descriptor); } catch (e) { } } } } return targetComponent; } // src/components/connect.tsx var useSyncExternalStore = notInitialized; var initializeConnect = (fn) => { useSyncExternalStore = fn; }; var NO_SUBSCRIPTION_ARRAY = [null, null]; var stringifyComponent = (Comp) => { try { return JSON.stringify(Comp); } catch (err) { return String(Comp); } }; function useIsomorphicLayoutEffectWithArgs(effectFunc, effectArgs, dependencies) { useIsomorphicLayoutEffect(() => effectFunc(...effectArgs), dependencies); } function captureWrapperProps(lastWrapperProps, lastChildProps, renderIsScheduled, wrapperProps, childPropsFromStoreUpdate, notifyNestedSubs) { lastWrapperProps.current = wrapperProps; renderIsScheduled.current = false; if (childPropsFromStoreUpdate.current) { childPropsFromStoreUpdate.current = null; notifyNestedSubs(); } } function subscribeUpdates(shouldHandleStateChanges, store, subscription, childPropsSelector, lastWrapperProps, lastChildProps, renderIsScheduled, isMounted, childPropsFromStoreUpdate, notifyNestedSubs, additionalSubscribeListener) { if (!shouldHandleStateChanges) return () => { }; let didUnsubscribe = false; let lastThrownError = null; const checkForUpdates = () => { if (didUnsubscribe || !isMounted.current) { return; } const latestStoreState = store.getState(); let newChildProps, error; try { newChildProps = childPropsSelector( latestStoreState, lastWrapperProps.current ); } catch (e) { error = e; lastThrownError = e; } if (!error) { lastThrownError = null; } if (newChildProps === lastChildProps.current) { if (!renderIsScheduled.current) { notifyNestedSubs(); } } else { lastChildProps.current = newChildProps; childPropsFromStoreUpdate.current = newChildProps; renderIsScheduled.current = true; additionalSubscribeListener(); } }; subscription.onStateChange = checkForUpdates; subscription.trySubscribe(); checkForUpdates(); const unsubscribeWrapper = () => { didUnsubscribe = true; subscription.tryUnsubscribe(); subscription.onStateChange = null; if (lastThrownError) { throw lastThrownError; } }; return unsubscribeWrapper; } function strictEqual(a, b) { return a === b; } var hasWarnedAboutDeprecatedPureOption = false; function connect(mapStateToProps, mapDispatchToProps, mergeProps, { // The `pure` option has been removed, so TS doesn't like us destructuring this to check its existence. // @ts-ignore pure, areStatesEqual = strictEqual, areOwnPropsEqual = shallowEqual, areStatePropsEqual = shallowEqual, areMergedPropsEqual = shallowEqual, // use React's forwardRef to expose a ref of the wrapped component forwardRef = false, // the context consumer to use context = ReactReduxContext } = {}) { if (true) { if (pure !== void 0 && !hasWarnedAboutDeprecatedPureOption) { hasWarnedAboutDeprecatedPureOption = true; warning( 'The `pure` option has been removed. `connect` is now always a "pure/memoized" component' ); } } const Context = context; const initMapStateToProps = mapStateToPropsFactory(mapStateToProps); const initMapDispatchToProps = mapDispatchToPropsFactory(mapDispatchToProps); const initMergeProps = mergePropsFactory(mergeProps); const shouldHandleStateChanges = Boolean(mapStateToProps); const wrapWithConnect = (WrappedComponent) => { if (true) { const isValid = /* @__PURE__ */ isValidElementType(WrappedComponent); if (!isValid) throw new Error( `You must pass a component to the function returned by connect. Instead received ${stringifyComponent( WrappedComponent )}` ); } const wrappedComponentName = WrappedComponent.displayName || WrappedComponent.name || "Component"; const displayName = `Connect(${wrappedComponentName})`; const selectorFactoryOptions = { shouldHandleStateChanges, displayName, wrappedComponentName, WrappedComponent, // @ts-ignore initMapStateToProps, // @ts-ignore initMapDispatchToProps, initMergeProps, areStatesEqual, areStatePropsEqual, areOwnPropsEqual, areMergedPropsEqual }; function ConnectFunction(props) { const [propsContext, reactReduxForwardedRef, wrapperProps] = React.useMemo(() => { const { reactReduxForwardedRef: reactReduxForwardedRef2, ...wrapperProps2 } = props; return [props.context, reactReduxForwardedRef2, wrapperProps2]; }, [props]); const ContextToUse = React.useMemo(() => { let ResultContext = Context; if (propsContext?.Consumer) { if (true) { const isValid = /* @__PURE__ */ isContextConsumer( // @ts-ignore /* @__PURE__ */ React.createElement(propsContext.Consumer, null) ); if (!isValid) { throw new Error( "You must pass a valid React context consumer as `props.context`" ); } ResultContext = propsContext; } } return ResultContext; }, [propsContext, Context]); const contextValue = React.useContext(ContextToUse); const didStoreComeFromProps = Boolean(props.store) && Boolean(props.store.getState) && Boolean(props.store.dispatch); const didStoreComeFromContext = Boolean(contextValue) && Boolean(contextValue.store); if (!didStoreComeFromProps && !didStoreComeFromContext) { throw new Error( `Could not find "store" in the context of "${displayName}". Either wrap the root component in a , or pass a custom React context provider to and the corresponding React context consumer to ${displayName} in connect options.` ); } const store = didStoreComeFromProps ? props.store : contextValue.store; const getServerState = didStoreComeFromContext ? contextValue.getServerState : store.getState; const childPropsSelector = React.useMemo(() => { return finalPropsSelectorFactory(store.dispatch, selectorFactoryOptions); }, [store]); const [subscription, notifyNestedSubs] = React.useMemo(() => { if (!shouldHandleStateChanges) return NO_SUBSCRIPTION_ARRAY; const subscription2 = createSubscription( store, didStoreComeFromProps ? void 0 : contextValue.subscription ); const notifyNestedSubs2 = subscription2.notifyNestedSubs.bind(subscription2); return [subscription2, notifyNestedSubs2]; }, [store, didStoreComeFromProps, contextValue]); const overriddenContextValue = React.useMemo(() => { if (didStoreComeFromProps) { return contextValue; } return { ...contextValue, subscription }; }, [didStoreComeFromProps, contextValue, subscription]); const lastChildProps = React.useRef(void 0); const lastWrapperProps = React.useRef(wrapperProps); const childPropsFromStoreUpdate = React.useRef(void 0); const renderIsScheduled = React.useRef(false); const isMounted = React.useRef(false); const latestSubscriptionCallbackError = React.useRef( void 0 ); useIsomorphicLayoutEffect(() => { isMounted.current = true; return () => { isMounted.current = false; }; }, []); const actualChildPropsSelector = React.useMemo(() => { const selector = () => { if (childPropsFromStoreUpdate.current && wrapperProps === lastWrapperProps.current) { return childPropsFromStoreUpdate.current; } return childPropsSelector(store.getState(), wrapperProps); }; return selector; }, [store, wrapperProps]); const subscribeForReact = React.useMemo(() => { const subscribe = (reactListener) => { if (!subscription) { return () => { }; } return subscribeUpdates( shouldHandleStateChanges, store, subscription, // @ts-ignore childPropsSelector, lastWrapperProps, lastChildProps, renderIsScheduled, isMounted, childPropsFromStoreUpdate, notifyNestedSubs, reactListener ); }; return subscribe; }, [subscription]); useIsomorphicLayoutEffectWithArgs(captureWrapperProps, [ lastWrapperProps, lastChildProps, renderIsScheduled, wrapperProps, childPropsFromStoreUpdate, notifyNestedSubs ]); let actualChildProps; try { actualChildProps = useSyncExternalStore( // TODO We're passing through a big wrapper that does a bunch of extra side effects besides subscribing subscribeForReact, // TODO This is incredibly hacky. We've already processed the store update and calculated new child props, // TODO and we're just passing that through so it triggers a re-render for us rather than relying on `uSES`. actualChildPropsSelector, getServerState ? () => childPropsSelector(getServerState(), wrapperProps) : actualChildPropsSelector ); } catch (err) { if (latestSubscriptionCallbackError.current) { ; err.message += ` The error may be correlated with this previous error: ${latestSubscriptionCallbackError.current.stack} `; } throw err; } useIsomorphicLayoutEffect(() => { latestSubscriptionCallbackError.current = void 0; childPropsFromStoreUpdate.current = void 0; lastChildProps.current = actualChildProps; }); const renderedWrappedComponent = React.useMemo(() => { return ( // @ts-ignore /* @__PURE__ */ React.createElement( WrappedComponent, { ...actualChildProps, ref: reactReduxForwardedRef } ) ); }, [reactReduxForwardedRef, WrappedComponent, actualChildProps]); const renderedChild = React.useMemo(() => { if (shouldHandleStateChanges) { return /* @__PURE__ */ React.createElement(ContextToUse.Provider, { value: overriddenContextValue }, renderedWrappedComponent); } return renderedWrappedComponent; }, [ContextToUse, renderedWrappedComponent, overriddenContextValue]); return renderedChild; } const _Connect = React.memo(ConnectFunction); const Connect = _Connect; Connect.WrappedComponent = WrappedComponent; Connect.displayName = ConnectFunction.displayName = displayName; if (forwardRef) { const _forwarded = React.forwardRef( function forwardConnectRef(props, ref) { return /* @__PURE__ */ React.createElement(Connect, { ...props, reactReduxForwardedRef: ref }); } ); const forwarded = _forwarded; forwarded.displayName = displayName; forwarded.WrappedComponent = WrappedComponent; return /* @__PURE__ */ hoistNonReactStatics(forwarded, WrappedComponent); } return /* @__PURE__ */ hoistNonReactStatics(Connect, WrappedComponent); }; return wrapWithConnect; } var connect_default = connect; // src/components/Provider.tsx function Provider({ store, context, children, serverState, stabilityCheck = "once", identityFunctionCheck = "once" }) { const contextValue = React.useMemo(() => { const subscription = createSubscription(store); return { store, subscription, getServerState: serverState ? () => serverState : void 0, stabilityCheck, identityFunctionCheck }; }, [store, serverState, stabilityCheck, identityFunctionCheck]); const previousState = React.useMemo(() => store.getState(), [store]); useIsomorphicLayoutEffect(() => { const { subscription } = contextValue; subscription.onStateChange = subscription.notifyNestedSubs; subscription.trySubscribe(); if (previousState !== store.getState()) { subscription.notifyNestedSubs(); } return () => { subscription.tryUnsubscribe(); subscription.onStateChange = void 0; }; }, [contextValue, previousState]); const Context = context || ReactReduxContext; return /* @__PURE__ */ React.createElement(Context.Provider, { value: contextValue }, children); } var Provider_default = Provider; // src/hooks/useStore.ts function createStoreHook(context = ReactReduxContext) { const useReduxContext2 = context === ReactReduxContext ? useReduxContext : ( // @ts-ignore createReduxContextHook(context) ); const useStore2 = () => { const { store } = useReduxContext2(); return store; }; Object.assign(useStore2, { withTypes: () => useStore2 }); return useStore2; } var useStore = /* @__PURE__ */ createStoreHook(); // src/hooks/useDispatch.ts function createDispatchHook(context = ReactReduxContext) { const useStore2 = context === ReactReduxContext ? useStore : createStoreHook(context); const useDispatch2 = () => { const store = useStore2(); return store.dispatch; }; Object.assign(useDispatch2, { withTypes: () => useDispatch2 }); return useDispatch2; } var useDispatch = /* @__PURE__ */ createDispatchHook(); // src/exports.ts var batch = defaultNoopBatch; // src/index.ts initializeUseSelector(import_with_selector.useSyncExternalStoreWithSelector); initializeConnect(React2.useSyncExternalStore); // Annotate the CommonJS export names for ESM import in node: 0 && (module.exports = { Provider, ReactReduxContext, batch, connect, createDispatchHook, createSelectorHook, createStoreHook, shallowEqual, useDispatch, useSelector, useStore }); //# sourceMappingURL=react-redux.development.cjs.map