@react-navigation/core 6.0.2

package/lib/commonjs/index.js

@@ -0,0 +1,227 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  BaseNavigationContainer: true,
+  createNavigationContainerRef: true,
+  createNavigatorFactory: true,
+  CurrentRenderContext: true,
+  findFocusedRoute: true,
+  getActionFromState: true,
+  getFocusedRouteNameFromRoute: true,
+  getPathFromState: true,
+  getStateFromPath: true,
+  NavigationContainerRefContext: true,
+  NavigationContext: true,
+  NavigationHelpersContext: true,
+  NavigationRouteContext: true,
+  useFocusEffect: true,
+  useIsFocused: true,
+  useNavigation: true,
+  useNavigationBuilder: true,
+  useNavigationContainerRef: true,
+  useNavigationState: true,
+  useRoute: true,
+  validatePathConfig: true
+};
+Object.defineProperty(exports, "BaseNavigationContainer", {
+  enumerable: true,
+  get: function () {
+    return _BaseNavigationContainer.default;
+  }
+});
+Object.defineProperty(exports, "createNavigationContainerRef", {
+  enumerable: true,
+  get: function () {
+    return _createNavigationContainerRef.default;
+  }
+});
+Object.defineProperty(exports, "createNavigatorFactory", {
+  enumerable: true,
+  get: function () {
+    return _createNavigatorFactory.default;
+  }
+});
+Object.defineProperty(exports, "CurrentRenderContext", {
+  enumerable: true,
+  get: function () {
+    return _CurrentRenderContext.default;
+  }
+});
+Object.defineProperty(exports, "findFocusedRoute", {
+  enumerable: true,
+  get: function () {
+    return _findFocusedRoute.default;
+  }
+});
+Object.defineProperty(exports, "getActionFromState", {
+  enumerable: true,
+  get: function () {
+    return _getActionFromState.default;
+  }
+});
+Object.defineProperty(exports, "getFocusedRouteNameFromRoute", {
+  enumerable: true,
+  get: function () {
+    return _getFocusedRouteNameFromRoute.default;
+  }
+});
+Object.defineProperty(exports, "getPathFromState", {
+  enumerable: true,
+  get: function () {
+    return _getPathFromState.default;
+  }
+});
+Object.defineProperty(exports, "getStateFromPath", {
+  enumerable: true,
+  get: function () {
+    return _getStateFromPath.default;
+  }
+});
+Object.defineProperty(exports, "NavigationContainerRefContext", {
+  enumerable: true,
+  get: function () {
+    return _NavigationContainerRefContext.default;
+  }
+});
+Object.defineProperty(exports, "NavigationContext", {
+  enumerable: true,
+  get: function () {
+    return _NavigationContext.default;
+  }
+});
+Object.defineProperty(exports, "NavigationHelpersContext", {
+  enumerable: true,
+  get: function () {
+    return _NavigationHelpersContext.default;
+  }
+});
+Object.defineProperty(exports, "NavigationRouteContext", {
+  enumerable: true,
+  get: function () {
+    return _NavigationRouteContext.default;
+  }
+});
+Object.defineProperty(exports, "useFocusEffect", {
+  enumerable: true,
+  get: function () {
+    return _useFocusEffect.default;
+  }
+});
+Object.defineProperty(exports, "useIsFocused", {
+  enumerable: true,
+  get: function () {
+    return _useIsFocused.default;
+  }
+});
+Object.defineProperty(exports, "useNavigation", {
+  enumerable: true,
+  get: function () {
+    return _useNavigation.default;
+  }
+});
+Object.defineProperty(exports, "useNavigationBuilder", {
+  enumerable: true,
+  get: function () {
+    return _useNavigationBuilder.default;
+  }
+});
+Object.defineProperty(exports, "useNavigationContainerRef", {
+  enumerable: true,
+  get: function () {
+    return _useNavigationContainerRef.default;
+  }
+});
+Object.defineProperty(exports, "useNavigationState", {
+  enumerable: true,
+  get: function () {
+    return _useNavigationState.default;
+  }
+});
+Object.defineProperty(exports, "useRoute", {
+  enumerable: true,
+  get: function () {
+    return _useRoute.default;
+  }
+});
+Object.defineProperty(exports, "validatePathConfig", {
+  enumerable: true,
+  get: function () {
+    return _validatePathConfig.default;
+  }
+});
+
+var _BaseNavigationContainer = _interopRequireDefault(require("./BaseNavigationContainer"));
+
+var _createNavigationContainerRef = _interopRequireDefault(require("./createNavigationContainerRef"));
+
+var _createNavigatorFactory = _interopRequireDefault(require("./createNavigatorFactory"));
+
+var _CurrentRenderContext = _interopRequireDefault(require("./CurrentRenderContext"));
+
+var _findFocusedRoute = _interopRequireDefault(require("./findFocusedRoute"));
+
+var _getActionFromState = _interopRequireDefault(require("./getActionFromState"));
+
+var _getFocusedRouteNameFromRoute = _interopRequireDefault(require("./getFocusedRouteNameFromRoute"));
+
+var _getPathFromState = _interopRequireDefault(require("./getPathFromState"));
+
+var _getStateFromPath = _interopRequireDefault(require("./getStateFromPath"));
+
+var _NavigationContainerRefContext = _interopRequireDefault(require("./NavigationContainerRefContext"));
+
+var _NavigationContext = _interopRequireDefault(require("./NavigationContext"));
+
+var _NavigationHelpersContext = _interopRequireDefault(require("./NavigationHelpersContext"));
+
+var _NavigationRouteContext = _interopRequireDefault(require("./NavigationRouteContext"));
+
+var _types = require("./types");
+
+Object.keys(_types).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _types[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _types[key];
+    }
+  });
+});
+
+var _useFocusEffect = _interopRequireDefault(require("./useFocusEffect"));
+
+var _useIsFocused = _interopRequireDefault(require("./useIsFocused"));
+
+var _useNavigation = _interopRequireDefault(require("./useNavigation"));
+
+var _useNavigationBuilder = _interopRequireDefault(require("./useNavigationBuilder"));
+
+var _useNavigationContainerRef = _interopRequireDefault(require("./useNavigationContainerRef"));
+
+var _useNavigationState = _interopRequireDefault(require("./useNavigationState"));
+
+var _useRoute = _interopRequireDefault(require("./useRoute"));
+
+var _validatePathConfig = _interopRequireDefault(require("./validatePathConfig"));
+
+var _routers = require("@react-navigation/routers");
+
+Object.keys(_routers).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _routers[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _routers[key];
+    }
+  });
+});
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+//# sourceMappingURL=index.js.map

