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

package/lib/commonjs/useDescriptors.js

@@ -0,0 +1,188 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useDescriptors = useDescriptors;
+var React = _interopRequireWildcard(require("react"));
+var _NavigationBuilderContext = require("./NavigationBuilderContext.js");
+var _NavigationContext = require("./NavigationContext.js");
+var _NavigationRouteContext = require("./NavigationRouteContext.js");
+var _SceneView = require("./SceneView.js");
+var _ThemeContext = require("./theming/ThemeContext.js");
+var _useNavigationCache = require("./useNavigationCache.js");
+var _useRouteCache = require("./useRouteCache.js");
+var _jsxRuntime = require("react/jsx-runtime");
+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 create descriptor objects for the child routes.
+ *
+ * A descriptor object provides 3 things:
+ * - Helper method to render a screen
+ * - Options specified by the screen for the navigator
+ * - Navigation object intended for the route
+ */
+function useDescriptors({
+  state,
+  screens,
+  navigation,
+  screenOptions,
+  screenLayout,
+  onAction,
+  getState,
+  setState,
+  addListener,
+  addKeyedListener,
+  onRouteFocus,
+  router,
+  emitter
+}) {
+  const theme = React.useContext(_ThemeContext.ThemeContext);
+  const [options, setOptions] = React.useState({});
+  const {
+    onDispatchAction,
+    onOptionsChange,
+    stackRef
+  } = React.useContext(_NavigationBuilderContext.NavigationBuilderContext);
+  const context = React.useMemo(() => ({
+    navigation,
+    onAction,
+    addListener,
+    addKeyedListener,
+    onRouteFocus,
+    onDispatchAction,
+    onOptionsChange,
+    stackRef
+  }), [navigation, onAction, addListener, addKeyedListener, onRouteFocus, onDispatchAction, onOptionsChange, stackRef]);
+  const {
+    base,
+    navigations
+  } = (0, _useNavigationCache.useNavigationCache)({
+    state,
+    getState,
+    navigation,
+    setOptions,
+    router,
+    emitter
+  });
+  const routes = (0, _useRouteCache.useRouteCache)(state.routes);
+  const getOptions = (route, navigation, overrides) => {
+    const config = screens[route.name];
+    const screen = config.props;
+    const optionsList = [
+    // The default `screenOptions` passed to the navigator
+    screenOptions,
+    // The `screenOptions` props passed to `Group` elements
+    ...(config.options ? config.options.filter(Boolean) : []),
+    // The `options` prop passed to `Screen` elements,
+    screen.options,
+    // The options set via `navigation.setOptions`
+    overrides];
+    return optionsList.reduce((acc, curr) => Object.assign(acc,
+    // @ts-expect-error: we check for function but TS still complains
+    typeof curr !== 'function' ? curr : curr({
+      route,
+      navigation,
+      theme
+    })), {});
+  };
+  const render = (route, navigation, customOptions, routeState) => {
+    const config = screens[route.name];
+    const screen = config.props;
+    const clearOptions = () => setOptions(o => {
+      if (route.key in o) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const {
+          [route.key]: _,
+          ...rest
+        } = o;
+        return rest;
+      }
+      return o;
+    });
+    const layout =
+    // The `layout` prop passed to `Screen` elements,
+    screen.layout ??
+    // The `screenLayout` props passed to `Group` elements
+    config.layout ??
+    // The default `screenLayout` passed to the navigator
+    screenLayout;
+    let element = /*#__PURE__*/(0, _jsxRuntime.jsx)(_SceneView.SceneView, {
+      navigation: navigation,
+      route: route,
+      screen: screen,
+      routeState: routeState,
+      getState: getState,
+      setState: setState,
+      options: customOptions,
+      clearOptions: clearOptions
+    });
+    if (layout != null) {
+      element = layout({
+        route,
+        navigation,
+        // @ts-expect-error: in practice `theme` will be defined
+        theme,
+        children: element
+      });
+    }
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_NavigationBuilderContext.NavigationBuilderContext.Provider, {
+      value: context,
+      children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_NavigationContext.NavigationContext.Provider, {
+        value: navigation,
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_NavigationRouteContext.NavigationRouteContext.Provider, {
+          value: route,
+          children: element
+        })
+      })
+    }, route.key);
+  };
+  const descriptors = routes.reduce((acc, route, i) => {
+    const navigation = navigations[route.key];
+    const customOptions = getOptions(route, navigation, options[route.key]);
+    const element = render(route, navigation, customOptions, state.routes[i].state);
+    acc[route.key] = {
+      route,
+      // @ts-expect-error: it's missing action helpers, fix later
+      navigation,
+      render() {
+        return element;
+      },
+      options: customOptions
+    };
+    return acc;
+  }, {});
+
+  /**
+   * Create a descriptor object for a route.
+   *
+   * @param route Route object for which the descriptor should be created
+   * @param placeholder Whether the descriptor should be a placeholder, e.g. for a route not yet in the state
+   * @returns Descriptor object
+   */
+  const describe = (route, placeholder) => {
+    if (!placeholder) {
+      if (!(route.key in descriptors)) {
+        throw new Error(`Couldn't find a route with the key ${route.key}.`);
+      }
+      return descriptors[route.key];
+    }
+    const navigation = base;
+    const customOptions = getOptions(route, navigation, {});
+    const element = render(route, navigation, customOptions, undefined);
+    return {
+      route,
+      navigation,
+      render() {
+        return element;
+      },
+      options: customOptions
+    };
+  };
+  return {
+    describe,
+    descriptors
+  };
+}
+//# sourceMappingURL=useDescriptors.js.map

