@react-navigation/core 7.0.0-rc.9 → 7.0.1

package/lib/commonjs/usePreventRemove.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.usePreventRemove = usePreventRemove;
+var _nonSecure = require("nanoid/non-secure");
+var React = _interopRequireWildcard(require("react"));
+var _useLatestCallback = _interopRequireDefault(require("use-latest-callback"));
+var _useNavigation = require("./useNavigation.js");
+var _usePreventRemoveContext = require("./usePreventRemoveContext.js");
+var _useRoute = require("./useRoute.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+/**
+ * Hook to prevent screen from being removed. Can be used to prevent users from leaving the screen.
+ *
+ * @param preventRemove Boolean indicating whether to prevent screen from being removed.
+ * @param callback Function which is executed when screen was prevented from being removed.
+ */
+function usePreventRemove(preventRemove, callback) {
+  const [id] = React.useState(() => (0, _nonSecure.nanoid)());
+  const navigation = (0, _useNavigation.useNavigation)();
+  const {
+    key: routeKey
+  } = (0, _useRoute.useRoute)();
+  const {
+    setPreventRemove
+  } = (0, _usePreventRemoveContext.usePreventRemoveContext)();
+  React.useEffect(() => {
+    setPreventRemove(id, routeKey, preventRemove);
+    return () => {
+      setPreventRemove(id, routeKey, false);
+    };
+  }, [setPreventRemove, id, routeKey, preventRemove]);
+  const beforeRemoveListener = (0, _useLatestCallback.default)(e => {
+    if (!preventRemove) {
+      return;
+    }
+    e.preventDefault();
+    callback({
+      data: e.data
+    });
+  });
+  React.useEffect(() => navigation?.addListener('beforeRemove', beforeRemoveListener), [navigation, beforeRemoveListener]);
+}
+//# sourceMappingURL=usePreventRemove.js.map

package/lib/commonjs/usePreventRemoveContext.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.usePreventRemoveContext = usePreventRemoveContext;
+var React = _interopRequireWildcard(require("react"));
+var _PreventRemoveContext = require("./PreventRemoveContext.js");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function usePreventRemoveContext() {
+  const value = React.useContext(_PreventRemoveContext.PreventRemoveContext);
+  if (value == null) {
+    throw new Error("Couldn't find the prevent remove context. Is your component inside NavigationContent?");
+  }
+  return value;
+}
+//# sourceMappingURL=usePreventRemoveContext.js.map

package/lib/commonjs/useRegisterNavigator.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useRegisterNavigator = useRegisterNavigator;
+var _nonSecure = require("nanoid/non-secure");
+var React = _interopRequireWildcard(require("react"));
+var _EnsureSingleNavigator = require("./EnsureSingleNavigator.js");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+/**
+ * Register a navigator in the parent context (either a navigation container or a screen).
+ * This is used to prevent multiple navigators under a single container or screen.
+ */
+function useRegisterNavigator() {
+  const [key] = React.useState(() => (0, _nonSecure.nanoid)());
+  const container = React.useContext(_EnsureSingleNavigator.SingleNavigatorContext);
+  if (container === undefined) {
+    throw new Error("Couldn't register the navigator. Have you wrapped your app with 'NavigationContainer'?\n\nThis can also happen if there are multiple copies of '@react-navigation' packages installed.");
+  }
+  React.useEffect(() => {
+    const {
+      register,
+      unregister
+    } = container;
+    register(key);
+    return () => unregister(key);
+  }, [container, key]);
+  return key;
+}
+//# sourceMappingURL=useRegisterNavigator.js.map

package/lib/commonjs/useRoute.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useRoute = useRoute;
+var React = _interopRequireWildcard(require("react"));
+var _NavigationRouteContext = require("./NavigationRouteContext.js");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+/**
+ * Hook to access the route prop of the parent screen anywhere.
+ *
+ * @returns Route prop of the parent screen.
+ */
+function useRoute() {
+  const route = React.useContext(_NavigationRouteContext.NavigationRouteContext);
+  if (route === undefined) {
+    throw new Error("Couldn't find a route object. Is your component inside a screen in a navigator?");
+  }
+  return route;
+}
+//# sourceMappingURL=useRoute.js.map

package/lib/commonjs/useRouteCache.js

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CHILD_STATE = void 0;
+exports.useRouteCache = useRouteCache;
+var React = _interopRequireWildcard(require("react"));
+var _isRecordEqual = require("./isRecordEqual.js");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+/**
+ * Utilities such as `getFocusedRouteNameFromRoute` need to access state.
+ * So we need a way to suppress the warning for those use cases.
+ * This is fine since they are internal utilities and this is not public API.
+ */
+const CHILD_STATE = exports.CHILD_STATE = Symbol('CHILD_STATE');
+
+/**
+ * Hook to cache route props for each screen in the navigator.
+ * This lets add warnings and modifications to the route object but keep references between renders.
+ */
+function useRouteCache(routes) {
+  // Cache object which holds route objects for each screen
+  const cache = React.useMemo(() => ({
+    current: new Map()
+  }), []);
+  if (process.env.NODE_ENV === 'production') {
+    // We don't want the overhead of creating extra maps every render in prod
+    return routes;
+  }
+  cache.current = routes.reduce((acc, route) => {
+    const previous = cache.current.get(route.key);
+    const {
+      state,
+      ...routeWithoutState
+    } = route;
+    let proxy;
+    if (previous && (0, _isRecordEqual.isRecordEqual)(previous, routeWithoutState)) {
+      // If a cached route object already exists, reuse it
+      proxy = previous;
+    } else {
+      proxy = routeWithoutState;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+      // FIXME: since the state is updated with mutation, the route object cannot be frozen
+      // As a workaround, loop through the object and make the properties readonly
+      for (const key in proxy) {
+        // @ts-expect-error: this is fine since we are looping through the object
+        const value = proxy[key];
+        Object.defineProperty(proxy, key, {
+          enumerable: true,
+          configurable: true,
+          writable: false,
+          value
+        });
+      }
+    }
+    Object.defineProperty(proxy, CHILD_STATE, {
+      enumerable: false,
+      configurable: true,
+      value: state
+    });
+    acc.set(route.key, proxy);
+    return acc;
+  }, new Map());
+  return Array.from(cache.current.values());
+}
+//# sourceMappingURL=useRouteCache.js.map

package/lib/commonjs/useSyncState.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useSyncState = useSyncState;
+var React = _interopRequireWildcard(require("react"));
+var _deepFreeze = require("./deepFreeze.js");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+const createStore = getInitialState => {
+  const listeners = [];
+  let initialized = false;
+  let state;
+  const getState = () => {
+    if (initialized) {
+      return state;
+    }
+    initialized = true;
+    state = (0, _deepFreeze.deepFreeze)(getInitialState());
+    return state;
+  };
+  const setState = newState => {
+    state = (0, _deepFreeze.deepFreeze)(newState);
+    listeners.forEach(listener => listener());
+  };
+  const subscribe = callback => {
+    listeners.push(callback);
+    return () => {
+      const index = listeners.indexOf(callback);
+      if (index > -1) {
+        listeners.splice(index, 1);
+      }
+    };
+  };
+  return {
+    getState,
+    setState,
+    subscribe
+  };
+};
+function useSyncState(getInitialState) {
+  const store = React.useRef(createStore(getInitialState)).current;
+  const state = React.useSyncExternalStore(store.subscribe, store.getState, store.getState);
+  React.useDebugValue(state);
+  return [state, store.getState, store.setState];
+}
+//# sourceMappingURL=useSyncState.js.map

package/lib/commonjs/validatePathConfig.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validatePathConfig = validatePathConfig;
+const formatToList = items => Object.entries(items).map(([key, value]) => `- ${key} (${value})`).join('\n');
+function validatePathConfig(config, root = true) {
+  const validation = {
+    path: 'string',
+    initialRouteName: 'string',
+    screens: 'object',
+    ...(root ? null : {
+      exact: 'boolean',
+      stringify: 'object',
+      parse: 'object'
+    })
+  };
+  if (typeof config !== 'object' || config === null) {
+    throw new Error(`Expected the configuration to be an object, but got ${JSON.stringify(config)}.`);
+  }
+  const validationErrors = Object.fromEntries(Object.keys(config).map(key => {
+    if (key in validation) {
+      const type = validation[key];
+      // @ts-expect-error: we know the key exists
+      const value = config[key];
+      if (value !== undefined && typeof value !== type) {
+        return [key, `expected '${type}', got '${typeof value}'`];
+      }
+    } else {
+      return [key, 'extraneous'];
+    }
+    return null;
+  }).filter(Boolean));
+  if (Object.keys(validationErrors).length) {
+    throw new Error(`Found invalid properties in the configuration:\n${formatToList(validationErrors)}\n\nYou can only specify the following properties:\n${formatToList(validation)}\n\nIf you want to specify configuration for screens, you need to specify them under a 'screens' property.\n\nSee https://reactnavigation.org/docs/configuring-links for more details on how to specify a linking configuration.`);
+  }
+  if (root && 'path' in config && typeof config.path === 'string' && config.path.includes(':')) {
+    throw new Error(`Found invalid path '${config.path}'. The 'path' in the top-level configuration cannot contain patterns for params.`);
+  }
+  if ('screens' in config && config.screens) {
+    Object.entries(config.screens).forEach(([_, value]) => {
+      if (typeof value !== 'string') {
+        validatePathConfig(value, false);
+      }
+    });
+  }
+}
+//# sourceMappingURL=validatePathConfig.js.map

package/lib/commonjs/validatePathConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["formatToList","items","Object","entries","map","key","value","join","validatePathConfig","config","root","validation","path","initialRouteName","screens","exact","stringify","parse","Error","JSON","validationErrors","fromEntries","keys","type","undefined","filter","Boolean","length","includes","forEach","_"],"sourceRoot":"../../src","sources":["validatePathConfig.tsx"],"mappings":";;;;;;AAAA,MAAMA,YAAY,GAAIC,KAA6B,IACjDC,MAAM,CAACC,OAAO,CAACF,KAAK,CAAC,CAClBG,GAAG,CAAC,CAAC,CAACC,GAAG,EAAEC,KAAK,CAAC,KAAK,KAAKD,GAAG,KAAKC,KAAK,GAAG,CAAC,CAC5CC,IAAI,CAAC,IAAI,CAAC;AAER,SAASC,kBAAkBA,CAACC,MAAe,EAAEC,IAAI,GAAG,IAAI,EAAE;EAC/D,MAAMC,UAAU,GAAG;IACjBC,IAAI,EAAE,QAAQ;IACdC,gBAAgB,EAAE,QAAQ;IAC1BC,OAAO,EAAE,QAAQ;IACjB,IAAIJ,IAAI,GACJ,IAAI,GACJ;MACEK,KAAK,EAAE,SAAS;MAChBC,SAAS,EAAE,QAAQ;MACnBC,KAAK,EAAE;IACT,CAAC;EACP,CAAC;EAED,IAAI,OAAOR,MAAM,KAAK,QAAQ,IAAIA,MAAM,KAAK,IAAI,EAAE;IACjD,MAAM,IAAIS,KAAK,CACb,uDAAuDC,IAAI,CAACH,SAAS,CACnEP,MACF,CAAC,GACH,CAAC;EACH;EAEA,MAAMW,gBAAgB,GAAGlB,MAAM,CAACmB,WAAW,CACzCnB,MAAM,CAACoB,IAAI,CAACb,MAAM,CAAC,CAChBL,GAAG,CAAEC,GAAG,IAAK;IACZ,IAAIA,GAAG,IAAIM,UAAU,EAAE;MACrB,MAAMY,IAAI,GAAGZ,UAAU,CAACN,GAAG,CAA4B;MACvD;MACA,MAAMC,KAAK,GAAGG,MAAM,CAACJ,GAAG,CAAC;MAEzB,IAAIC,KAAK,KAAKkB,SAAS,IAAI,OAAOlB,KAAK,KAAKiB,IAAI,EAAE;QAChD,OAAO,CAAClB,GAAG,EAAE,aAAakB,IAAI,WAAW,OAAOjB,KAAK,GAAG,CAAC;MAC3D;IACF,CAAC,MAAM;MACL,OAAO,CAACD,GAAG,EAAE,YAAY,CAAC;IAC5B;IAEA,OAAO,IAAI;EACb,CAAC,CAAC,CACDoB,MAAM,CAACC,OAAO,CACnB,CAAC;EAED,IAAIxB,MAAM,CAACoB,IAAI,CAACF,gBAAgB,CAAC,CAACO,MAAM,EAAE;IACxC,MAAM,IAAIT,KAAK,CACb,mDAAmDlB,YAAY,CAC7DoB,gBACF,CAAC,uDAAuDpB,YAAY,CAClEW,UACF,CAAC,kOACH,CAAC;EACH;EAEA,IACED,IAAI,IACJ,MAAM,IAAID,MAAM,IAChB,OAAOA,MAAM,CAACG,IAAI,KAAK,QAAQ,IAC/BH,MAAM,CAACG,IAAI,CAACgB,QAAQ,CAAC,GAAG,CAAC,EACzB;IACA,MAAM,IAAIV,KAAK,CACb,uBAAuBT,MAAM,CAACG,IAAI,kFACpC,CAAC;EACH;EAEA,IAAI,SAAS,IAAIH,MAAM,IAAIA,MAAM,CAACK,OAAO,EAAE;IACzCZ,MAAM,CAACC,OAAO,CAACM,MAAM,CAACK,OAAO,CAAC,CAACe,OAAO,CAAC,CAAC,CAACC,CAAC,EAAExB,KAAK,CAAC,KAAK;MACrD,IAAI,OAAOA,KAAK,KAAK,QAAQ,EAAE;QAC7BE,kBAAkB,CAACF,KAAK,EAAE,KAAK,CAAC;MAClC;IACF,CAAC,CAAC;EACJ;AACF","ignoreList":[]}