package/lib/commonjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["index.tsx"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA","sourcesContent":["export { default as BaseNavigationContainer } from './BaseNavigationContainer';\nexport { default as createNavigationContainerRef } from './createNavigationContainerRef';\nexport { default as createNavigatorFactory } from './createNavigatorFactory';\nexport { default as CurrentRenderContext } from './CurrentRenderContext';\nexport { default as findFocusedRoute } from './findFocusedRoute';\nexport { default as getActionFromState } from './getActionFromState';\nexport { default as getFocusedRouteNameFromRoute } from './getFocusedRouteNameFromRoute';\nexport { default as getPathFromState } from './getPathFromState';\nexport { default as getStateFromPath } from './getStateFromPath';\nexport { default as NavigationContainerRefContext } from './NavigationContainerRefContext';\nexport { default as NavigationContext } from './NavigationContext';\nexport { default as NavigationHelpersContext } from './NavigationHelpersContext';\nexport { default as NavigationRouteContext } from './NavigationRouteContext';\nexport * from './types';\nexport { default as useFocusEffect } from './useFocusEffect';\nexport { default as useIsFocused } from './useIsFocused';\nexport { default as useNavigation } from './useNavigation';\nexport { default as useNavigationBuilder } from './useNavigationBuilder';\nexport { default as useNavigationContainerRef } from './useNavigationContainerRef';\nexport { default as useNavigationState } from './useNavigationState';\nexport { default as useRoute } from './useRoute';\nexport { default as validatePathConfig } from './validatePathConfig';\nexport * from '@react-navigation/routers';\n"]}

package/lib/commonjs/isArrayEqual.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isArrayEqual;
+
+/**
+ * Compare two arrays with primitive values as the content.
+ * We need to make sure that both values and order match.
+ */
+function isArrayEqual(a, b) {
+  return a.length === b.length && a.every((it, index) => it === b[index]);
+}
+//# sourceMappingURL=isArrayEqual.js.map

package/lib/commonjs/isArrayEqual.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["isArrayEqual.tsx"],"names":["isArrayEqual","a","b","length","every","it","index"],"mappings":";;;;;;;AAAA;AACA;AACA;AACA;AACe,SAASA,YAAT,CAAsBC,CAAtB,EAAgCC,CAAhC,EAA0C;AACvD,SAAOD,CAAC,CAACE,MAAF,KAAaD,CAAC,CAACC,MAAf,IAAyBF,CAAC,CAACG,KAAF,CAAQ,CAACC,EAAD,EAAKC,KAAL,KAAeD,EAAE,KAAKH,CAAC,CAACI,KAAD,CAA/B,CAAhC;AACD","sourcesContent":["/**\n * Compare two arrays with primitive values as the content.\n * We need to make sure that both values and order match.\n */\nexport default function isArrayEqual(a: any[], b: any[]) {\n  return a.length === b.length && a.every((it, index) => it === b[index]);\n}\n"]}

package/lib/commonjs/types.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PrivateValueStore = void 0;
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+class PrivateValueStore {
+  constructor() {
+    _defineProperty(this, '', void 0);
+  }
+
+}
+
+exports.PrivateValueStore = PrivateValueStore;
+//# sourceMappingURL=types.js.map