package/lib/commonjs/useEventEmitter.js

@@ -0,0 +1,105 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useEventEmitter = useEventEmitter;
+var React = _interopRequireWildcard(require("react"));
+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 manage the event system used by the navigator to notify screens of various events.
+ */
+function useEventEmitter(listen) {
+  const listenRef = React.useRef(listen);
+  React.useEffect(() => {
+    listenRef.current = listen;
+  });
+  const listeners = React.useRef(Object.create(null));
+  const create = React.useCallback(target => {
+    const removeListener = (type, callback) => {
+      const callbacks = listeners.current[type] ? listeners.current[type][target] : undefined;
+      if (!callbacks) {
+        return;
+      }
+      const index = callbacks.indexOf(callback);
+      if (index > -1) {
+        callbacks.splice(index, 1);
+      }
+    };
+    const addListener = (type, callback) => {
+      listeners.current[type] = listeners.current[type] || {};
+      listeners.current[type][target] = listeners.current[type][target] || [];
+      listeners.current[type][target].push(callback);
+      let removed = false;
+      return () => {
+        // Prevent removing other listeners when unsubscribing same listener multiple times
+        if (!removed) {
+          removed = true;
+          removeListener(type, callback);
+        }
+      };
+    };
+    return {
+      addListener,
+      removeListener
+    };
+  }, []);
+  const emit = React.useCallback(({
+    type,
+    data,
+    target,
+    canPreventDefault
+  }) => {
+    const items = listeners.current[type] || {};
+
+    // Copy the current list of callbacks in case they are mutated during execution
+    const callbacks = target !== undefined ? items[target]?.slice() : [].concat(...Object.keys(items).map(t => items[t])).filter((cb, i, self) => self.lastIndexOf(cb) === i);
+    const event = {
+      get type() {
+        return type;
+      }
+    };
+    if (target !== undefined) {
+      Object.defineProperty(event, 'target', {
+        enumerable: true,
+        get() {
+          return target;
+        }
+      });
+    }
+    if (data !== undefined) {
+      Object.defineProperty(event, 'data', {
+        enumerable: true,
+        get() {
+          return data;
+        }
+      });
+    }
+    if (canPreventDefault) {
+      let defaultPrevented = false;
+      Object.defineProperties(event, {
+        defaultPrevented: {
+          enumerable: true,
+          get() {
+            return defaultPrevented;
+          }
+        },
+        preventDefault: {
+          enumerable: true,
+          value() {
+            defaultPrevented = true;
+          }
+        }
+      });
+    }
+    listenRef.current?.(event);
+    callbacks?.forEach(cb => cb(event));
+    return event;
+  }, []);
+  return React.useMemo(() => ({
+    create,
+    emit
+  }), [create, emit]);
+}
+//# sourceMappingURL=useEventEmitter.js.map

package/lib/commonjs/useFocusEffect.js