package/lib/module/BaseNavigationContainer.js

@@ -0,0 +1,349 @@
+"use strict";
+
+import { CommonActions } from '@react-navigation/routers';
+import * as React from 'react';
+import useLatestCallback from 'use-latest-callback';
+import { checkDuplicateRouteNames } from "./checkDuplicateRouteNames.js";
+import { checkSerializable } from "./checkSerializable.js";
+import { NOT_INITIALIZED_ERROR } from "./createNavigationContainerRef.js";
+import { DeprecatedNavigationInChildContext } from "./DeprecatedNavigationInChildContext.js";
+import { EnsureSingleNavigator } from "./EnsureSingleNavigator.js";
+import { findFocusedRoute } from "./findFocusedRoute.js";
+import { NavigationBuilderContext } from "./NavigationBuilderContext.js";
+import { NavigationContainerRefContext } from "./NavigationContainerRefContext.js";
+import { NavigationIndependentTreeContext } from "./NavigationIndependentTreeContext.js";
+import { NavigationStateContext } from "./NavigationStateContext.js";
+import { ThemeProvider } from "./theming/ThemeProvider.js";
+import { UnhandledActionContext } from "./UnhandledActionContext.js";
+import { useChildListeners } from "./useChildListeners.js";
+import { useEventEmitter } from "./useEventEmitter.js";
+import { useKeyedChildListeners } from "./useKeyedChildListeners.js";
+import { useNavigationIndependentTree } from "./useNavigationIndependentTree.js";
+import { useOptionsGetters } from "./useOptionsGetters.js";
+import { useSyncState } from "./useSyncState.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+const serializableWarnings = [];
+const duplicateNameWarnings = [];
+
+/**
+ * Remove `key` and `routeNames` from the state objects recursively to get partial state.
+ *
+ * @param state Initial state object.
+ */
+const getPartialState = state => {
+  if (state === undefined) {
+    return;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const {
+    key,
+    routeNames,
+    ...partialState
+  } = state;
+  return {
+    ...partialState,
+    stale: true,
+    routes: state.routes.map(route => {
+      if (route.state === undefined) {
+        return route;
+      }
+      return {
+        ...route,
+        state: getPartialState(route.state)
+      };
+    })
+  };
+};
+
+/**
+ * Container component which holds the navigation state.
+ * This should be rendered at the root wrapping the whole app.
+ *
+ * @param props.initialState Initial state object for the navigation tree.
+ * @param props.onReady Callback which is called after the navigation tree mounts.
+ * @param props.onStateChange Callback which is called with the latest navigation state when it changes.
+ * @param props.onUnhandledAction Callback which is called when an action is not handled.
+ * @param props.theme Theme object for the UI elements.
+ * @param props.children Child elements to render the content.
+ * @param props.ref Ref object which refers to the navigation object containing helper methods.
+ */
+export const BaseNavigationContainer = /*#__PURE__*/React.forwardRef(function BaseNavigationContainer({
+  initialState,
+  onStateChange,
+  onReady,
+  onUnhandledAction,
+  navigationInChildEnabled = false,
+  theme,
+  children
+}, ref) {
+  const parent = React.useContext(NavigationStateContext);
+  const independent = useNavigationIndependentTree();
+  if (!parent.isDefault && !independent) {
+    throw new Error("Looks like you have nested a 'NavigationContainer' inside another. Normally you need only one container at the root of the app, so this was probably an error. If this was intentional, wrap the container in 'NavigationIndependentTree' explicitly. Note that this will make the child navigators disconnected from the parent and you won't be able to navigate between them.");
+  }
+  const [state, getState, setState] = useSyncState(() => getPartialState(initialState == null ? undefined : initialState));
+  const isFirstMountRef = React.useRef(true);
+  const navigatorKeyRef = React.useRef();
+  const getKey = React.useCallback(() => navigatorKeyRef.current, []);
+  const setKey = React.useCallback(key => {
+    navigatorKeyRef.current = key;
+  }, []);
+  const {
+    listeners,
+    addListener
+  } = useChildListeners();
+  const {
+    keyedListeners,
+    addKeyedListener
+  } = useKeyedChildListeners();
+  const dispatch = useLatestCallback(action => {
+    if (listeners.focus[0] == null) {
+      console.error(NOT_INITIALIZED_ERROR);
+    } else {
+      listeners.focus[0](navigation => navigation.dispatch(action));
+    }
+  });
+  const canGoBack = useLatestCallback(() => {
+    if (listeners.focus[0] == null) {
+      return false;
+    }
+    const {
+      result,
+      handled
+    } = listeners.focus[0](navigation => navigation.canGoBack());
+    if (handled) {
+      return result;
+    } else {
+      return false;
+    }
+  });
+  const resetRoot = useLatestCallback(state => {
+    const target = state?.key ?? keyedListeners.getState.root?.().key;
+    if (target == null) {
+      console.error(NOT_INITIALIZED_ERROR);
+    } else {
+      listeners.focus[0](navigation => navigation.dispatch({
+        ...CommonActions.reset(state),
+        target
+      }));
+    }
+  });
+  const getRootState = useLatestCallback(() => {
+    return keyedListeners.getState.root?.();
+  });
+  const getCurrentRoute = useLatestCallback(() => {
+    const state = getRootState();
+    if (state == null) {
+      return undefined;
+    }
+    const route = findFocusedRoute(state);
+    return route;
+  });
+  const isReady = useLatestCallback(() => listeners.focus[0] != null);
+  const emitter = useEventEmitter();
+  const {
+    addOptionsGetter,
+    getCurrentOptions
+  } = useOptionsGetters({});
+  const navigation = React.useMemo(() => ({
+    ...Object.keys(CommonActions).reduce((acc, name) => {
+      acc[name] = (...args) =>
+      // @ts-expect-error: this is ok
+      dispatch(CommonActions[name](...args));
+      return acc;
+    }, {}),
+    ...emitter.create('root'),
+    dispatch,
+    resetRoot,
+    isFocused: () => true,
+    canGoBack,
+    getParent: () => undefined,
+    getState,
+    getRootState,
+    getCurrentRoute,
+    getCurrentOptions,
+    isReady,
+    setOptions: () => {
+      throw new Error('Cannot call setOptions outside a screen');
+    }
+  }), [canGoBack, dispatch, emitter, getCurrentOptions, getCurrentRoute, getRootState, getState, isReady, resetRoot]);
+  React.useImperativeHandle(ref, () => navigation, [navigation]);
+  const onDispatchAction = useLatestCallback((action, noop) => {
+    emitter.emit({
+      type: '__unsafe_action__',
+      data: {
+        action,
+        noop,
+        stack: stackRef.current
+      }
+    });
+  });
+  const lastEmittedOptionsRef = React.useRef();
+  const onOptionsChange = useLatestCallback(options => {
+    if (lastEmittedOptionsRef.current === options) {
+      return;
+    }
+    lastEmittedOptionsRef.current = options;
+    emitter.emit({
+      type: 'options',
+      data: {
+        options
+      }
+    });
+  });
+  const stackRef = React.useRef();
+  const builderContext = React.useMemo(() => ({
+    addListener,
+    addKeyedListener,
+    onDispatchAction,
+    onOptionsChange,
+    stackRef
+  }), [addListener, addKeyedListener, onDispatchAction, onOptionsChange]);
+  const isInitialRef = React.useRef(true);
+  const getIsInitial = React.useCallback(() => isInitialRef.current, []);
+  const context = React.useMemo(() => ({
+    state,
+    getState,
+    setState,
+    getKey,
+    setKey,
+    getIsInitial,
+    addOptionsGetter
+  }), [state, getState, setState, getKey, setKey, getIsInitial, addOptionsGetter]);
+  const onReadyRef = React.useRef(onReady);
+  const onStateChangeRef = React.useRef(onStateChange);
+  React.useEffect(() => {
+    isInitialRef.current = false;
+    onStateChangeRef.current = onStateChange;
+    onReadyRef.current = onReady;
+  });
+  const onReadyCalledRef = React.useRef(false);
+  React.useEffect(() => {
+    if (!onReadyCalledRef.current && isReady()) {
+      onReadyCalledRef.current = true;
+      onReadyRef.current?.();
+    }
+  }, [state, isReady]);
+  React.useEffect(() => {
+    const hydratedState = getRootState();
+    if (process.env.NODE_ENV !== 'production') {
+      if (hydratedState !== undefined) {
+        const serializableResult = checkSerializable(hydratedState);
+        if (!serializableResult.serializable) {
+          const {
+            location,
+            reason
+          } = serializableResult;
+          let path = '';
+          let pointer = hydratedState;
+          let params = false;
+          for (let i = 0; i < location.length; i++) {
+            const curr = location[i];
+            const prev = location[i - 1];
+            pointer = pointer[curr];
+            if (!params && curr === 'state') {
+              continue;
+            } else if (!params && curr === 'routes') {
+              if (path) {
+                path += ' > ';
+              }
+            } else if (!params && typeof curr === 'number' && prev === 'routes') {
+              path += pointer?.name;
+            } else if (!params) {
+              path += ` > ${curr}`;
+              params = true;
+            } else {
+              if (typeof curr === 'number' || /^[0-9]+$/.test(curr)) {
+                path += `[${curr}]`;
+              } else if (/^[a-z$_]+$/i.test(curr)) {
+                path += `.${curr}`;
+              } else {
+                path += `[${JSON.stringify(curr)}]`;
+              }
+            }
+          }
+          const message = `Non-serializable values were found in the navigation state. Check:\n\n${path} (${reason})\n\nThis can break usage such as persisting and restoring state. This might happen if you passed non-serializable values such as function, class instances etc. in params. If you need to use components with callbacks in your options, you can use 'navigation.setOptions' instead. See https://reactnavigation.org/docs/troubleshooting#i-get-the-warning-non-serializable-values-were-found-in-the-navigation-state for more details.`;
+          if (!serializableWarnings.includes(message)) {
+            serializableWarnings.push(message);
+            console.warn(message);
+          }
+        }
+        const duplicateRouteNamesResult = checkDuplicateRouteNames(hydratedState);
+        if (duplicateRouteNamesResult.length) {
+          const message = `Found screens with the same name nested inside one another. Check:\n${duplicateRouteNamesResult.map(locations => `\n${locations.join(', ')}`)}\n\nThis can cause confusing behavior during navigation. Consider using unique names for each screen instead.`;
+          if (!duplicateNameWarnings.includes(message)) {
+            duplicateNameWarnings.push(message);
+            console.warn(message);
+          }
+        }
+      }
+    }
+    emitter.emit({
+      type: 'state',
+      data: {
+        state
+      }
+    });
+    if (!isFirstMountRef.current && onStateChangeRef.current) {
+      onStateChangeRef.current(hydratedState);
+    }
+    isFirstMountRef.current = false;
+  }, [getRootState, emitter, state]);
+  const defaultOnUnhandledAction = useLatestCallback(action => {
+    if (process.env.NODE_ENV === 'production') {
+      return;
+    }
+    const payload = action.payload;
+    let message = `The action '${action.type}'${payload ? ` with payload ${JSON.stringify(action.payload)}` : ''} was not handled by any navigator.`;
+    switch (action.type) {
+      case 'NAVIGATE':
+      case 'PUSH':
+      case 'REPLACE':
+      case 'JUMP_TO':
+        if (payload?.name) {
+          message += `\n\nDo you have a screen named '${payload.name}'?\n\nIf you're trying to navigate to a screen in a nested navigator, see https://reactnavigation.org/docs/nesting-navigators#navigating-to-a-screen-in-a-nested-navigator.\n\nIf you're using conditional rendering, navigation will happen automatically and you shouldn't navigate manually.`;
+        } else {
+          message += `\n\nYou need to pass the name of the screen to navigate to.\n\nSee https://reactnavigation.org/docs/navigation-actions for usage.`;
+        }
+        break;
+      case 'GO_BACK':
+      case 'POP':
+      case 'POP_TO_TOP':
+        message += `\n\nIs there any screen to go back to?`;
+        break;
+      case 'OPEN_DRAWER':
+      case 'CLOSE_DRAWER':
+      case 'TOGGLE_DRAWER':
+        message += `\n\nIs your screen inside a Drawer navigator?`;
+        break;
+    }
+    message += `\n\nThis is a development-only warning and won't be shown in production.`;
+    console.error(message);
+  });
+  return /*#__PURE__*/_jsx(NavigationIndependentTreeContext.Provider, {
+    value: false,
+    children: /*#__PURE__*/_jsx(NavigationContainerRefContext.Provider, {
+      value: navigation,
+      children: /*#__PURE__*/_jsx(NavigationBuilderContext.Provider, {
+        value: builderContext,
+        children: /*#__PURE__*/_jsx(NavigationStateContext.Provider, {
+          value: context,
+          children: /*#__PURE__*/_jsx(UnhandledActionContext.Provider, {
+            value: onUnhandledAction ?? defaultOnUnhandledAction,
+            children: /*#__PURE__*/_jsx(DeprecatedNavigationInChildContext.Provider, {
+              value: navigationInChildEnabled,
+              children: /*#__PURE__*/_jsx(EnsureSingleNavigator, {
+                children: /*#__PURE__*/_jsx(ThemeProvider, {
+                  value: theme,
+                  children: children
+                })
+              })
+            })
+          })
+        })
+      })
+    })
+  });
+});
+//# sourceMappingURL=BaseNavigationContainer.js.map