@react-navigation/core 6.0.2

package/lib/module/useRouteCache.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useRouteCache.tsx"],"names":["React","CHILD_STATE","Symbol","useRouteCache","routes","cache","useMemo","current","Map","process","env","NODE_ENV","reduce","acc","route","previous","get","set","state","proxy","Object","defineProperty","enumerable","value","Array","from","values"],"mappings":"AAKA,OAAO,KAAKA,KAAZ,MAAuB,OAAvB;;AAMA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,WAAW,GAAGC,MAAM,CAAC,aAAD,CAA1B;AAEP;AACA;AACA;AACA;;AACA,eAAe,SAASC,aAAT,CACbC,MADa,EAEb;AACA;AACA,QAAMC,KAAK,GAAGL,KAAK,CAACM,OAAN,CAAc,OAAO;AAAEC,IAAAA,OAAO,EAAE,IAAIC,GAAJ;AAAX,GAAP,CAAd,EAA4D,EAA5D,CAAd;;AAEA,MAAIC,OAAO,CAACC,GAAR,CAAYC,QAAZ,KAAyB,YAA7B,EAA2C;AACzC;AACA,WAAOP,MAAP;AACD;;AAEDC,EAAAA,KAAK,CAACE,OAAN,GAAgBH,MAAM,CAACQ,MAAP,CAAc,CAACC,GAAD,EAAMC,KAAN,KAAgB;AAC5C,UAAMC,QAAQ,GAAGV,KAAK,CAACE,OAAN,CAAcS,GAAd,CAAkBF,KAAlB,CAAjB;;AAEA,QAAIC,QAAJ,EAAc;AACZ;AACAF,MAAAA,GAAG,CAACI,GAAJ,CAAQH,KAAR,EAAeC,QAAf;AACD,KAHD,MAGO;AACL,YAAM;AAAEG,QAAAA,KAAF;AAAS,WAAGC;AAAZ,UAAsBL,KAA5B;AAEAM,MAAAA,MAAM,CAACC,cAAP,CAAsBF,KAAtB,EAA6BlB,WAA7B,EAA0C;AACxCqB,QAAAA,UAAU,EAAE,KAD4B;AAExCC,QAAAA,KAAK,EAAEL;AAFiC,OAA1C;AAKAL,MAAAA,GAAG,CAACI,GAAJ,CAAQH,KAAR,EAAeK,KAAf;AACD;;AAED,WAAON,GAAP;AACD,GAlBe,EAkBb,IAAIL,GAAJ,EAlBa,CAAhB;AAoBA,SAAOgB,KAAK,CAACC,IAAN,CAAWpB,KAAK,CAACE,OAAN,CAAcmB,MAAd,EAAX,CAAP;AACD","sourcesContent":["import type {\n  NavigationState,\n  ParamListBase,\n  Route,\n} from '@react-navigation/routers';\nimport * as React from 'react';\n\nimport type { RouteProp } from './types';\n\ntype RouteCache = Map<Route<string>, RouteProp<ParamListBase>>;\n\n/**\n * Utilites such as `getFocusedRouteNameFromRoute` need to access state.\n * So we need a way to suppress the warning for those use cases.\n * This is fine since they are internal utilities and this is not public API.\n */\nexport const CHILD_STATE = Symbol('CHILD_STATE');\n\n/**\n * Hook to cache route props for each screen in the navigator.\n * This lets add warnings and modifications to the route object but keep references between renders.\n */\nexport default function useRouteCache<State extends NavigationState>(\n  routes: State['routes']\n) {\n  // Cache object which holds route objects for each screen\n  const cache = React.useMemo(() => ({ current: new Map() as RouteCache }), []);\n\n  if (process.env.NODE_ENV === 'production') {\n    // We don't want the overhead of creating extra maps every render in prod\n    return routes;\n  }\n\n  cache.current = routes.reduce((acc, route) => {\n    const previous = cache.current.get(route);\n\n    if (previous) {\n      // If a cached route object already exists, reuse it\n      acc.set(route, previous);\n    } else {\n      const { state, ...proxy } = route;\n\n      Object.defineProperty(proxy, CHILD_STATE, {\n        enumerable: false,\n        value: state,\n      });\n\n      acc.set(route, proxy);\n    }\n\n    return acc;\n  }, new Map() as RouteCache);\n\n  return Array.from(cache.current.values());\n}\n"]}

package/lib/module/useScheduleUpdate.js

@@ -0,0 +1,29 @@
+import * as React from 'react';
+const MISSING_CONTEXT_ERROR = "Couldn't find a schedule context.";
+export const ScheduleUpdateContext = /*#__PURE__*/React.createContext({
+  scheduleUpdate() {
+    throw new Error(MISSING_CONTEXT_ERROR);
+  },
+
+  flushUpdates() {
+    throw new Error(MISSING_CONTEXT_ERROR);
+  }
+
+});
+/**
+ * When screen config changes, we want to update the navigator in the same update phase.
+ * However, navigation state is in the root component and React won't let us update it from a child.
+ * This is a workaround for that, the scheduled update is stored in the ref without actually calling setState.
+ * It lets all subsequent updates access the latest state so it stays correct.
+ * Then we call setState during after the component updates.
+ */
+
+export default function useScheduleUpdate(callback) {
+  const {
+    scheduleUpdate,
+    flushUpdates
+  } = React.useContext(ScheduleUpdateContext);
+  scheduleUpdate(callback);
+  React.useEffect(flushUpdates);
+}
+//# sourceMappingURL=useScheduleUpdate.js.map

package/lib/module/useScheduleUpdate.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useScheduleUpdate.tsx"],"names":["React","MISSING_CONTEXT_ERROR","ScheduleUpdateContext","createContext","scheduleUpdate","Error","flushUpdates","useScheduleUpdate","callback","useContext","useEffect"],"mappings":"AAAA,OAAO,KAAKA,KAAZ,MAAuB,OAAvB;AAEA,MAAMC,qBAAqB,GAAG,mCAA9B;AAEA,OAAO,MAAMC,qBAAqB,gBAAGF,KAAK,CAACG,aAAN,CAGlC;AACDC,EAAAA,cAAc,GAAG;AACf,UAAM,IAAIC,KAAJ,CAAUJ,qBAAV,CAAN;AACD,GAHA;;AAIDK,EAAAA,YAAY,GAAG;AACb,UAAM,IAAID,KAAJ,CAAUJ,qBAAV,CAAN;AACD;;AANA,CAHkC,CAA9B;AAYP;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,eAAe,SAASM,iBAAT,CAA2BC,QAA3B,EAAiD;AAC9D,QAAM;AAAEJ,IAAAA,cAAF;AAAkBE,IAAAA;AAAlB,MAAmCN,KAAK,CAACS,UAAN,CACvCP,qBADuC,CAAzC;AAIAE,EAAAA,cAAc,CAACI,QAAD,CAAd;AAEAR,EAAAA,KAAK,CAACU,SAAN,CAAgBJ,YAAhB;AACD","sourcesContent":["import * as React from 'react';\n\nconst MISSING_CONTEXT_ERROR = \"Couldn't find a schedule context.\";\n\nexport const ScheduleUpdateContext = React.createContext<{\n  scheduleUpdate: (callback: () => void) => void;\n  flushUpdates: () => void;\n}>({\n  scheduleUpdate() {\n    throw new Error(MISSING_CONTEXT_ERROR);\n  },\n  flushUpdates() {\n    throw new Error(MISSING_CONTEXT_ERROR);\n  },\n});\n\n/**\n * When screen config changes, we want to update the navigator in the same update phase.\n * However, navigation state is in the root component and React won't let us update it from a child.\n * This is a workaround for that, the scheduled update is stored in the ref without actually calling setState.\n * It lets all subsequent updates access the latest state so it stays correct.\n * Then we call setState during after the component updates.\n */\nexport default function useScheduleUpdate(callback: () => void) {\n  const { scheduleUpdate, flushUpdates } = React.useContext(\n    ScheduleUpdateContext\n  );\n\n  scheduleUpdate(callback);\n\n  React.useEffect(flushUpdates);\n}\n"]}