@@ -0,0 +1,80 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useFocusEffect = useFocusEffect;
+var React = _interopRequireWildcard(require("react"));
+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 run an effect in a focused screen, similar to `React.useEffect`.
+ * This can be used to perform side-effects such as fetching data or subscribing to events.
+ * The passed callback should be wrapped in `React.useCallback` to avoid running the effect too often.
+ *
+ * @param callback Memoized callback containing the effect, should optionally return a cleanup function.
+ */
+function useFocusEffect(effect) {
+  const navigation = (0, _useNavigation.useNavigation)();
+
+  // eslint-disable-next-line prefer-rest-params
+  if (arguments[1] !== undefined) {
+    const message = "You passed a second argument to 'useFocusEffect', but it only accepts one argument. " + "If you want to pass a dependency array, you can use 'React.useCallback':\n\n" + 'useFocusEffect(\n' + '  React.useCallback(() => {\n' + '    // Your code here\n' + '  }, [depA, depB])\n' + ');\n\n' + 'See usage guide: https://reactnavigation.org/docs/use-focus-effect';
+    console.error(message);
+  }
+  React.useEffect(() => {
+    let isFocused = false;
+    let cleanup;
+    const callback = () => {
+      const destroy = effect();
+      if (destroy === undefined || typeof destroy === 'function') {
+        return destroy;
+      }
+      if (process.env.NODE_ENV !== 'production') {
+        let message = 'An effect function must not return anything besides a function, which is used for clean-up.';
+        if (destroy === null) {
+          message += " You returned 'null'. If your effect does not require clean-up, return 'undefined' (or nothing).";
+        } else if (typeof destroy.then === 'function') {
+          message += "\n\nIt looks like you wrote 'useFocusEffect(async () => ...)' or returned a Promise. " + 'Instead, write the async function inside your effect ' + 'and call it immediately:\n\n' + 'useFocusEffect(\n' + '  React.useCallback(() => {\n' + '    async function fetchData() {\n' + '      // You can await here\n' + '      const response = await MyAPI.getData(someId);\n' + '      // ...\n' + '    }\n\n' + '    fetchData();\n' + '  }, [someId])\n' + ');\n\n' + 'See usage guide: https://reactnavigation.org/docs/use-focus-effect';
+        } else {
+          message += ` You returned '${JSON.stringify(destroy)}'.`;
+        }
+        console.error(message);
+      }
+    };
+
+    // We need to run the effect on initial render/dep changes if the screen is focused
+    if (navigation.isFocused()) {
+      cleanup = callback();
+      isFocused = true;
+    }
+    const unsubscribeFocus = navigation.addListener('focus', () => {
+      // If callback was already called for focus, avoid calling it again
+      // The focus event may also fire on initial render, so we guard against running the effect twice
+      if (isFocused) {
+        return;
+      }
+      if (cleanup !== undefined) {
+        cleanup();
+      }
+      cleanup = callback();
+      isFocused = true;
+    });
+    const unsubscribeBlur = navigation.addListener('blur', () => {
+      if (cleanup !== undefined) {
+        cleanup();
+      }
+      cleanup = undefined;
+      isFocused = false;
+    });
+    return () => {
+      if (cleanup !== undefined) {
+        cleanup();
+      }
+      unsubscribeFocus();
+      unsubscribeBlur();
+    };
+  }, [effect, navigation]);
+}
+//# sourceMappingURL=useFocusEffect.js.map

package/lib/commonjs/useFocusEvents.js

