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

package/lib/commonjs/useNavigationCache.js

@@ -0,0 +1,162 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useNavigationCache = useNavigationCache;
+var _routers = require("@react-navigation/routers");
+var React = _interopRequireWildcard(require("react"));
+var _NavigationBuilderContext = require("./NavigationBuilderContext.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 cache navigation objects for each screen in the navigator.
+ * It's important to cache them to make sure navigation objects don't change between renders.
+ * This lets us apply optimizations like `React.memo` to minimize re-rendering screens.
+ */
+function useNavigationCache({
+  state,
+  getState,
+  navigation,
+  setOptions,
+  router,
+  emitter
+}) {
+  const {
+    stackRef
+  } = React.useContext(_NavigationBuilderContext.NavigationBuilderContext);
+  const base = React.useMemo(() => {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const {
+      emit,
+      ...rest
+    } = navigation;
+    const actions = {
+      ...router.actionCreators,
+      ..._routers.CommonActions
+    };
+    const dispatch = () => {
+      throw new Error('Actions cannot be dispatched from a placeholder screen.');
+    };
+    const helpers = Object.keys(actions).reduce((acc, name) => {
+      acc[name] = dispatch;
+      return acc;
+    }, {});
+    return {
+      ...rest,
+      ...helpers,
+      addListener: () => {
+        // Event listeners are not supported for placeholder screens
+
+        return () => {
+          // Empty function
+        };
+      },
+      removeListener: () => {
+        // Event listeners are not supported for placeholder screens
+      },
+      dispatch,
+      getParent: id => {
+        if (id !== undefined && id === rest.getId()) {
+          return base;
+        }
+        return rest.getParent(id);
+      },
+      setOptions: () => {
+        throw new Error('Options cannot be set from a placeholder screen.');
+      },
+      isFocused: () => false
+    };
+  }, [navigation, router.actionCreators]);
+
+  // Cache object which holds navigation objects for each screen
+  // We use `React.useMemo` instead of `React.useRef` coz we want to invalidate it when deps change
+  // In reality, these deps will rarely change, if ever
+  const cache = React.useMemo(() => ({
+    current: {}
+  }),
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  [base, getState, navigation, setOptions, emitter]);
+  cache.current = state.routes.reduce((acc, route) => {
+    const previous = cache.current[route.key];
+    if (previous) {
+      // If a cached navigation object already exists, reuse it
+      acc[route.key] = previous;
+    } else {
+      const dispatch = thunk => {
+        const action = typeof thunk === 'function' ? thunk(getState()) : thunk;
+        if (action != null) {
+          navigation.dispatch({
+            source: route.key,
+            ...action
+          });
+        }
+      };
+      const withStack = callback => {
+        let isStackSet = false;
+        try {
+          if (process.env.NODE_ENV !== 'production' && stackRef && !stackRef.current) {
+            // Capture the stack trace for devtools
+            stackRef.current = new Error().stack;
+            isStackSet = true;
+          }
+          callback();
+        } finally {
+          if (isStackSet && stackRef) {
+            stackRef.current = undefined;
+          }
+        }
+      };
+      const actions = {
+        ...router.actionCreators,
+        ..._routers.CommonActions
+      };
+      const helpers = Object.keys(actions).reduce((acc, name) => {
+        acc[name] = (...args) => withStack(() =>
+        // @ts-expect-error: name is a valid key, but TypeScript is dumb
+        dispatch(actions[name](...args)));
+        return acc;
+      }, {});
+      acc[route.key] = {
+        ...base,
+        ...helpers,
+        // FIXME: too much work to fix the types for now
+        ...emitter.create(route.key),
+        dispatch: thunk => withStack(() => dispatch(thunk)),
+        getParent: id => {
+          if (id !== undefined && id === base.getId()) {
+            // If the passed id is the same as the current navigation id,
+            // we return the cached navigation object for the relevant route
+            return acc[route.key];
+          }
+          return base.getParent(id);
+        },
+        setOptions: options => {
+          setOptions(o => ({
+            ...o,
+            [route.key]: {
+              ...o[route.key],
+              ...options
+            }
+          }));
+        },
+        isFocused: () => {
+          const state = getState();
+          if (state.routes[state.index].key !== route.key) {
+            return false;
+          }
+
+          // If the current screen is focused, we also need to check if parent navigator is focused
+          // This makes sure that we return the focus state in the whole tree, not just this navigator
+          return navigation ? navigation.isFocused() : true;
+        }
+      };
+    }
+    return acc;
+  }, {});
+  return {
+    base,
+    navigations: cache.current
+  };
+}
+//# sourceMappingURL=useNavigationCache.js.map

package/lib/commonjs/useNavigationContainerRef.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useNavigationContainerRef = useNavigationContainerRef;
+var React = _interopRequireWildcard(require("react"));
+var _createNavigationContainerRef = require("./createNavigationContainerRef.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 useNavigationContainerRef() {
+  const navigation = React.useRef(null);
+  if (navigation.current == null) {
+    navigation.current = (0, _createNavigationContainerRef.createNavigationContainerRef)();
+  }
+  return navigation.current;
+}
+//# sourceMappingURL=useNavigationContainerRef.js.map

package/lib/commonjs/useNavigationHelpers.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useNavigationHelpers = useNavigationHelpers;
+var _routers = require("@react-navigation/routers");
+var React = _interopRequireWildcard(require("react"));
+var _NavigationContext = require("./NavigationContext.js");
+var _types = require("./types.js");
+var _UnhandledActionContext = require("./UnhandledActionContext.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; }
+// This is to make TypeScript compiler happy
+_types.PrivateValueStore;
+/**
+ * Navigation object with helper methods to be used by a navigator.
+ * This object includes methods for common actions as well as methods the parent screen's navigation object.
+ */
+function useNavigationHelpers({
+  id: navigatorId,
+  onAction,
+  getState,
+  emitter,
+  router
+}) {
+  const onUnhandledAction = React.useContext(_UnhandledActionContext.UnhandledActionContext);
+  const parentNavigationHelpers = React.useContext(_NavigationContext.NavigationContext);
+  return React.useMemo(() => {
+    const dispatch = op => {
+      const action = typeof op === 'function' ? op(getState()) : op;
+      const handled = onAction(action);
+      if (!handled) {
+        onUnhandledAction?.(action);
+      }
+    };
+    const actions = {
+      ...router.actionCreators,
+      ..._routers.CommonActions
+    };
+    const helpers = Object.keys(actions).reduce((acc, name) => {
+      // @ts-expect-error: name is a valid key, but TypeScript is dumb
+      acc[name] = (...args) => dispatch(actions[name](...args));
+      return acc;
+    }, {});
+    const navigationHelpers = {
+      ...parentNavigationHelpers,
+      ...helpers,
+      dispatch,
+      emit: emitter.emit,
+      isFocused: parentNavigationHelpers ? parentNavigationHelpers.isFocused : () => true,
+      canGoBack: () => {
+        const state = getState();
+        return router.getStateForAction(state, _routers.CommonActions.goBack(), {
+          routeNames: state.routeNames,
+          routeParamList: {},
+          routeGetIdList: {}
+        }) !== null || parentNavigationHelpers?.canGoBack() || false;
+      },
+      getId: () => navigatorId,
+      getParent: id => {
+        if (id !== undefined) {
+          let current = navigationHelpers;
+          while (current && id !== current.getId()) {
+            current = current.getParent();
+          }
+          return current;
+        }
+        return parentNavigationHelpers;
+      },
+      getState
+    };
+    return navigationHelpers;
+  }, [navigatorId, emitter.emit, getState, onAction, onUnhandledAction, parentNavigationHelpers, router]);
+}
+//# sourceMappingURL=useNavigationHelpers.js.map

package/lib/commonjs/useNavigationIndependentTree.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useNavigationIndependentTree = useNavigationIndependentTree;
+var React = _interopRequireWildcard(require("react"));
+var _NavigationIndependentTreeContext = require("./NavigationIndependentTreeContext.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 useNavigationIndependentTree() {
+  return React.useContext(_NavigationIndependentTreeContext.NavigationIndependentTreeContext);
+}
+//# sourceMappingURL=useNavigationIndependentTree.js.map

package/lib/commonjs/useNavigationState.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useNavigationState = useNavigationState;
+var React = _interopRequireWildcard(require("react"));
+var _withSelector = require("use-sync-external-store/with-selector");
+var _useNavigation = require("./useNavigation.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 get a value from the current navigation state using a selector.
+ *
+ * @param selector Selector function to get a value from the state.
+ */
+function useNavigationState(selector) {
+  const navigation = (0, _useNavigation.useNavigation)();
+  const subscribe = React.useCallback(callback => {
+    const unsubscribe = navigation.addListener('state', callback);
+    return unsubscribe;
+  }, [navigation]);
+  const value = (0, _withSelector.useSyncExternalStoreWithSelector)(subscribe, navigation.getState, navigation.getState, selector);
+  return value;
+}
+//# sourceMappingURL=useNavigationState.js.map

package/lib/commonjs/useOnAction.js

@@ -0,0 +1,106 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useOnAction = useOnAction;
+var React = _interopRequireWildcard(require("react"));
+var _DeprecatedNavigationInChildContext = require("./DeprecatedNavigationInChildContext.js");
+var _NavigationBuilderContext = require("./NavigationBuilderContext.js");
+var _useOnPreventRemove = require("./useOnPreventRemove.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 handle actions for a navigator, including state updates and bubbling.
+ *
+ * Bubbling an action is achieved in 2 ways:
+ * 1. To bubble action to parent, we expose the action handler in context and then access the parent context
+ * 2. To bubble action to child, child adds event listeners subscribing to actions from parent
+ *
+ * When the action handler handles as action, it returns `true`, otherwise `false`.
+ */
+function useOnAction({
+  router,
+  getState,
+  setState,
+  key,
+  actionListeners,
+  beforeRemoveListeners,
+  routerConfigOptions,
+  emitter
+}) {
+  const {
+    onAction: onActionParent,
+    onRouteFocus: onRouteFocusParent,
+    addListener: addListenerParent,
+    onDispatchAction
+  } = React.useContext(_NavigationBuilderContext.NavigationBuilderContext);
+  const navigationInChildEnabled = React.useContext(_DeprecatedNavigationInChildContext.DeprecatedNavigationInChildContext);
+  const routerConfigOptionsRef = React.useRef(routerConfigOptions);
+  React.useEffect(() => {
+    routerConfigOptionsRef.current = routerConfigOptions;
+  });
+  const onAction = React.useCallback((action, visitedNavigators = new Set()) => {
+    const state = getState();
+
+    // Since actions can bubble both up and down, they could come to the same navigator again
+    // We keep track of navigators which have already tried to handle the action and return if it's already visited
+    if (visitedNavigators.has(state.key)) {
+      return false;
+    }
+    visitedNavigators.add(state.key);
+    if (typeof action.target !== 'string' || action.target === state.key) {
+      let result = router.getStateForAction(state, action, routerConfigOptionsRef.current);
+
+      // If a target is specified and set to current navigator, the action shouldn't bubble
+      // So instead of `null`, we use the state object for such cases to signal that action was handled
+      result = result === null && action.target === state.key ? state : result;
+      if (result !== null) {
+        onDispatchAction(action, state === result);
+        if (state !== result) {
+          const isPrevented = (0, _useOnPreventRemove.shouldPreventRemove)(emitter, beforeRemoveListeners, state.routes, result.routes, action);
+          if (isPrevented) {
+            return true;
+          }
+          setState(result);
+        }
+        if (onRouteFocusParent !== undefined) {
+          // Some actions such as `NAVIGATE` also want to bring the navigated route to focus in the whole tree
+          // This means we need to focus all of the parent navigators of this navigator as well
+          const shouldFocus = router.shouldActionChangeFocus(action);
+          if (shouldFocus && key !== undefined) {
+            onRouteFocusParent(key);
+          }
+        }
+        return true;
+      }
+    }
+    if (onActionParent !== undefined) {
+      // Bubble action to the parent if the current navigator didn't handle it
+      if (onActionParent(action, visitedNavigators)) {
+        return true;
+      }
+    }
+    if (typeof action.target === 'string' ||
+    // For backward compatibility
+    action.type === 'NAVIGATE_DEPRECATED' || navigationInChildEnabled) {
+      // If the action wasn't handled by current navigator or a parent navigator, let children handle it
+      // Handling this when target isn't specified is deprecated and will be removed in the future
+      for (let i = actionListeners.length - 1; i >= 0; i--) {
+        const listener = actionListeners[i];
+        if (listener(action, visitedNavigators)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }, [actionListeners, beforeRemoveListeners, emitter, getState, navigationInChildEnabled, key, onActionParent, onDispatchAction, onRouteFocusParent, router, setState]);
+  (0, _useOnPreventRemove.useOnPreventRemove)({
+    getState,
+    emitter,
+    beforeRemoveListeners
+  });
+  React.useEffect(() => addListenerParent?.('action', onAction), [addListenerParent, onAction]);
+  return onAction;
+}
+//# sourceMappingURL=useOnAction.js.map

package/lib/commonjs/useOnGetState.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useOnGetState = useOnGetState;
+var React = _interopRequireWildcard(require("react"));
+var _isArrayEqual = require("./isArrayEqual.js");
+var _NavigationBuilderContext = require("./NavigationBuilderContext.js");
+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; }
+function useOnGetState({
+  getState,
+  getStateListeners
+}) {
+  const {
+    addKeyedListener
+  } = React.useContext(_NavigationBuilderContext.NavigationBuilderContext);
+  const route = React.useContext(_NavigationRouteContext.NavigationRouteContext);
+  const key = route ? route.key : 'root';
+  const getRehydratedState = React.useCallback(() => {
+    const state = getState();
+
+    // Avoid returning new route objects if we don't need to
+    const routes = state.routes.map(route => {
+      const childState = getStateListeners[route.key]?.();
+      if (route.state === childState) {
+        return route;
+      }
+      return {
+        ...route,
+        state: childState
+      };
+    });
+    if ((0, _isArrayEqual.isArrayEqual)(state.routes, routes)) {
+      return state;
+    }
+    return {
+      ...state,
+      routes
+    };
+  }, [getState, getStateListeners]);
+  React.useEffect(() => {
+    return addKeyedListener?.('getState', key, getRehydratedState);
+  }, [addKeyedListener, getRehydratedState, key]);
+}
+//# sourceMappingURL=useOnGetState.js.map

package/lib/commonjs/useOnPreventRemove.js

@@ -0,0 +1,72 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.shouldPreventRemove = void 0;
+exports.useOnPreventRemove = useOnPreventRemove;
+var React = _interopRequireWildcard(require("react"));
+var _NavigationBuilderContext = require("./NavigationBuilderContext.js");
+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; }
+const VISITED_ROUTE_KEYS = Symbol('VISITED_ROUTE_KEYS');
+const shouldPreventRemove = (emitter, beforeRemoveListeners, currentRoutes, nextRoutes, action) => {
+  const nextRouteKeys = nextRoutes.map(route => route.key);
+
+  // Call these in reverse order so last screens handle the event first
+  const removedRoutes = currentRoutes.filter(route => !nextRouteKeys.includes(route.key)).reverse();
+  const visitedRouteKeys =
+  // @ts-expect-error: add this property to mark that we've already emitted this action
+  action[VISITED_ROUTE_KEYS] ?? new Set();
+  const beforeRemoveAction = {
+    ...action,
+    [VISITED_ROUTE_KEYS]: visitedRouteKeys
+  };
+  for (const route of removedRoutes) {
+    if (visitedRouteKeys.has(route.key)) {
+      // Skip if we've already emitted this action for this screen
+      continue;
+    }
+
+    // First, we need to check if any child screens want to prevent it
+    const isPrevented = beforeRemoveListeners[route.key]?.(beforeRemoveAction);
+    if (isPrevented) {
+      return true;
+    }
+    visitedRouteKeys.add(route.key);
+    const event = emitter.emit({
+      type: 'beforeRemove',
+      target: route.key,
+      data: {
+        action: beforeRemoveAction
+      },
+      canPreventDefault: true
+    });
+    if (event.defaultPrevented) {
+      return true;
+    }
+  }
+  return false;
+};
+exports.shouldPreventRemove = shouldPreventRemove;
+function useOnPreventRemove({
+  getState,
+  emitter,
+  beforeRemoveListeners
+}) {
+  const {
+    addKeyedListener
+  } = React.useContext(_NavigationBuilderContext.NavigationBuilderContext);
+  const route = React.useContext(_NavigationRouteContext.NavigationRouteContext);
+  const routeKey = route?.key;
+  React.useEffect(() => {
+    if (routeKey) {
+      return addKeyedListener?.('beforeRemove', routeKey, action => {
+        const state = getState();
+        return shouldPreventRemove(emitter, beforeRemoveListeners, state.routes, [], action);
+      });
+    }
+  }, [addKeyedListener, beforeRemoveListeners, emitter, getState, routeKey]);
+}
+//# sourceMappingURL=useOnPreventRemove.js.map

package/lib/commonjs/useOnRouteFocus.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useOnRouteFocus = useOnRouteFocus;
+var React = _interopRequireWildcard(require("react"));
+var _NavigationBuilderContext = require("./NavigationBuilderContext.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 handle focus actions for a route.
+ * Focus action needs to be treated specially, coz when a nested route is focused,
+ * the parent navigators also needs to be focused.
+ */
+function useOnRouteFocus({
+  router,
+  getState,
+  key: sourceRouteKey,
+  setState
+}) {
+  const {
+    onRouteFocus: onRouteFocusParent
+  } = React.useContext(_NavigationBuilderContext.NavigationBuilderContext);
+  return React.useCallback(key => {
+    const state = getState();
+    const result = router.getStateForRouteFocus(state, key);
+    if (result !== state) {
+      setState(result);
+    }
+    if (onRouteFocusParent !== undefined && sourceRouteKey !== undefined) {
+      onRouteFocusParent(sourceRouteKey);
+    }
+  }, [getState, onRouteFocusParent, router, setState, sourceRouteKey]);
+}
+//# sourceMappingURL=useOnRouteFocus.js.map

package/lib/commonjs/useOptionsGetters.js

@@ -0,0 +1,78 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useOptionsGetters = useOptionsGetters;
+var React = _interopRequireWildcard(require("react"));
+var _NavigationBuilderContext = require("./NavigationBuilderContext.js");
+var _NavigationStateContext = require("./NavigationStateContext.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 useOptionsGetters({
+  key,
+  options,
+  navigation
+}) {
+  const optionsRef = React.useRef(options);
+  const optionsGettersFromChildRef = React.useRef({});
+  const {
+    onOptionsChange
+  } = React.useContext(_NavigationBuilderContext.NavigationBuilderContext);
+  const {
+    addOptionsGetter: parentAddOptionsGetter
+  } = React.useContext(_NavigationStateContext.NavigationStateContext);
+  const optionsChangeListener = React.useCallback(() => {
+    const isFocused = navigation?.isFocused() ?? true;
+    const hasChildren = Object.keys(optionsGettersFromChildRef.current).length;
+    if (isFocused && !hasChildren) {
+      onOptionsChange(optionsRef.current ?? {});
+    }
+  }, [navigation, onOptionsChange]);
+  React.useEffect(() => {
+    optionsRef.current = options;
+    optionsChangeListener();
+    return navigation?.addListener('focus', optionsChangeListener);
+  }, [navigation, options, optionsChangeListener]);
+  const getOptionsFromListener = React.useCallback(() => {
+    for (const key in optionsGettersFromChildRef.current) {
+      if (key in optionsGettersFromChildRef.current) {
+        const result = optionsGettersFromChildRef.current[key]?.();
+
+        // null means unfocused route
+        if (result !== null) {
+          return result;
+        }
+      }
+    }
+    return null;
+  }, []);
+  const getCurrentOptions = React.useCallback(() => {
+    const isFocused = navigation?.isFocused() ?? true;
+    if (!isFocused) {
+      return null;
+    }
+    const optionsFromListener = getOptionsFromListener();
+    if (optionsFromListener !== null) {
+      return optionsFromListener;
+    }
+    return optionsRef.current;
+  }, [navigation, getOptionsFromListener]);
+  React.useEffect(() => {
+    return parentAddOptionsGetter?.(key, getCurrentOptions);
+  }, [getCurrentOptions, parentAddOptionsGetter, key]);
+  const addOptionsGetter = React.useCallback((key, getter) => {
+    optionsGettersFromChildRef.current[key] = getter;
+    optionsChangeListener();
+    return () => {
+      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+      delete optionsGettersFromChildRef.current[key];
+      optionsChangeListener();
+    };
+  }, [optionsChangeListener]);
+  return {
+    addOptionsGetter,
+    getCurrentOptions
+  };
+}
+//# sourceMappingURL=useOptionsGetters.js.map