package/lib/commonjs/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["types.tsx"],"names":["PrivateValueStore"],"mappings":";;;;;;;;;AA2JO,MAAMA,iBAAN,CAAiC;AAAA;AAAA,0BAW5B,EAX4B;AAAA;;AAAA","sourcesContent":["import type {\n  DefaultRouterOptions,\n  InitialState,\n  NavigationAction,\n  NavigationState,\n  ParamListBase,\n  PartialState,\n  Route,\n} from '@react-navigation/routers';\nimport type * as React from 'react';\n\ndeclare global {\n  // eslint-disable-next-line @typescript-eslint/no-namespace\n  namespace ReactNavigation {\n    // eslint-disable-next-line @typescript-eslint/no-empty-interface\n    interface RootParamList {}\n  }\n}\n\ntype Keyof<T extends {}> = Extract<keyof T, string>;\n\nexport type DefaultNavigatorOptions<\n  ParamList extends ParamListBase,\n  State extends NavigationState,\n  ScreenOptions extends {},\n  EventMap extends EventMapBase\n> = DefaultRouterOptions<Keyof<ParamList>> & {\n  /**\n   * Children React Elements to extract the route configuration from.\n   * Only `Screen`, `Group` and `React.Fragment` are supported as children.\n   */\n  children: React.ReactNode;\n  /**\n   * Event listeners for all the screens in the navigator.\n   */\n  screenListeners?:\n    | ScreenListeners<State, EventMap>\n    | ((props: {\n        route: RouteProp<ParamList>;\n        navigation: any;\n      }) => ScreenListeners<State, EventMap>);\n  /**\n   * Default options for all screens under this navigator.\n   */\n  screenOptions?:\n    | ScreenOptions\n    | ((props: {\n        route: RouteProp<ParamList>;\n        navigation: any;\n      }) => ScreenOptions);\n  /**\n   * Default options specified by the navigator.\n   * It receives the custom options in the arguments if a function is specified.\n   */\n  defaultScreenOptions?:\n    | ScreenOptions\n    | ((props: {\n        route: RouteProp<ParamList>;\n        navigation: any;\n        options: ScreenOptions;\n      }) => ScreenOptions);\n};\n\nexport type EventMapBase = Record<\n  string,\n  { data?: any; canPreventDefault?: boolean }\n>;\n\nexport type EventMapCore<State extends NavigationState> = {\n  focus: { data: undefined };\n  blur: { data: undefined };\n  state: { data: { state: State } };\n  beforeRemove: { data: { action: NavigationAction }; canPreventDefault: true };\n};\n\nexport type EventArg<\n  EventName extends string,\n  CanPreventDefault extends boolean | undefined = false,\n  Data = undefined\n> = {\n  /**\n   * Type of the event (e.g. `focus`, `blur`)\n   */\n  readonly type: EventName;\n  readonly target?: string;\n} & (CanPreventDefault extends true\n  ? {\n      /**\n       * Whether `event.preventDefault()` was called on this event object.\n       */\n      readonly defaultPrevented: boolean;\n      /**\n       * Prevent the default action which happens on this event.\n       */\n      preventDefault(): void;\n    }\n  : {}) &\n  (undefined extends Data\n    ? { readonly data?: Readonly<Data> }\n    : { readonly data: Readonly<Data> });\n\nexport type EventListenerCallback<\n  EventMap extends EventMapBase,\n  EventName extends keyof EventMap\n> = (\n  e: EventArg<\n    Extract<EventName, string>,\n    EventMap[EventName]['canPreventDefault'],\n    EventMap[EventName]['data']\n  >\n) => void;\n\nexport type EventConsumer<EventMap extends EventMapBase> = {\n  /**\n   * Subscribe to events from the parent navigator.\n   *\n   * @param type Type of the event (e.g. `focus`, `blur`)\n   * @param callback Callback listener which is executed upon receiving the event.\n   */\n  addListener<EventName extends Keyof<EventMap>>(\n    type: EventName,\n    callback: EventListenerCallback<EventMap, EventName>\n  ): () => void;\n  removeListener<EventName extends Keyof<EventMap>>(\n    type: EventName,\n    callback: EventListenerCallback<EventMap, EventName>\n  ): void;\n};\n\nexport type EventEmitter<EventMap extends EventMapBase> = {\n  /**\n   * Emit an event to child screens.\n   *\n   * @param options.type Type of the event (e.g. `focus`, `blur`)\n   * @param [options.data] Optional information regarding the event.\n   * @param [options.target] Key of the target route which should receive the event.\n   * If not specified, all routes receive the event.\n   */\n  emit<EventName extends Keyof<EventMap>>(\n    options: {\n      type: EventName;\n      target?: string;\n    } & (EventMap[EventName]['canPreventDefault'] extends true\n      ? { canPreventDefault: true }\n      : {}) &\n      (undefined extends EventMap[EventName]['data']\n        ? { data?: EventMap[EventName]['data'] }\n        : { data: EventMap[EventName]['data'] })\n  ): EventArg<\n    EventName,\n    EventMap[EventName]['canPreventDefault'],\n    EventMap[EventName]['data']\n  >;\n};\n\nexport class PrivateValueStore<A, B, C> {\n  /**\n   * UGLY HACK! DO NOT USE THE TYPE!!!\n   *\n   * TypeScript requires a type to be used to be able to infer it.\n   * The type should exist as its own without any operations such as union.\n   * So we need to figure out a way to store this type in a property.\n   * The problem with a normal property is that it shows up in intelliSense.\n   * Adding private keyword works, but the annotation is stripped away in declaration.\n   * Turns out if we use an empty string, it doesn't show up in intelliSense.\n   */\n  protected ''?: { a: A; b: B; c: C };\n}\n\ntype NavigationHelpersCommon<\n  ParamList extends ParamListBase,\n  State extends NavigationState = NavigationState\n> = {\n  /**\n   * Dispatch an action or an update function to the router.\n   * The update function will receive the current state,\n   *\n   * @param action Action object or update function.\n   */\n  dispatch(\n    action: NavigationAction | ((state: State) => NavigationAction)\n  ): void;\n\n  /**\n   * Navigate to a route in current navigation tree.\n   *\n   * @param name Name of the route to navigate to.\n   * @param [params] Params object for the route.\n   */\n  navigate<RouteName extends keyof ParamList>(\n    ...args: undefined extends ParamList[RouteName]\n      ? [screen: RouteName] | [screen: RouteName, params: ParamList[RouteName]]\n      : [screen: RouteName, params: ParamList[RouteName]]\n  ): void;\n\n  /**\n   * Navigate to a route in current navigation tree.\n   *\n   * @param route Object with `key` or `name` for the route to navigate to, and a `params` object.\n   */\n  navigate<RouteName extends keyof ParamList>(\n    options:\n      | { key: string; params?: ParamList[RouteName]; merge?: boolean }\n      | {\n          name: RouteName;\n          key?: string;\n          params: ParamList[RouteName];\n          merge?: boolean;\n        }\n  ): void;\n\n  /**\n   * Reset the navigation state to the provided state.\n   *\n   * @param state Navigation state object.\n   */\n  reset(state: PartialState<State> | State): void;\n\n  /**\n   * Go back to the previous route in history.\n   */\n  goBack(): void;\n\n  /**\n   * Check if the screen is focused. The method returns `true` if focused, `false` otherwise.\n   * Note that this method doesn't re-render screen when the focus changes. So don't use it in `render`.\n   * To get notified of focus changes, use `addListener('focus', cb)` and `addListener('blur', cb)`.\n   * To conditionally render content based on focus state, use the `useIsFocused` hook.\n   */\n  isFocused(): boolean;\n\n  /**\n   * Check if dispatching back action will be handled by navigation.\n   * Note that this method doesn't re-render screen when the result changes. So don't use it in `render`.\n   */\n  canGoBack(): boolean;\n\n  /**\n   * Returns the navigation prop from the parent navigator,\n   */\n  getParent<T = NavigationProp<ParamListBase> | undefined>(): T;\n\n  /**\n   * Returns the navigator's state.\n   * Note that this method doesn't re-render screen when the result changes. So don't use it in `render`.\n   */\n  getState(): State;\n} & PrivateValueStore<ParamList, keyof ParamList, {}>;\n\nexport type NavigationHelpers<\n  ParamList extends ParamListBase,\n  EventMap extends EventMapBase = {}\n> = NavigationHelpersCommon<ParamList> &\n  EventEmitter<EventMap> & {\n    /**\n     * Update the param object for the route.\n     * The new params will be shallow merged with the old one.\n     *\n     * @param params Params object for the current route.\n     */\n    setParams<RouteName extends keyof ParamList>(\n      params: Partial<ParamList[RouteName]>\n    ): void;\n  };\n\nexport type NavigationContainerProps = {\n  /**\n   * Initial navigation state for the child navigators.\n   */\n  initialState?: InitialState;\n  /**\n   * Callback which is called with the latest navigation state when it changes.\n   */\n  onStateChange?: (state: NavigationState | undefined) => void;\n  /**\n   * Callback which is called when an action is not handled.\n   */\n  onUnhandledAction?: (action: NavigationAction) => void;\n  /**\n   * Whether this navigation container should be independent of parent containers.\n   * If this is not set to `true`, this container cannot be nested inside another container.\n   * Setting it to `true` disconnects any children navigators from parent container.\n   */\n  independent?: boolean;\n  /**\n   * Children elements to render.\n   */\n  children: React.ReactNode;\n};\n\nexport type NavigationProp<\n  ParamList extends {},\n  RouteName extends keyof ParamList = Keyof<ParamList>,\n  State extends NavigationState = NavigationState<ParamList>,\n  ScreenOptions extends {} = {},\n  EventMap extends EventMapBase = {}\n> = NavigationHelpersCommon<ParamList, State> & {\n  /**\n   * Update the param object for the route.\n   * The new params will be shallow merged with the old one.\n   *\n   * @param params Params object for the current route.\n   */\n  setParams(params: Partial<ParamList[RouteName]>): void;\n\n  /**\n   * Update the options for the route.\n   * The options object will be shallow merged with default options object.\n   *\n   * @param options Options object for the route.\n   */\n  setOptions(options: Partial<ScreenOptions>): void;\n} & EventConsumer<EventMap & EventMapCore<State>> &\n  PrivateValueStore<ParamList, RouteName, EventMap>;\n\nexport type RouteProp<\n  ParamList extends ParamListBase,\n  RouteName extends keyof ParamList = Keyof<ParamList>\n> = Route<Extract<RouteName, string>, ParamList[RouteName]>;\n\nexport type CompositeNavigationProp<\n  A extends NavigationProp<ParamListBase, string, any, any>,\n  B extends NavigationHelpersCommon<ParamListBase, any>\n> = Omit<A & B, keyof NavigationProp<any>> &\n  NavigationProp<\n    /**\n     * Param list from both navigation objects needs to be combined\n     * For example, we should be able to navigate to screens in both A and B\n     */\n    (A extends NavigationHelpersCommon<infer T> ? T : never) &\n      (B extends NavigationHelpersCommon<infer U> ? U : never),\n    /**\n     * The route name should refer to the route name specified in the first type\n     * Ideally it should work for any of them, but it's not possible to infer that way\n     */\n    A extends NavigationProp<any, infer R> ? R : string,\n    /**\n     * The type of state should refer to the state specified in the first type\n     */\n    A extends NavigationProp<any, any, infer S> ? S : NavigationState,\n    /**\n     * Screen options from both navigation objects needs to be combined\n     * This allows typechecking `setOptions`\n     */\n    (A extends NavigationProp<any, any, any, infer O> ? O : {}) &\n      (B extends NavigationProp<any, any, any, infer P> ? P : {}),\n    /**\n     * Event consumer config should refer to the config specified in the first type\n     * This allows typechecking `addListener`/`removeListener`\n     */\n    A extends NavigationProp<any, any, any, any, infer E> ? E : {}\n  >;\n\nexport type CompositeScreenProps<\n  A extends {\n    navigation: NavigationProp<ParamListBase, string, any, any>;\n    route: RouteProp<ParamListBase>;\n  },\n  B extends {\n    navigation: NavigationHelpersCommon<ParamListBase, any>;\n  }\n> = {\n  navigation: CompositeNavigationProp<A['navigation'], B['navigation']>;\n  route: A['route'];\n};\n\nexport type Descriptor<\n  ScreenOptions extends {},\n  Navigation extends NavigationProp<any, any, any, any, any>,\n  Route extends RouteProp<any, any>\n> = {\n  /**\n   * Render the component associated with this route.\n   */\n  render(): JSX.Element;\n\n  /**\n   * Options for the route.\n   */\n  options: ScreenOptions;\n\n  /**\n   * Route object for the screen\n   */\n  route: Route;\n\n  /**\n   * Navigation object for the screen\n   */\n  navigation: Navigation;\n};\n\nexport type ScreenListeners<\n  State extends NavigationState,\n  EventMap extends EventMapBase\n> = Partial<\n  {\n    [EventName in keyof (EventMap &\n      EventMapCore<State>)]: EventListenerCallback<EventMap, EventName>;\n  }\n>;\n\nexport type RouteConfigComponent<\n  ParamList extends ParamListBase,\n  RouteName extends keyof ParamList\n> =\n  | {\n      /**\n       * React component to render for this screen.\n       */\n      component: React.ComponentType<any>;\n      getComponent?: never;\n      children?: never;\n    }\n  | {\n      /**\n       * Lazily get a React component to render for this screen.\n       */\n      getComponent: () => React.ComponentType<any>;\n      component?: never;\n      children?: never;\n    }\n  | {\n      /**\n       * Render callback to render content of this screen.\n       */\n      children: (props: {\n        route: RouteProp<ParamList, RouteName>;\n        navigation: any;\n      }) => React.ReactNode;\n      component?: never;\n      getComponent?: never;\n    };\n\nexport type RouteConfig<\n  ParamList extends ParamListBase,\n  RouteName extends keyof ParamList,\n  State extends NavigationState,\n  ScreenOptions extends {},\n  EventMap extends EventMapBase\n> = {\n  /**\n   * Route name of this screen.\n   */\n  name: RouteName;\n\n  /**\n   * Navigator options for this screen.\n   */\n  options?:\n    | ScreenOptions\n    | ((props: {\n        route: RouteProp<ParamList, RouteName>;\n        navigation: any;\n      }) => ScreenOptions);\n\n  /**\n   * Event listeners for this screen.\n   */\n  listeners?:\n    | ScreenListeners<State, EventMap>\n    | ((props: {\n        route: RouteProp<ParamList, RouteName>;\n        navigation: any;\n      }) => ScreenListeners<State, EventMap>);\n\n  /**\n   * Function to return an unique ID for this screen.\n   * Receives an object with the route params.\n   * For a given screen name, there will always be only one screen corresponding to an ID.\n   * If `undefined` is returned, it acts same as no `getId` being specified.\n   */\n  getId?: ({ params }: { params: ParamList[RouteName] }) => string | undefined;\n\n  /**\n   * Initial params object for the route.\n   */\n  initialParams?: Partial<ParamList[RouteName]>;\n} & RouteConfigComponent<ParamList, RouteName>;\n\nexport type RouteGroupConfig<\n  ParamList extends ParamListBase,\n  ScreenOptions extends {}\n> = {\n  /**\n   * Navigator options for this screen.\n   */\n  screenOptions?:\n    | ScreenOptions\n    | ((props: {\n        route: RouteProp<ParamList, keyof ParamList>;\n        navigation: any;\n      }) => ScreenOptions);\n  /**\n   * Children React Elements to extract the route configuration from.\n   * Only `Screen`, `Group` and `React.Fragment` are supported as children.\n   */\n  children: React.ReactNode;\n};\n\nexport type NavigationContainerEventMap = {\n  /**\n   * Event which fires when the navigation state changes.\n   */\n  state: {\n    data: {\n      /**\n       * The updated state object after the state change.\n       */\n      state: NavigationState | PartialState<NavigationState> | undefined;\n    };\n  };\n  /**\n   * Event which fires when current options changes.\n   */\n  options: { data: { options: object } };\n  /**\n   * Event which fires when an action is dispatched.\n   * Only intended for debugging purposes, don't use it for app logic.\n   * This event will be emitted before state changes have been applied.\n   */\n  __unsafe_action__: {\n    data: {\n      /**\n       * The action object which was dispatched.\n       */\n      action: NavigationAction;\n      /**\n       * Whether the action was a no-op, i.e. resulted any state changes.\n       */\n      noop: boolean;\n      /**\n       * Stack trace of the action, this will only be available during development.\n       */\n      stack: string | undefined;\n    };\n  };\n};\n\nexport type NavigationContainerRef<ParamList extends {}> =\n  NavigationHelpers<ParamList> &\n    EventConsumer<NavigationContainerEventMap> & {\n      /**\n       * Reset the navigation state of the root navigator to the provided state.\n       *\n       * @param state Navigation state object.\n       */\n      resetRoot(state?: PartialState<NavigationState> | NavigationState): void;\n      /**\n       * Get the rehydrated navigation state of the navigation tree.\n       */\n      getRootState(): NavigationState;\n      /**\n       * Get the currently focused navigation route.\n       */\n      getCurrentRoute(): Route<string> | undefined;\n      /**\n       * Get the currently focused route's options.\n       */\n      getCurrentOptions(): object | undefined;\n      /**\n       * Whether the navigation container is ready to handle actions.\n       */\n      isReady(): boolean;\n    };\n\nexport type NavigationContainerRefWithCurrent<ParamList extends {}> =\n  NavigationContainerRef<ParamList> & {\n    current: NavigationContainerRef<ParamList> | null;\n  };\n\nexport type TypedNavigator<\n  ParamList extends ParamListBase,\n  State extends NavigationState,\n  ScreenOptions extends {},\n  EventMap extends EventMapBase,\n  Navigator extends React.ComponentType<any>\n> = {\n  /**\n   * Navigator component which manages the child screens.\n   */\n  Navigator: React.ComponentType<\n    Omit<\n      React.ComponentProps<Navigator>,\n      keyof DefaultNavigatorOptions<any, any, any, any>\n    > &\n      DefaultNavigatorOptions<ParamList, State, ScreenOptions, EventMap>\n  >;\n  /**\n   * Component used for grouping multiple route configuration.\n   */\n  Group: React.ComponentType<RouteGroupConfig<ParamList, ScreenOptions>>;\n  /**\n   * Component used for specifying route configuration.\n   */\n  Screen: <RouteName extends keyof ParamList>(\n    _: RouteConfig<ParamList, RouteName, State, ScreenOptions, EventMap>\n  ) => null;\n};\n\nexport type NavigatorScreenParams<\n  ParamList,\n  State extends NavigationState = NavigationState\n> =\n  | {\n      screen?: never;\n      params?: never;\n      initial?: never;\n      path?: string;\n      state: PartialState<State> | State | undefined;\n    }\n  | {\n      [RouteName in keyof ParamList]: undefined extends ParamList[RouteName]\n        ? {\n            screen: RouteName;\n            params?: ParamList[RouteName];\n            initial?: boolean;\n            path?: string;\n            state?: never;\n          }\n        : {\n            screen: RouteName;\n            params: ParamList[RouteName];\n            initial?: boolean;\n            path?: string;\n            state?: never;\n          };\n    }[keyof ParamList];\n\nexport type PathConfig<ParamList extends {}> = {\n  path?: string;\n  exact?: boolean;\n  parse?: Record<string, (value: string) => any>;\n  stringify?: Record<string, (value: any) => string>;\n  screens?: PathConfigMap<ParamList>;\n  initialRouteName?: keyof ParamList;\n};\n\nexport type PathConfigMap<ParamList extends {}> = {\n  [RouteName in keyof ParamList]?: NonNullable<\n    ParamList[RouteName]\n  > extends NavigatorScreenParams<infer T, any>\n    ? string | PathConfig<T>\n    : string | Omit<PathConfig<{}>, 'screens' | 'initialRouteName'>;\n};\n"]}