package/lib/module/useSyncState.js

@@ -0,0 +1,64 @@
+import * as React from 'react';
+const UNINTIALIZED_STATE = {};
+/**
+ * This is definitely not compatible with concurrent mode, but we don't have a solution for sync state yet.
+ */
+
+export default function useSyncState(initialState) {
+  const stateRef = React.useRef(UNINTIALIZED_STATE);
+  const isSchedulingRef = React.useRef(false);
+  const isMountedRef = React.useRef(true);
+  React.useEffect(() => {
+    isMountedRef.current = true;
+    return () => {
+      isMountedRef.current = false;
+    };
+  }, []);
+
+  if (stateRef.current === UNINTIALIZED_STATE) {
+    stateRef.current = // @ts-expect-error: initialState is a function, but TypeScript doesn't think so
+    typeof initialState === 'function' ? initialState() : initialState;
+  }
+
+  const [trackingState, setTrackingState] = React.useState(stateRef.current);
+  const getState = React.useCallback(() => stateRef.current, []);
+  const setState = React.useCallback(state => {
+    if (state === stateRef.current || !isMountedRef.current) {
+      return;
+    }
+
+    stateRef.current = state;
+
+    if (!isSchedulingRef.current) {
+      setTrackingState(state);
+    }
+  }, []);
+  const scheduleUpdate = React.useCallback(callback => {
+    isSchedulingRef.current = true;
+
+    try {
+      callback();
+    } finally {
+      isSchedulingRef.current = false;
+    }
+  }, []);
+  const flushUpdates = React.useCallback(() => {
+    if (!isMountedRef.current) {
+      return;
+    } // Make sure that the tracking state is up-to-date.
+    // We call it unconditionally, but React should skip the update if state is unchanged.
+
+
+    setTrackingState(stateRef.current);
+  }, []); // If we're rendering and the tracking state is out of date, update it immediately
+  // This will make sure that our updates are applied as early as possible.
+
+  if (trackingState !== stateRef.current) {
+    setTrackingState(stateRef.current);
+  }
+
+  const state = stateRef.current;
+  React.useDebugValue(state);
+  return [state, getState, setState, scheduleUpdate, flushUpdates];
+}
+//# sourceMappingURL=useSyncState.js.map