@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useFocusEvents = useFocusEvents;
+var React = _interopRequireWildcard(require("react"));
+var _NavigationContext = require("./NavigationContext.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 take care of emitting `focus` and `blur` events.
+ */
+function useFocusEvents({
+  state,
+  emitter
+}) {
+  const navigation = React.useContext(_NavigationContext.NavigationContext);
+  const lastFocusedKeyRef = React.useRef();
+  const currentFocusedKey = state.routes[state.index].key;
+
+  // When the parent screen changes its focus state, we also need to change child's focus
+  // Coz the child screen can't be focused if the parent screen is out of focus
+  React.useEffect(() => navigation?.addListener('focus', () => {
+    lastFocusedKeyRef.current = currentFocusedKey;
+    emitter.emit({
+      type: 'focus',
+      target: currentFocusedKey
+    });
+  }), [currentFocusedKey, emitter, navigation]);
+  React.useEffect(() => navigation?.addListener('blur', () => {
+    lastFocusedKeyRef.current = undefined;
+    emitter.emit({
+      type: 'blur',
+      target: currentFocusedKey
+    });
+  }), [currentFocusedKey, emitter, navigation]);
+  React.useEffect(() => {
+    const lastFocusedKey = lastFocusedKeyRef.current;
+    lastFocusedKeyRef.current = currentFocusedKey;
+
+    // We wouldn't have `lastFocusedKey` on initial mount
+    // Fire focus event for the current route on mount if there's no parent navigator
+    if (lastFocusedKey === undefined && !navigation) {
+      emitter.emit({
+        type: 'focus',
+        target: currentFocusedKey
+      });
+    }
+
+    // We should only emit events when the focused key changed and navigator is focused
+    // When navigator is not focused, screens inside shouldn't receive focused status either
+    if (lastFocusedKey === currentFocusedKey || !(navigation ? navigation.isFocused() : true)) {
+      return;
+    }
+    if (lastFocusedKey === undefined) {
+      // Only fire events after initial mount
+      return;
+    }
+    emitter.emit({
+      type: 'blur',
+      target: lastFocusedKey
+    });
+    emitter.emit({
+      type: 'focus',
+      target: currentFocusedKey
+    });
+  }, [currentFocusedKey, emitter, navigation]);
+}
+//# sourceMappingURL=useFocusEvents.js.map

package/lib/commonjs/useFocusedListenersChildrenAdapter.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useFocusedListenersChildrenAdapter = useFocusedListenersChildrenAdapter;
+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 for passing focus callback to children
+ */
+function useFocusedListenersChildrenAdapter({
+  navigation,
+  focusedListeners
+}) {
+  const {
+    addListener
+  } = React.useContext(_NavigationBuilderContext.NavigationBuilderContext);
+  const listener = React.useCallback(callback => {
+    if (navigation.isFocused()) {
+      for (const listener of focusedListeners) {
+        const {
+          handled,
+          result
+        } = listener(callback);
+        if (handled) {
+          return {
+            handled,
+            result
+          };
+        }
+      }
+      return {
+        handled: true,
+        result: callback(navigation)
+      };
+    } else {
+      return {
+        handled: false,
+        result: null
+      };
+    }
+  }, [focusedListeners, navigation]);
+  React.useEffect(() => addListener?.('focus', listener), [addListener, listener]);
+}
+//# sourceMappingURL=useFocusedListenersChildrenAdapter.js.map

package/lib/commonjs/useIsFocused.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useIsFocused = useIsFocused;
+var React = _interopRequireWildcard(require("react"));
+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 the current focus state of the screen. Returns a `true` if screen is focused, otherwise `false`.
+ * This can be used if a component needs to render something based on the focus state.
+ */
+function useIsFocused() {
+  const navigation = (0, _useNavigation.useNavigation)();
+  const subscribe = React.useCallback(callback => {
+    const unsubscribeFocus = navigation.addListener('focus', callback);
+    const unsubscribeBlur = navigation.addListener('blur', callback);
+    return () => {
+      unsubscribeFocus();
+      unsubscribeBlur();
+    };
+  }, [navigation]);
+  const value = React.useSyncExternalStore(subscribe, navigation.isFocused, navigation.isFocused);
+  return value;
+}
+//# sourceMappingURL=useIsFocused.js.map

package/lib/commonjs/useIsomorphicLayoutEffect.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useIsomorphicLayoutEffect = void 0;
+var _react = require("react");
+/**
+ * Use `useEffect` during SSR and `useLayoutEffect` in the browser to avoid warnings.
+ */
+const useIsomorphicLayoutEffect = exports.useIsomorphicLayoutEffect = typeof document !== 'undefined' ? _react.useLayoutEffect : _react.useEffect;
+//# sourceMappingURL=useIsomorphicLayoutEffect.js.map

package/lib/commonjs/useIsomorphicLayoutEffect.native.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useIsomorphicLayoutEffect = void 0;
+var _react = require("react");
+const useIsomorphicLayoutEffect = exports.useIsomorphicLayoutEffect = _react.useLayoutEffect;
+//# sourceMappingURL=useIsomorphicLayoutEffect.native.js.map

package/lib/commonjs/useKeyedChildListeners.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useKeyedChildListeners = useKeyedChildListeners;
+var React = _interopRequireWildcard(require("react"));
+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 which lets child navigators add getters to be called for obtaining rehydrated state.
+ */
+function useKeyedChildListeners() {
+  const {
+    current: keyedListeners
+  } = React.useRef(Object.assign(Object.create(null), {
+    getState: {},
+    beforeRemove: {}
+  }));
+  const addKeyedListener = React.useCallback((type, key, listener) => {
+    // @ts-expect-error: according to ref stated above you can use `key` to index type
+    keyedListeners[type][key] = listener;
+    return () => {
+      // @ts-expect-error: according to ref stated above you can use `key` to index type
+      keyedListeners[type][key] = undefined;
+    };
+  }, [keyedListeners]);
+  return {
+    keyedListeners,
+    addKeyedListener
+  };
+}
+//# sourceMappingURL=useKeyedChildListeners.js.map

package/lib/commonjs/useLazyValue.js

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

package/lib/commonjs/useNavigation.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useNavigation = useNavigation;
+var React = _interopRequireWildcard(require("react"));
+var _NavigationContainerRefContext = require("./NavigationContainerRefContext.js");
+var _NavigationContext = require("./NavigationContext.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 navigation prop of the parent screen anywhere.
+ *
+ * @returns Navigation prop of the parent screen.
+ */
+function useNavigation() {
+  const root = React.useContext(_NavigationContainerRefContext.NavigationContainerRefContext);
+  const navigation = React.useContext(_NavigationContext.NavigationContext);
+  if (navigation === undefined && root === undefined) {
+    throw new Error("Couldn't find a navigation object. Is your component inside NavigationContainer?");
+  }
+
+  // FIXME: Figure out a better way to do this
+  return navigation ?? root;
+}
+//# sourceMappingURL=useNavigation.js.map