package/lib/commonjs/useChildListeners.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useChildListeners;
+
+var React = _interopRequireWildcard(require("react"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+/**
+ * Hook which lets child navigators add action listeners.
+ */
+function useChildListeners() {
+  const {
+    current: listeners
+  } = React.useRef({
+    action: [],
+    focus: []
+  });
+  const addListener = React.useCallback((type, listener) => {
+    // @ts-expect-error: listener should be correct type according to `type`
+    listeners[type].push(listener);
+    return () => {
+      // @ts-expect-error: listener should be correct type according to `type`
+      const index = listeners[type].indexOf(listener);
+      listeners[type].splice(index, 1);
+    };
+  }, [listeners]);
+  return {
+    listeners,
+    addListener
+  };
+}
+//# sourceMappingURL=useChildListeners.js.map

package/lib/commonjs/useChildListeners.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useChildListeners.tsx"],"names":["useChildListeners","current","listeners","React","useRef","action","focus","addListener","useCallback","type","listener","push","index","indexOf","splice"],"mappings":";;;;;;;AAAA;;;;;;AAIA;AACA;AACA;AACe,SAASA,iBAAT,GAA6B;AAC1C,QAAM;AAAEC,IAAAA,OAAO,EAAEC;AAAX,MAAyBC,KAAK,CAACC,MAAN,CAI7B;AACAC,IAAAA,MAAM,EAAE,EADR;AAEAC,IAAAA,KAAK,EAAE;AAFP,GAJ6B,CAA/B;AASA,QAAMC,WAAW,GAAGJ,KAAK,CAACK,WAAN,CAClB,CAA8BC,IAA9B,EAAuCC,QAAvC,KAAoE;AAClE;AACAR,IAAAA,SAAS,CAACO,IAAD,CAAT,CAAgBE,IAAhB,CAAqBD,QAArB;AAEA,WAAO,MAAM;AACX;AACA,YAAME,KAAK,GAAGV,SAAS,CAACO,IAAD,CAAT,CAAgBI,OAAhB,CAAwBH,QAAxB,CAAd;AAEAR,MAAAA,SAAS,CAACO,IAAD,CAAT,CAAgBK,MAAhB,CAAuBF,KAAvB,EAA8B,CAA9B;AACD,KALD;AAMD,GAXiB,EAYlB,CAACV,SAAD,CAZkB,CAApB;AAeA,SAAO;AACLA,IAAAA,SADK;AAELK,IAAAA;AAFK,GAAP;AAID","sourcesContent":["import * as React from 'react';\n\nimport type { ListenerMap } from './NavigationBuilderContext';\n\n/**\n * Hook which lets child navigators add action listeners.\n */\nexport default function useChildListeners() {\n  const { current: listeners } = React.useRef<\n    {\n      [K in keyof ListenerMap]: ListenerMap[K][];\n    }\n  >({\n    action: [],\n    focus: [],\n  });\n\n  const addListener = React.useCallback(\n    <T extends keyof ListenerMap>(type: T, listener: ListenerMap[T]) => {\n      // @ts-expect-error: listener should be correct type according to `type`\n      listeners[type].push(listener);\n\n      return () => {\n        // @ts-expect-error: listener should be correct type according to `type`\n        const index = listeners[type].indexOf(listener);\n\n        listeners[type].splice(index, 1);\n      };\n    },\n    [listeners]\n  );\n\n  return {\n    listeners,\n    addListener,\n  };\n}\n"]}

package/lib/commonjs/useComponent.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useComponent;
+
+var React = _interopRequireWildcard(require("react"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+function useComponent(Component, props) {
+  const propsRef = React.useRef(props); // Normally refs shouldn't be mutated in render
+  // But we return a component which will be rendered
+  // So it's just for immediate consumption
+
+  propsRef.current = props;
+  React.useEffect(() => {
+    propsRef.current = null;
+  });
+  return React.useRef(rest => {
+    const props = propsRef.current;
+
+    if (props === null) {
+      throw new Error('The returned component must be rendered in the same render phase as the hook.');
+    } // @ts-expect-error: the props should be fine here
+
+
+    return /*#__PURE__*/React.createElement(Component, _extends({}, props, rest));
+  }).current;
+}
+//# sourceMappingURL=useComponent.js.map

package/lib/commonjs/useComponent.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useComponent.tsx"],"names":["useComponent","Component","props","propsRef","React","useRef","current","useEffect","rest","Error"],"mappings":";;;;;;;AAAA;;;;;;;;AAEe,SAASA,YAAT,CAGbC,SAHa,EAGCC,KAHD,EAGW;AACxB,QAAMC,QAAQ,GAAGC,KAAK,CAACC,MAAN,CAAuBH,KAAvB,CAAjB,CADwB,CAGxB;AACA;AACA;;AACAC,EAAAA,QAAQ,CAACG,OAAT,GAAmBJ,KAAnB;AAEAE,EAAAA,KAAK,CAACG,SAAN,CAAgB,MAAM;AACpBJ,IAAAA,QAAQ,CAACG,OAAT,GAAmB,IAAnB;AACD,GAFD;AAIA,SAAOF,KAAK,CAACC,MAAN,CAAcG,IAAD,IAAkD;AACpE,UAAMN,KAAK,GAAGC,QAAQ,CAACG,OAAvB;;AAEA,QAAIJ,KAAK,KAAK,IAAd,EAAoB;AAClB,YAAM,IAAIO,KAAJ,CACJ,+EADI,CAAN;AAGD,KAPmE,CASpE;;;AACA,wBAAO,oBAAC,SAAD,eAAeP,KAAf,EAA0BM,IAA1B,EAAP;AACD,GAXM,EAWJF,OAXH;AAYD","sourcesContent":["import * as React from 'react';\n\nexport default function useComponent<\n  T extends React.ComponentType<any>,\n  P extends {}\n>(Component: T, props: P) {\n  const propsRef = React.useRef<P | null>(props);\n\n  // Normally refs shouldn't be mutated in render\n  // But we return a component which will be rendered\n  // So it's just for immediate consumption\n  propsRef.current = props;\n\n  React.useEffect(() => {\n    propsRef.current = null;\n  });\n\n  return React.useRef((rest: Omit<React.ComponentProps<T>, keyof P>) => {\n    const props = propsRef.current;\n\n    if (props === null) {\n      throw new Error(\n        'The returned component must be rendered in the same render phase as the hook.'\n      );\n    }\n\n    // @ts-expect-error: the props should be fine here\n    return <Component {...props} {...rest} />;\n  }).current;\n}\n"]}

package/lib/commonjs/useCurrentRender.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useCurrentRender;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _CurrentRenderContext = _interopRequireDefault(require("./CurrentRenderContext"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+/**
+ * Write the current options, so that server renderer can get current values
+ * Mutating values like this is not safe in async mode, but it doesn't apply to SSR
+ */
+function useCurrentRender({
+  state,
+  navigation,
+  descriptors
+}) {
+  const current = React.useContext(_CurrentRenderContext.default);
+
+  if (current && navigation.isFocused()) {
+    current.options = descriptors[state.routes[state.index].key].options;
+  }
+}
+//# sourceMappingURL=useCurrentRender.js.map

package/lib/commonjs/useCurrentRender.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useCurrentRender.tsx"],"names":["useCurrentRender","state","navigation","descriptors","current","React","useContext","CurrentRenderContext","isFocused","options","routes","index","key"],"mappings":";;;;;;;AACA;;AAEA;;;;;;;;AAiBA;AACA;AACA;AACA;AACe,SAASA,gBAAT,CAA0B;AACvCC,EAAAA,KADuC;AAEvCC,EAAAA,UAFuC;AAGvCC,EAAAA;AAHuC,CAA1B,EAIH;AACV,QAAMC,OAAO,GAAGC,KAAK,CAACC,UAAN,CAAiBC,6BAAjB,CAAhB;;AAEA,MAAIH,OAAO,IAAIF,UAAU,CAACM,SAAX,EAAf,EAAuC;AACrCJ,IAAAA,OAAO,CAACK,OAAR,GAAkBN,WAAW,CAACF,KAAK,CAACS,MAAN,CAAaT,KAAK,CAACU,KAAnB,EAA0BC,GAA3B,CAAX,CAA2CH,OAA7D;AACD;AACF","sourcesContent":["import type { NavigationState, ParamListBase } from '@react-navigation/routers';\nimport * as React from 'react';\n\nimport CurrentRenderContext from './CurrentRenderContext';\nimport type {\n  Descriptor,\n  NavigationHelpers,\n  NavigationProp,\n  RouteProp,\n} from './types';\n\ntype Options = {\n  state: NavigationState;\n  navigation: NavigationHelpers<ParamListBase>;\n  descriptors: Record<\n    string,\n    Descriptor<object, NavigationProp<ParamListBase>, RouteProp<ParamListBase>>\n  >;\n};\n\n/**\n * Write the current options, so that server renderer can get current values\n * Mutating values like this is not safe in async mode, but it doesn't apply to SSR\n */\nexport default function useCurrentRender({\n  state,\n  navigation,\n  descriptors,\n}: Options) {\n  const current = React.useContext(CurrentRenderContext);\n\n  if (current && navigation.isFocused()) {\n    current.options = descriptors[state.routes[state.index].key].options;\n  }\n}\n"]}

package/lib/commonjs/useDescriptors.js

@@ -0,0 +1,141 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useDescriptors;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _NavigationBuilderContext = _interopRequireDefault(require("./NavigationBuilderContext"));
+
+var _NavigationContext = _interopRequireDefault(require("./NavigationContext"));
+
+var _NavigationRouteContext = _interopRequireDefault(require("./NavigationRouteContext"));
+
+var _SceneView = _interopRequireDefault(require("./SceneView"));
+
+var _useNavigationCache = _interopRequireDefault(require("./useNavigationCache"));
+
+var _useRouteCache = _interopRequireDefault(require("./useRouteCache"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+/**
+ * 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,
+  defaultScreenOptions,
+  onAction,
+  getState,
+  setState,
+  addListener,
+  addKeyedListener,
+  onRouteFocus,
+  router,
+  emitter
+}) {
+  const [options, setOptions] = React.useState({});
+  const {
+    onDispatchAction,
+    onOptionsChange,
+    stackRef
+  } = React.useContext(_NavigationBuilderContext.default);
+  const context = React.useMemo(() => ({
+    navigation,
+    onAction,
+    addListener,
+    addKeyedListener,
+    onRouteFocus,
+    onDispatchAction,
+    onOptionsChange,
+    stackRef
+  }), [navigation, onAction, addListener, addKeyedListener, onRouteFocus, onDispatchAction, onOptionsChange, stackRef]);
+  const navigations = (0, _useNavigationCache.default)({
+    state,
+    getState,
+    navigation,
+    setOptions,
+    router,
+    emitter
+  });
+  const routes = (0, _useRouteCache.default)(state.routes);
+  return routes.reduce((acc, route, i) => {
+    const config = screens[route.name];
+    const screen = config[1];
+    const navigation = navigations[route.key];
+    const optionsList = [// The default `screenOptions` passed to the navigator
+    screenOptions, // The `screenOptions` props passed to `Group` elements
+    ...(config[0] ? config[0].filter(Boolean) : []), // The `options` prop passed to `Screen` elements,
+    screen.options, // The options set via `navigation.setOptions`
+    options[route.key]];
+    const customOptions = optionsList.reduce((acc, curr) => Object.assign(acc, typeof curr !== 'function' ? curr : curr({
+      route,
+      navigation
+    })), {});
+    const mergedOptions = { ...(typeof defaultScreenOptions === 'function' ? // @ts-expect-error: ts gives incorrect error here
+      defaultScreenOptions({
+        route,
+        navigation,
+        options: customOptions
+      }) : defaultScreenOptions),
+      ...customOptions
+    };
+
+    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;
+    });
+
+    acc[route.key] = {
+      route,
+      // @ts-expect-error: it's missing action helpers, fix later
+      navigation,
+
+      render() {
+        return /*#__PURE__*/React.createElement(_NavigationBuilderContext.default.Provider, {
+          key: route.key,
+          value: context
+        }, /*#__PURE__*/React.createElement(_NavigationContext.default.Provider, {
+          value: navigation
+        }, /*#__PURE__*/React.createElement(_NavigationRouteContext.default.Provider, {
+          value: route
+        }, /*#__PURE__*/React.createElement(_SceneView.default, {
+          navigation: navigation,
+          route: route,
+          screen: screen,
+          routeState: state.routes[i].state,
+          getState: getState,
+          setState: setState,
+          options: mergedOptions,
+          clearOptions: clearOptions
+        }))));
+      },
+
+      options: mergedOptions
+    };
+    return acc;
+  }, {});
+}
+//# sourceMappingURL=useDescriptors.js.map

package/lib/commonjs/useDescriptors.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useDescriptors.tsx"],"names":["useDescriptors","state","screens","navigation","screenOptions","defaultScreenOptions","onAction","getState","setState","addListener","addKeyedListener","onRouteFocus","router","emitter","options","setOptions","React","useState","onDispatchAction","onOptionsChange","stackRef","useContext","NavigationBuilderContext","context","useMemo","navigations","routes","reduce","acc","route","i","config","name","screen","key","optionsList","filter","Boolean","customOptions","curr","Object","assign","mergedOptions","clearOptions","o","_","rest","render"],"mappings":"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","sourcesContent":["import type {\n  NavigationAction,\n  NavigationState,\n  ParamListBase,\n  Router,\n} from '@react-navigation/routers';\nimport * as React from 'react';\n\nimport NavigationBuilderContext, {\n  AddKeyedListener,\n  AddListener,\n} from './NavigationBuilderContext';\nimport NavigationContext from './NavigationContext';\nimport NavigationRouteContext from './NavigationRouteContext';\nimport SceneView from './SceneView';\nimport type {\n  Descriptor,\n  EventMapBase,\n  NavigationHelpers,\n  NavigationProp,\n  RouteConfig,\n  RouteProp,\n} from './types';\nimport type { NavigationEventEmitter } from './useEventEmitter';\nimport useNavigationCache from './useNavigationCache';\nimport useRouteCache from './useRouteCache';\n\nexport type ScreenConfigWithParent<\n  State extends NavigationState,\n  ScreenOptions extends {},\n  EventMap extends EventMapBase\n> = [\n  (ScreenOptionsOrCallback<ScreenOptions> | undefined)[] | undefined,\n  RouteConfig<ParamListBase, string, State, ScreenOptions, EventMap>\n];\n\ntype ScreenOptionsOrCallback<ScreenOptions extends {}> =\n  | ScreenOptions\n  | ((props: {\n      route: RouteProp<ParamListBase, string>;\n      navigation: any;\n    }) => ScreenOptions);\n\ntype Options<\n  State extends NavigationState,\n  ScreenOptions extends {},\n  EventMap extends EventMapBase\n> = {\n  state: State;\n  screens: Record<\n    string,\n    ScreenConfigWithParent<State, ScreenOptions, EventMap>\n  >;\n  navigation: NavigationHelpers<ParamListBase>;\n  screenOptions?: ScreenOptionsOrCallback<ScreenOptions>;\n  defaultScreenOptions?:\n    | ScreenOptions\n    | ((props: {\n        route: RouteProp<ParamListBase>;\n        navigation: any;\n        options: ScreenOptions;\n      }) => ScreenOptions);\n  onAction: (action: NavigationAction) => boolean;\n  getState: () => State;\n  setState: (state: State) => void;\n  addListener: AddListener;\n  addKeyedListener: AddKeyedListener;\n  onRouteFocus: (key: string) => void;\n  router: Router<State, NavigationAction>;\n  emitter: NavigationEventEmitter<EventMap>;\n};\n\n/**\n * Hook to create descriptor objects for the child routes.\n *\n * A descriptor object provides 3 things:\n * - Helper method to render a screen\n * - Options specified by the screen for the navigator\n * - Navigation object intended for the route\n */\nexport default function useDescriptors<\n  State extends NavigationState,\n  ActionHelpers extends Record<string, () => void>,\n  ScreenOptions extends {},\n  EventMap extends EventMapBase\n>({\n  state,\n  screens,\n  navigation,\n  screenOptions,\n  defaultScreenOptions,\n  onAction,\n  getState,\n  setState,\n  addListener,\n  addKeyedListener,\n  onRouteFocus,\n  router,\n  emitter,\n}: Options<State, ScreenOptions, EventMap>) {\n  const [options, setOptions] = React.useState<Record<string, object>>({});\n  const { onDispatchAction, onOptionsChange, stackRef } = React.useContext(\n    NavigationBuilderContext\n  );\n\n  const context = React.useMemo(\n    () => ({\n      navigation,\n      onAction,\n      addListener,\n      addKeyedListener,\n      onRouteFocus,\n      onDispatchAction,\n      onOptionsChange,\n      stackRef,\n    }),\n    [\n      navigation,\n      onAction,\n      addListener,\n      addKeyedListener,\n      onRouteFocus,\n      onDispatchAction,\n      onOptionsChange,\n      stackRef,\n    ]\n  );\n\n  const navigations = useNavigationCache<State, ScreenOptions, EventMap>({\n    state,\n    getState,\n    navigation,\n    setOptions,\n    router,\n    emitter,\n  });\n\n  const routes = useRouteCache(state.routes);\n\n  return routes.reduce<\n    Record<\n      string,\n      Descriptor<\n        ScreenOptions,\n        NavigationProp<ParamListBase, string, State, ScreenOptions, EventMap> &\n          ActionHelpers,\n        RouteProp<ParamListBase>\n      >\n    >\n  >((acc, route, i) => {\n    const config = screens[route.name];\n    const screen = config[1];\n    const navigation = navigations[route.key];\n\n    const optionsList = [\n      // The default `screenOptions` passed to the navigator\n      screenOptions,\n      // The `screenOptions` props passed to `Group` elements\n      ...((config[0]\n        ? config[0].filter(Boolean)\n        : []) as ScreenOptionsOrCallback<ScreenOptions>[]),\n      // The `options` prop passed to `Screen` elements,\n      screen.options,\n      // The options set via `navigation.setOptions`\n      options[route.key],\n    ];\n\n    const customOptions = optionsList.reduce<ScreenOptions>(\n      (acc, curr) =>\n        Object.assign(\n          acc,\n          typeof curr !== 'function' ? curr : curr({ route, navigation })\n        ),\n      {} as ScreenOptions\n    );\n\n    const mergedOptions = {\n      ...(typeof defaultScreenOptions === 'function'\n        ? // @ts-expect-error: ts gives incorrect error here\n          defaultScreenOptions({\n            route,\n            navigation,\n            options: customOptions,\n          })\n        : defaultScreenOptions),\n      ...customOptions,\n    };\n\n    const clearOptions = () =>\n      setOptions((o) => {\n        if (route.key in o) {\n          // eslint-disable-next-line @typescript-eslint/no-unused-vars\n          const { [route.key]: _, ...rest } = o;\n          return rest;\n        }\n\n        return o;\n      });\n\n    acc[route.key] = {\n      route,\n      // @ts-expect-error: it's missing action helpers, fix later\n      navigation,\n      render() {\n        return (\n          <NavigationBuilderContext.Provider key={route.key} value={context}>\n            <NavigationContext.Provider value={navigation}>\n              <NavigationRouteContext.Provider value={route}>\n                <SceneView\n                  navigation={navigation}\n                  route={route}\n                  screen={screen}\n                  routeState={state.routes[i].state}\n                  getState={getState}\n                  setState={setState}\n                  options={mergedOptions}\n                  clearOptions={clearOptions}\n                />\n              </NavigationRouteContext.Provider>\n            </NavigationContext.Provider>\n          </NavigationBuilderContext.Provider>\n        );\n      },\n      options: mergedOptions as ScreenOptions,\n    };\n\n    return acc;\n  }, {});\n}\n"]}