package/lib/module/useSyncState.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useSyncState.tsx"],"names":["React","UNINTIALIZED_STATE","useSyncState","initialState","stateRef","useRef","isSchedulingRef","isMountedRef","useEffect","current","trackingState","setTrackingState","useState","getState","useCallback","setState","state","scheduleUpdate","callback","flushUpdates","useDebugValue"],"mappings":"AAAA,OAAO,KAAKA,KAAZ,MAAuB,OAAvB;AAEA,MAAMC,kBAAkB,GAAG,EAA3B;AAEA;AACA;AACA;;AACA,eAAe,SAASC,YAAT,CAAyBC,YAAzB,EAAuD;AACpE,QAAMC,QAAQ,GAAGJ,KAAK,CAACK,MAAN,CAAgBJ,kBAAhB,CAAjB;AACA,QAAMK,eAAe,GAAGN,KAAK,CAACK,MAAN,CAAa,KAAb,CAAxB;AACA,QAAME,YAAY,GAAGP,KAAK,CAACK,MAAN,CAAa,IAAb,CAArB;AAEAL,EAAAA,KAAK,CAACQ,SAAN,CAAgB,MAAM;AACpBD,IAAAA,YAAY,CAACE,OAAb,GAAuB,IAAvB;AAEA,WAAO,MAAM;AACXF,MAAAA,YAAY,CAACE,OAAb,GAAuB,KAAvB;AACD,KAFD;AAGD,GAND,EAMG,EANH;;AAQA,MAAIL,QAAQ,CAACK,OAAT,KAAqBR,kBAAzB,EAA6C;AAC3CG,IAAAA,QAAQ,CAACK,OAAT,GACE;AACA,WAAON,YAAP,KAAwB,UAAxB,GAAqCA,YAAY,EAAjD,GAAsDA,YAFxD;AAGD;;AAED,QAAM,CAACO,aAAD,EAAgBC,gBAAhB,IAAoCX,KAAK,CAACY,QAAN,CAAeR,QAAQ,CAACK,OAAxB,CAA1C;AAEA,QAAMI,QAAQ,GAAGb,KAAK,CAACc,WAAN,CAAkB,MAAMV,QAAQ,CAACK,OAAjC,EAA0C,EAA1C,CAAjB;AAEA,QAAMM,QAAQ,GAAGf,KAAK,CAACc,WAAN,CAAmBE,KAAD,IAAc;AAC/C,QAAIA,KAAK,KAAKZ,QAAQ,CAACK,OAAnB,IAA8B,CAACF,YAAY,CAACE,OAAhD,EAAyD;AACvD;AACD;;AAEDL,IAAAA,QAAQ,CAACK,OAAT,GAAmBO,KAAnB;;AAEA,QAAI,CAACV,eAAe,CAACG,OAArB,EAA8B;AAC5BE,MAAAA,gBAAgB,CAACK,KAAD,CAAhB;AACD;AACF,GAVgB,EAUd,EAVc,CAAjB;AAYA,QAAMC,cAAc,GAAGjB,KAAK,CAACc,WAAN,CAAmBI,QAAD,IAA0B;AACjEZ,IAAAA,eAAe,CAACG,OAAhB,GAA0B,IAA1B;;AAEA,QAAI;AACFS,MAAAA,QAAQ;AACT,KAFD,SAEU;AACRZ,MAAAA,eAAe,CAACG,OAAhB,GAA0B,KAA1B;AACD;AACF,GARsB,EAQpB,EARoB,CAAvB;AAUA,QAAMU,YAAY,GAAGnB,KAAK,CAACc,WAAN,CAAkB,MAAM;AAC3C,QAAI,CAACP,YAAY,CAACE,OAAlB,EAA2B;AACzB;AACD,KAH0C,CAK3C;AACA;;;AACAE,IAAAA,gBAAgB,CAACP,QAAQ,CAACK,OAAV,CAAhB;AACD,GARoB,EAQlB,EARkB,CAArB,CA7CoE,CAuDpE;AACA;;AACA,MAAIC,aAAa,KAAKN,QAAQ,CAACK,OAA/B,EAAwC;AACtCE,IAAAA,gBAAgB,CAACP,QAAQ,CAACK,OAAV,CAAhB;AACD;;AAED,QAAMO,KAAK,GAAGZ,QAAQ,CAACK,OAAvB;AAEAT,EAAAA,KAAK,CAACoB,aAAN,CAAoBJ,KAApB;AAEA,SAAO,CAACA,KAAD,EAAQH,QAAR,EAAkBE,QAAlB,EAA4BE,cAA5B,EAA4CE,YAA5C,CAAP;AACD","sourcesContent":["import * as React from 'react';\n\nconst UNINTIALIZED_STATE = {};\n\n/**\n * This is definitely not compatible with concurrent mode, but we don't have a solution for sync state yet.\n */\nexport default function useSyncState<T>(initialState?: (() => T) | T) {\n  const stateRef = React.useRef<T>(UNINTIALIZED_STATE as any);\n  const isSchedulingRef = React.useRef(false);\n  const isMountedRef = React.useRef(true);\n\n  React.useEffect(() => {\n    isMountedRef.current = true;\n\n    return () => {\n      isMountedRef.current = false;\n    };\n  }, []);\n\n  if (stateRef.current === UNINTIALIZED_STATE) {\n    stateRef.current =\n      // @ts-expect-error: initialState is a function, but TypeScript doesn't think so\n      typeof initialState === 'function' ? initialState() : initialState;\n  }\n\n  const [trackingState, setTrackingState] = React.useState(stateRef.current);\n\n  const getState = React.useCallback(() => stateRef.current, []);\n\n  const setState = React.useCallback((state: T) => {\n    if (state === stateRef.current || !isMountedRef.current) {\n      return;\n    }\n\n    stateRef.current = state;\n\n    if (!isSchedulingRef.current) {\n      setTrackingState(state);\n    }\n  }, []);\n\n  const scheduleUpdate = React.useCallback((callback: () => void) => {\n    isSchedulingRef.current = true;\n\n    try {\n      callback();\n    } finally {\n      isSchedulingRef.current = false;\n    }\n  }, []);\n\n  const flushUpdates = React.useCallback(() => {\n    if (!isMountedRef.current) {\n      return;\n    }\n\n    // Make sure that the tracking state is up-to-date.\n    // We call it unconditionally, but React should skip the update if state is unchanged.\n    setTrackingState(stateRef.current);\n  }, []);\n\n  // If we're rendering and the tracking state is out of date, update it immediately\n  // This will make sure that our updates are applied as early as possible.\n  if (trackingState !== stateRef.current) {\n    setTrackingState(stateRef.current);\n  }\n\n  const state = stateRef.current;\n\n  React.useDebugValue(state);\n\n  return [state, getState, setState, scheduleUpdate, flushUpdates] as const;\n}\n"]}

package/lib/module/validatePathConfig.js

@@ -0,0 +1,24 @@
+const formatToList = items => items.map(key => `- ${key}`).join('\n');
+
+export default function validatePathConfig(config, root = true) {
+  const validKeys = ['initialRouteName', 'screens'];
+
+  if (!root) {
+    validKeys.push('path', 'exact', 'stringify', 'parse');
+  }
+
+  const invalidKeys = Object.keys(config).filter(key => !validKeys.includes(key));
+
+  if (invalidKeys.length) {
+    throw new Error(`Found invalid properties in the configuration:\n${formatToList(invalidKeys)}\n\nDid you forget to specify them under a 'screens' property?\n\nYou can only specify the following properties:\n${formatToList(validKeys)}\n\nSee https://reactnavigation.org/docs/configuring-links for more details on how to specify a linking configuration.`);
+  }
+
+  if (config.screens) {
+    Object.entries(config.screens).forEach(([_, value]) => {
+      if (typeof value !== 'string') {
+        validatePathConfig(value, false);
+      }
+    });
+  }
+}
+//# sourceMappingURL=validatePathConfig.js.map

package/lib/module/validatePathConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["validatePathConfig.tsx"],"names":["formatToList","items","map","key","join","validatePathConfig","config","root","validKeys","push","invalidKeys","Object","keys","filter","includes","length","Error","screens","entries","forEach","_","value"],"mappings":"AAAA,MAAMA,YAAY,GAAIC,KAAD,IACnBA,KAAK,CAACC,GAAN,CAAWC,GAAD,IAAU,KAAIA,GAAI,EAA5B,EAA+BC,IAA/B,CAAoC,IAApC,CADF;;AAGA,eAAe,SAASC,kBAAT,CAA4BC,MAA5B,EAAyCC,IAAI,GAAG,IAAhD,EAAsD;AACnE,QAAMC,SAAS,GAAG,CAAC,kBAAD,EAAqB,SAArB,CAAlB;;AAEA,MAAI,CAACD,IAAL,EAAW;AACTC,IAAAA,SAAS,CAACC,IAAV,CAAe,MAAf,EAAuB,OAAvB,EAAgC,WAAhC,EAA6C,OAA7C;AACD;;AAED,QAAMC,WAAW,GAAGC,MAAM,CAACC,IAAP,CAAYN,MAAZ,EAAoBO,MAApB,CACjBV,GAAD,IAAS,CAACK,SAAS,CAACM,QAAV,CAAmBX,GAAnB,CADQ,CAApB;;AAIA,MAAIO,WAAW,CAACK,MAAhB,EAAwB;AACtB,UAAM,IAAIC,KAAJ,CACH,mDAAkDhB,YAAY,CAC7DU,WAD6D,CAE7D,qHAAoHV,YAAY,CAChIQ,SADgI,CAEhI,wHALE,CAAN;AAOD;;AAED,MAAIF,MAAM,CAACW,OAAX,EAAoB;AAClBN,IAAAA,MAAM,CAACO,OAAP,CAAeZ,MAAM,CAACW,OAAtB,EAA+BE,OAA/B,CAAuC,CAAC,CAACC,CAAD,EAAIC,KAAJ,CAAD,KAAgB;AACrD,UAAI,OAAOA,KAAP,KAAiB,QAArB,EAA+B;AAC7BhB,QAAAA,kBAAkB,CAACgB,KAAD,EAAQ,KAAR,CAAlB;AACD;AACF,KAJD;AAKD;AACF","sourcesContent":["const formatToList = (items: string[]) =>\n  items.map((key) => `- ${key}`).join('\\n');\n\nexport default function validatePathConfig(config: any, root = true) {\n  const validKeys = ['initialRouteName', 'screens'];\n\n  if (!root) {\n    validKeys.push('path', 'exact', 'stringify', 'parse');\n  }\n\n  const invalidKeys = Object.keys(config).filter(\n    (key) => !validKeys.includes(key)\n  );\n\n  if (invalidKeys.length) {\n    throw new Error(\n      `Found invalid properties in the configuration:\\n${formatToList(\n        invalidKeys\n      )}\\n\\nDid you forget to specify them under a 'screens' property?\\n\\nYou can only specify the following properties:\\n${formatToList(\n        validKeys\n      )}\\n\\nSee https://reactnavigation.org/docs/configuring-links for more details on how to specify a linking configuration.`\n    );\n  }\n\n  if (config.screens) {\n    Object.entries(config.screens).forEach(([_, value]) => {\n      if (typeof value !== 'string') {\n        validatePathConfig(value, false);\n      }\n    });\n  }\n}\n"]}

package/lib/typescript/src/BaseNavigationContainer.d.ts

@@ -0,0 +1,14 @@
+import { ParamListBase } from '@react-navigation/routers';
+import * as React from 'react';
+import type { NavigationContainerProps, NavigationContainerRef } from './types';
+/**
+ * Container component which holds the navigation state.
+ * This should be rendered at the root wrapping the whole app.
+ *
+ * @param props.initialState Initial state object for the navigation tree.
+ * @param props.onStateChange Callback which is called with the latest navigation state when it changes.
+ * @param props.children Child elements to render the content.
+ * @param props.ref Ref object which refers to the navigation object containing helper methods.
+ */
+declare const BaseNavigationContainer: React.ForwardRefExoticComponent<NavigationContainerProps & React.RefAttributes<NavigationContainerRef<ParamListBase>>>;
+export default BaseNavigationContainer;

package/lib/typescript/src/CurrentRenderContext.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+/**
+ * Context which holds the values for the current navigation tree.
+ * Intended for use in SSR. This is not safe to use on the client.
+ */
+declare const CurrentRenderContext: React.Context<{
+    options?: object | undefined;
+} | undefined>;
+export default CurrentRenderContext;

package/lib/typescript/src/EnsureSingleNavigator.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+declare type Props = {
+    children: React.ReactNode;
+};
+export declare const SingleNavigatorContext: React.Context<{
+    register(key: string): void;
+    unregister(key: string): void;
+} | undefined>;
+/**
+ * Component which ensures that there's only one navigator nested under it.
+ */
+export default function EnsureSingleNavigator({ children }: Props): JSX.Element;
+export {};

package/lib/typescript/src/Group.d.ts

@@ -0,0 +1,6 @@
+import type { ParamListBase } from '@react-navigation/routers';
+import type { RouteGroupConfig } from './types';
+/**
+ * Empty component used for grouping screen configs.
+ */
+export default function Group<ParamList extends ParamListBase, ScreenOptions extends {}>(_: RouteGroupConfig<ParamList, ScreenOptions>): null;

package/lib/typescript/src/NavigationBuilderContext.d.ts

@@ -0,0 +1,34 @@
+import type { NavigationAction, NavigationState, ParamListBase } from '@react-navigation/routers';
+import * as React from 'react';
+import type { NavigationHelpers } from './types';
+export declare type ListenerMap = {
+    action: ChildActionListener;
+    focus: FocusedNavigationListener;
+};
+export declare type KeyedListenerMap = {
+    getState: GetStateListener;
+    beforeRemove: ChildBeforeRemoveListener;
+};
+export declare type AddListener = <T extends keyof ListenerMap>(type: T, listener: ListenerMap[T]) => void;
+export declare type AddKeyedListener = <T extends keyof KeyedListenerMap>(type: T, key: string, listener: KeyedListenerMap[T]) => void;
+export declare type ChildActionListener = (action: NavigationAction, visitedNavigators?: Set<string>) => boolean;
+export declare type FocusedNavigationCallback<T> = (navigation: NavigationHelpers<ParamListBase>) => T;
+export declare type FocusedNavigationListener = <T>(callback: FocusedNavigationCallback<T>) => {
+    handled: boolean;
+    result: T;
+};
+export declare type GetStateListener = () => NavigationState;
+export declare type ChildBeforeRemoveListener = (action: NavigationAction) => boolean;
+/**
+ * Context which holds the required helpers needed to build nested navigators.
+ */
+declare const NavigationBuilderContext: React.Context<{
+    onAction?: ((action: NavigationAction, visitedNavigators?: Set<string> | undefined) => boolean) | undefined;
+    addListener?: AddListener | undefined;
+    addKeyedListener?: AddKeyedListener | undefined;
+    onRouteFocus?: ((key: string) => void) | undefined;
+    onDispatchAction: (action: NavigationAction, noop: boolean) => void;
+    onOptionsChange: (options: object) => void;
+    stackRef?: React.MutableRefObject<string | undefined> | undefined;
+}>;
+export default NavigationBuilderContext;

package/lib/typescript/src/NavigationContainerRefContext.d.ts

@@ -0,0 +1,8 @@
+import type { ParamListBase } from '@react-navigation/routers';
+import * as React from 'react';
+import type { NavigationContainerRef } from './types';
+/**
+ * Context which holds the route prop for a screen.
+ */
+declare const NavigationContainerRefContext: React.Context<NavigationContainerRef<ParamListBase> | undefined>;
+export default NavigationContainerRefContext;

package/lib/typescript/src/NavigationContext.d.ts

@@ -0,0 +1,24 @@
+import type { ParamListBase } from '@react-navigation/routers';
+import * as React from 'react';
+import type { NavigationProp } from './types';
+/**
+ * Context which holds the navigation prop for a screen.
+ */
+declare const NavigationContext: React.Context<NavigationProp<ParamListBase, string, Readonly<{
+    key: string;
+    index: number;
+    routeNames: string[];
+    history?: unknown[] | undefined;
+    routes: (Readonly<{
+        key: string;
+        name: string;
+        path?: string | undefined;
+    }> & Readonly<{
+        params?: Readonly<object | undefined>;
+    }> & {
+        state?: Readonly<any> | import("@react-navigation/routers").PartialState<Readonly<any>> | undefined;
+    })[];
+    type: string;
+    stale: false;
+}>, {}, {}> | undefined>;
+export default NavigationContext;

package/lib/typescript/src/NavigationHelpersContext.d.ts

@@ -0,0 +1,9 @@
+import type { ParamListBase } from '@react-navigation/routers';
+import * as React from 'react';
+import type { NavigationHelpers } from './types';
+/**
+ * Context which holds the navigation helpers of the parent navigator.
+ * Navigators should use this context in their view component.
+ */
+declare const NavigationHelpersContext: React.Context<NavigationHelpers<ParamListBase, {}> | undefined>;
+export default NavigationHelpersContext;

package/lib/typescript/src/NavigationRouteContext.d.ts

@@ -0,0 +1,7 @@
+import type { Route } from '@react-navigation/routers';
+import * as React from 'react';
+/**
+ * Context which holds the route prop for a screen.
+ */
+declare const NavigationRouteContext: React.Context<Route<string, object | undefined> | undefined>;
+export default NavigationRouteContext;

package/lib/typescript/src/NavigationStateContext.d.ts

@@ -0,0 +1,45 @@
+import type { NavigationState, PartialState } from '@react-navigation/routers';
+import * as React from 'react';
+declare const _default: React.Context<{
+    isDefault?: true | undefined;
+    state?: Readonly<{
+        key: string;
+        index: number;
+        routeNames: string[];
+        history?: unknown[] | undefined;
+        routes: (Readonly<{
+            key: string;
+            name: string;
+            path?: string | undefined;
+        }> & Readonly<{
+            params?: Readonly<object | undefined>;
+        }> & {
+            state?: Readonly<any> | PartialState<Readonly<any>> | undefined;
+        })[];
+        type: string;
+        stale: false;
+    }> | PartialState<Readonly<{
+        key: string;
+        index: number;
+        routeNames: string[];
+        history?: unknown[] | undefined;
+        routes: (Readonly<{
+            key: string;
+            name: string;
+            path?: string | undefined;
+        }> & Readonly<{
+            params?: Readonly<object | undefined>;
+        }> & {
+            state?: Readonly<any> | PartialState<Readonly<any>> | undefined;
+        })[];
+        type: string;
+        stale: false;
+    }>> | undefined;
+    getKey: () => string | undefined;
+    setKey: (key: string) => void;
+    getState: () => NavigationState | PartialState<NavigationState> | undefined;
+    setState: (state: NavigationState | PartialState<NavigationState> | undefined) => void;
+    getIsInitial: () => boolean;
+    addOptionsGetter?: ((key: string, getter: () => object | undefined | null) => void) | undefined;
+}>;
+export default _default;

package/lib/typescript/src/SceneView.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="react" />
+import type { NavigationState, ParamListBase, PartialState, Route } from '@react-navigation/routers';
+import type { NavigationProp, RouteConfigComponent } from './types';
+declare type Props<State extends NavigationState, ScreenOptions extends {}> = {
+    screen: RouteConfigComponent<ParamListBase, string> & {
+        name: string;
+    };
+    navigation: NavigationProp<ParamListBase, string, State, ScreenOptions>;
+    route: Route<string>;
+    routeState: NavigationState | PartialState<NavigationState> | undefined;
+    getState: () => State;
+    setState: (state: State) => void;
+    options: object;
+    clearOptions: () => void;
+};
+/**
+ * Component which takes care of rendering the screen for a route.
+ * It provides all required contexts and applies optimizations when applicable.
+ */
+export default function SceneView<State extends NavigationState, ScreenOptions extends {}>({ screen, route, navigation, routeState, getState, setState, options, clearOptions, }: Props<State, ScreenOptions>): JSX.Element;
+export {};

package/lib/typescript/src/Screen.d.ts

@@ -0,0 +1,6 @@
+import type { NavigationState, ParamListBase } from '@react-navigation/routers';
+import type { EventMapBase, RouteConfig } from './types';
+/**
+ * Empty component used for specifying route configuration.
+ */
+export default function Screen<ParamList extends ParamListBase, RouteName extends keyof ParamList, State extends NavigationState, ScreenOptions extends {}, EventMap extends EventMapBase>(_: RouteConfig<ParamList, RouteName, State, ScreenOptions, EventMap>): null;

package/lib/typescript/src/StaticContainer.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+/**
+ * Component which prevents updates for children if no props changed
+ */
+declare function StaticContainer(props: any): any;
+declare const _default: React.MemoExoticComponent<typeof StaticContainer>;
+export default _default;

package/lib/typescript/src/UnhandledActionContext.d.ts

@@ -0,0 +1,4 @@
+import type { NavigationAction } from '@react-navigation/routers';
+import * as React from 'react';
+declare const UnhandledActionContext: React.Context<((action: NavigationAction) => void) | undefined>;
+export default UnhandledActionContext;

package/lib/typescript/src/checkDuplicateRouteNames.d.ts

@@ -0,0 +1,2 @@
+import type { NavigationState } from '@react-navigation/routers';
+export default function checkDuplicateRouteNames(state: NavigationState): string[][];

package/lib/typescript/src/checkSerializable.d.ts

@@ -0,0 +1,9 @@
+export default function checkSerializable(o: {
+    [key: string]: any;
+}): {
+    serializable: true;
+} | {
+    serializable: false;
+    location: (string | number)[];
+    reason: string;
+};

package/lib/typescript/src/createNavigationContainerRef.d.ts

@@ -0,0 +1,3 @@
+import type { NavigationContainerRefWithCurrent } from './types';
+export declare const NOT_INITIALIZED_ERROR = "The 'navigation' object hasn't been initialized yet. This might happen if you don't have a navigator mounted, or if the navigator hasn't finished mounting. See https://reactnavigation.org/docs/navigating-without-navigation-prop#handling-initialization for more details.";
+export default function createNavigationContainerRef<ParamList extends {} = ReactNavigation.RootParamList>(): NavigationContainerRefWithCurrent<ParamList>;

package/lib/typescript/src/createNavigatorFactory.d.ts

@@ -0,0 +1,11 @@
+import type { NavigationState, ParamListBase } from '@react-navigation/routers';
+import type * as React from 'react';
+import type { EventMapBase, TypedNavigator } from './types';
+/**
+ * Higher order component to create a `Navigator` and `Screen` pair.
+ * Custom navigators should wrap the navigator component in `createNavigator` before exporting.
+ *
+ * @param Navigator The navigtor component to wrap.
+ * @returns Factory method to create a `Navigator` and `Screen` pair.
+ */
+export default function createNavigatorFactory<State extends NavigationState, ScreenOptions extends {}, EventMap extends EventMapBase, NavigatorComponent extends React.ComponentType<any>>(Navigator: NavigatorComponent): <ParamList extends ParamListBase>() => TypedNavigator<ParamList, State, ScreenOptions, EventMap, NavigatorComponent>;

package/lib/typescript/src/findFocusedRoute.d.ts

@@ -0,0 +1,22 @@
+import type { InitialState } from '@react-navigation/routers';
+export default function findFocusedRoute(state: InitialState): (Omit<import("@react-navigation/routers").Route<string, object | undefined>, "key"> & {
+    state?: Readonly<Partial<Omit<Readonly<{
+        key: string;
+        index: number;
+        routeNames: string[];
+        history?: unknown[] | undefined;
+        routes: (Readonly<{
+            key: string;
+            name: string;
+            path?: string | undefined;
+        }> & Readonly<{
+            params?: Readonly<object | undefined>;
+        }> & {
+            state?: Readonly<any> | import("@react-navigation/routers").PartialState<Readonly<any>> | undefined;
+        })[];
+        type: string;
+        stale: false;
+    }>, "stale" | "routes">> & {
+        routes: (Omit<import("@react-navigation/routers").Route<string, object | undefined>, "key"> & any)[];
+    }> | undefined;
+}) | undefined;

package/lib/typescript/src/fromEntries.d.ts

@@ -0,0 +1 @@
+export default function fromEntries<K extends string, V>(entries: (readonly [K, V])[]): Record<K, V>;

package/lib/typescript/src/getActionFromState.d.ts

@@ -0,0 +1,16 @@
+import type { CommonActions, NavigationState, PartialState } from '@react-navigation/routers';
+import type { NavigatorScreenParams, PathConfigMap } from './types';
+declare type Options = {
+    initialRouteName?: string;
+    screens: PathConfigMap<object>;
+};
+declare type NavigateAction<State extends NavigationState> = {
+    type: 'NAVIGATE';
+    payload: {
+        name: string;
+        params?: NavigatorScreenParams<State>;
+        path?: string;
+    };
+};
+export default function getActionFromState(state: PartialState<NavigationState>, options?: Options): NavigateAction<NavigationState> | CommonActions.Action | undefined;
+export {};

package/lib/typescript/src/getFocusedRouteNameFromRoute.d.ts

@@ -0,0 +1,2 @@
+import type { Route } from '@react-navigation/routers';
+export default function getFocusedRouteNameFromRoute(route: Partial<Route<string>>): string | undefined;

package/lib/typescript/src/getPathFromState.d.ts

@@ -0,0 +1,38 @@
+import type { NavigationState, PartialState } from '@react-navigation/routers';
+import type { PathConfigMap } from './types';
+declare type Options<ParamList> = {
+    initialRouteName?: string;
+    screens: PathConfigMap<ParamList>;
+};
+declare type State = NavigationState | Omit<PartialState<NavigationState>, 'stale'>;
+/**
+ * Utility to serialize a navigation state object to a path string.
+ *
+ * @example
+ * ```js
+ * getPathFromState(
+ *   {
+ *     routes: [
+ *       {
+ *         name: 'Chat',
+ *         params: { author: 'Jane', id: 42 },
+ *       },
+ *     ],
+ *   },
+ *   {
+ *     screens: {
+ *       Chat: {
+ *         path: 'chat/:author/:id',
+ *         stringify: { author: author => author.toLowerCase() }
+ *       }
+ *     }
+ *   }
+ * )
+ * ```
+ *
+ * @param state Navigation state to serialize.
+ * @param options Extra options to fine-tune how to serialize the path.
+ * @returns Path representing the state, e.g. /foo/bar?count=42.
+ */
+export default function getPathFromState<ParamList extends {}>(state: State, options?: Options<ParamList>): string;
+export {};

package/lib/typescript/src/getStateFromPath.d.ts

@@ -0,0 +1,32 @@
+import type { NavigationState, PartialState } from '@react-navigation/routers';
+import type { PathConfigMap } from './types';
+declare type Options<ParamList extends {}> = {
+    initialRouteName?: string;
+    screens: PathConfigMap<ParamList>;
+};
+declare type ResultState = PartialState<NavigationState> & {
+    state?: ResultState;
+};
+/**
+ * Utility to parse a path string to initial state object accepted by the container.
+ * This is useful for deep linking when we need to handle the incoming URL.
+ *
+ * @example
+ * ```js
+ * getStateFromPath(
+ *   '/chat/jane/42',
+ *   {
+ *     screens: {
+ *       Chat: {
+ *         path: 'chat/:author/:id',
+ *         parse: { id: Number }
+ *       }
+ *     }
+ *   }
+ * )
+ * ```
+ * @param path Path string to parse and convert, e.g. /foo/bar?count=42.
+ * @param options Extra options to fine-tune how to parse the path.
+ */
+export default function getStateFromPath<ParamList extends {}>(path: string, options?: Options<ParamList>): ResultState | undefined;
+export {};

package/lib/typescript/src/index.d.ts

@@ -0,0 +1,23 @@
+export { default as BaseNavigationContainer } from './BaseNavigationContainer';
+export { default as createNavigationContainerRef } from './createNavigationContainerRef';
+export { default as createNavigatorFactory } from './createNavigatorFactory';
+export { default as CurrentRenderContext } from './CurrentRenderContext';
+export { default as findFocusedRoute } from './findFocusedRoute';
+export { default as getActionFromState } from './getActionFromState';
+export { default as getFocusedRouteNameFromRoute } from './getFocusedRouteNameFromRoute';
+export { default as getPathFromState } from './getPathFromState';
+export { default as getStateFromPath } from './getStateFromPath';
+export { default as NavigationContainerRefContext } from './NavigationContainerRefContext';
+export { default as NavigationContext } from './NavigationContext';
+export { default as NavigationHelpersContext } from './NavigationHelpersContext';
+export { default as NavigationRouteContext } from './NavigationRouteContext';
+export * from './types';
+export { default as useFocusEffect } from './useFocusEffect';
+export { default as useIsFocused } from './useIsFocused';
+export { default as useNavigation } from './useNavigation';
+export { default as useNavigationBuilder } from './useNavigationBuilder';
+export { default as useNavigationContainerRef } from './useNavigationContainerRef';
+export { default as useNavigationState } from './useNavigationState';
+export { default as useRoute } from './useRoute';
+export { default as validatePathConfig } from './validatePathConfig';
+export * from '@react-navigation/routers';

package/lib/typescript/src/isArrayEqual.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Compare two arrays with primitive values as the content.
+ * We need to make sure that both values and order match.
+ */
+export default function isArrayEqual(a: any[], b: any[]): boolean;