@react-navigation/core 6.0.2

package/lib/commonjs/useOnRouteFocus.js

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

package/lib/commonjs/useOnRouteFocus.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useOnRouteFocus.tsx"],"names":["useOnRouteFocus","router","getState","key","sourceRouteKey","setState","onRouteFocus","onRouteFocusParent","React","useContext","NavigationBuilderContext","useCallback","state","result","getStateForRouteFocus","undefined"],"mappings":";;;;;;;AAKA;;AAEA;;;;;;;;AASA;AACA;AACA;AACA;AACA;AACe,SAASA,eAAT,CAA0D;AACvEC,EAAAA,MADuE;AAEvEC,EAAAA,QAFuE;AAGvEC,EAAAA,GAAG,EAAEC,cAHkE;AAIvEC,EAAAA;AAJuE,CAA1D,EAKK;AAClB,QAAM;AAAEC,IAAAA,YAAY,EAAEC;AAAhB,MAAuCC,KAAK,CAACC,UAAN,CAC3CC,iCAD2C,CAA7C;AAIA,SAAOF,KAAK,CAACG,WAAN,CACJR,GAAD,IAAiB;AACf,UAAMS,KAAK,GAAGV,QAAQ,EAAtB;AACA,UAAMW,MAAM,GAAGZ,MAAM,CAACa,qBAAP,CAA6BF,KAA7B,EAAoCT,GAApC,CAAf;;AAEA,QAAIU,MAAM,KAAKD,KAAf,EAAsB;AACpBP,MAAAA,QAAQ,CAACQ,MAAD,CAAR;AACD;;AAED,QAAIN,kBAAkB,KAAKQ,SAAvB,IAAoCX,cAAc,KAAKW,SAA3D,EAAsE;AACpER,MAAAA,kBAAkB,CAACH,cAAD,CAAlB;AACD;AACF,GAZI,EAaL,CAACF,QAAD,EAAWK,kBAAX,EAA+BN,MAA/B,EAAuCI,QAAvC,EAAiDD,cAAjD,CAbK,CAAP;AAeD","sourcesContent":["import type {\n  NavigationAction,\n  NavigationState,\n  Router,\n} from '@react-navigation/routers';\nimport * as React from 'react';\n\nimport NavigationBuilderContext from './NavigationBuilderContext';\n\ntype Options<Action extends NavigationAction> = {\n  router: Router<NavigationState, Action>;\n  getState: () => NavigationState;\n  setState: (state: NavigationState) => void;\n  key?: string;\n};\n\n/**\n * Hook to handle focus actions for a route.\n * Focus action needs to be treated specially, coz when a nested route is focused,\n * the parent navigators also needs to be focused.\n */\nexport default function useOnRouteFocus<Action extends NavigationAction>({\n  router,\n  getState,\n  key: sourceRouteKey,\n  setState,\n}: Options<Action>) {\n  const { onRouteFocus: onRouteFocusParent } = React.useContext(\n    NavigationBuilderContext\n  );\n\n  return React.useCallback(\n    (key: string) => {\n      const state = getState();\n      const result = router.getStateForRouteFocus(state, key);\n\n      if (result !== state) {\n        setState(result);\n      }\n\n      if (onRouteFocusParent !== undefined && sourceRouteKey !== undefined) {\n        onRouteFocusParent(sourceRouteKey);\n      }\n    },\n    [getState, onRouteFocusParent, router, setState, sourceRouteKey]\n  );\n}\n"]}

package/lib/commonjs/useOptionsGetters.js

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

package/lib/commonjs/useOptionsGetters.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useOptionsGetters.tsx"],"names":["useOptionsGetters","key","options","navigation","optionsRef","React","useRef","optionsGettersFromChildRef","onOptionsChange","useContext","NavigationBuilderContext","addOptionsGetter","parentAddOptionsGetter","NavigationStateContext","optionsChangeListener","useCallback","isFocused","hasChildren","Object","keys","current","length","useEffect","addListener","getOptionsFromListener","hasOwnProperty","result","getCurrentOptions","optionsFromListener","getter"],"mappings":"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","sourcesContent":["import type { ParamListBase } from '@react-navigation/routers';\nimport * as React from 'react';\n\nimport NavigationBuilderContext from './NavigationBuilderContext';\nimport NavigationStateContext from './NavigationStateContext';\nimport type { NavigationProp } from './types';\n\ntype Options = {\n  key?: string;\n  navigation?: NavigationProp<ParamListBase>;\n  options?: object | undefined;\n};\n\nexport default function useOptionsGetters({\n  key,\n  options,\n  navigation,\n}: Options) {\n  const optionsRef = React.useRef<object | undefined>(options);\n  const optionsGettersFromChildRef = React.useRef<\n    Record<string, () => object | undefined | null>\n  >({});\n\n  const { onOptionsChange } = React.useContext(NavigationBuilderContext);\n  const { addOptionsGetter: parentAddOptionsGetter } = React.useContext(\n    NavigationStateContext\n  );\n\n  const optionsChangeListener = React.useCallback(() => {\n    const isFocused = navigation?.isFocused() ?? true;\n    const hasChildren = Object.keys(optionsGettersFromChildRef.current).length;\n\n    if (isFocused && !hasChildren) {\n      onOptionsChange(optionsRef.current ?? {});\n    }\n  }, [navigation, onOptionsChange]);\n\n  React.useEffect(() => {\n    optionsRef.current = options;\n    optionsChangeListener();\n\n    return navigation?.addListener('focus', optionsChangeListener);\n  }, [navigation, options, optionsChangeListener]);\n\n  const getOptionsFromListener = React.useCallback(() => {\n    for (let key in optionsGettersFromChildRef.current) {\n      if (optionsGettersFromChildRef.current.hasOwnProperty(key)) {\n        const result = optionsGettersFromChildRef.current[key]?.();\n\n        // null means unfocused route\n        if (result !== null) {\n          return result;\n        }\n      }\n    }\n\n    return null;\n  }, []);\n\n  const getCurrentOptions = React.useCallback(() => {\n    const isFocused = navigation?.isFocused() ?? true;\n\n    if (!isFocused) {\n      return null;\n    }\n\n    const optionsFromListener = getOptionsFromListener();\n\n    if (optionsFromListener !== null) {\n      return optionsFromListener;\n    }\n\n    return optionsRef.current;\n  }, [navigation, getOptionsFromListener]);\n\n  React.useEffect(() => {\n    return parentAddOptionsGetter?.(key!, getCurrentOptions);\n  }, [getCurrentOptions, parentAddOptionsGetter, key]);\n\n  const addOptionsGetter = React.useCallback(\n    (key: string, getter: () => object | undefined | null) => {\n      optionsGettersFromChildRef.current[key] = getter;\n      optionsChangeListener();\n\n      return () => {\n        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n        delete optionsGettersFromChildRef.current[key];\n        optionsChangeListener();\n      };\n    },\n    [optionsChangeListener]\n  );\n\n  return {\n    addOptionsGetter,\n    getCurrentOptions,\n  };\n}\n"]}

package/lib/commonjs/useRegisterNavigator.js

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

package/lib/commonjs/useRegisterNavigator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useRegisterNavigator.tsx"],"names":["useRegisterNavigator","key","React","useState","container","useContext","SingleNavigatorContext","undefined","Error","useEffect","register","unregister"],"mappings":";;;;;;;AAAA;;AACA;;AAEA;;;;;;AAEA;AACA;AACA;AACA;AACe,SAASA,oBAAT,GAAgC;AAC7C,QAAM,CAACC,GAAD,IAAQC,KAAK,CAACC,QAAN,CAAe,MAAM,wBAArB,CAAd;AACA,QAAMC,SAAS,GAAGF,KAAK,CAACG,UAAN,CAAiBC,6CAAjB,CAAlB;;AAEA,MAAIF,SAAS,KAAKG,SAAlB,EAA6B;AAC3B,UAAM,IAAIC,KAAJ,CACJ,wLADI,CAAN;AAGD;;AAEDN,EAAAA,KAAK,CAACO,SAAN,CAAgB,MAAM;AACpB,UAAM;AAAEC,MAAAA,QAAF;AAAYC,MAAAA;AAAZ,QAA2BP,SAAjC;AAEAM,IAAAA,QAAQ,CAACT,GAAD,CAAR;AAEA,WAAO,MAAMU,UAAU,CAACV,GAAD,CAAvB;AACD,GAND,EAMG,CAACG,SAAD,EAAYH,GAAZ,CANH;AAQA,SAAOA,GAAP;AACD","sourcesContent":["import { nanoid } from 'nanoid/non-secure';\nimport * as React from 'react';\n\nimport { SingleNavigatorContext } from './EnsureSingleNavigator';\n\n/**\n * Register a navigator in the parent context (either a navigation container or a screen).\n * This is used to prevent multiple navigators under a single container or screen.\n */\nexport default function useRegisterNavigator() {\n  const [key] = React.useState(() => nanoid());\n  const container = React.useContext(SingleNavigatorContext);\n\n  if (container === undefined) {\n    throw new Error(\n      \"Couldn't register the navigator. Have you wrapped your app with 'NavigationContainer'?\\n\\nThis can also happen if there are multiple copies of '@react-navigation' packages installed.\"\n    );\n  }\n\n  React.useEffect(() => {\n    const { register, unregister } = container;\n\n    register(key);\n\n    return () => unregister(key);\n  }, [container, key]);\n\n  return key;\n}\n"]}

package/lib/commonjs/useRoute.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useRoute;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _NavigationRouteContext = _interopRequireDefault(require("./NavigationRouteContext"));
+
+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 access the route prop of the parent screen anywhere.
+ *
+ * @returns Route prop of the parent screen.
+ */
+function useRoute() {
+  const route = React.useContext(_NavigationRouteContext.default);
+
+  if (route === undefined) {
+    throw new Error("Couldn't find a route object. Is your component inside a screen in a navigator?");
+  }
+
+  return route;
+}
+//# sourceMappingURL=useRoute.js.map

package/lib/commonjs/useRoute.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useRoute.tsx"],"names":["useRoute","route","React","useContext","NavigationRouteContext","undefined","Error"],"mappings":";;;;;;;AACA;;AAEA;;;;;;;;AAGA;AACA;AACA;AACA;AACA;AACe,SAASA,QAAT,GAA2D;AACxE,QAAMC,KAAK,GAAGC,KAAK,CAACC,UAAN,CAAiBC,+BAAjB,CAAd;;AAEA,MAAIH,KAAK,KAAKI,SAAd,EAAyB;AACvB,UAAM,IAAIC,KAAJ,CACJ,iFADI,CAAN;AAGD;;AAED,SAAOL,KAAP;AACD","sourcesContent":["import type { ParamListBase } from '@react-navigation/routers';\nimport * as React from 'react';\n\nimport NavigationRouteContext from './NavigationRouteContext';\nimport type { RouteProp } from './types';\n\n/**\n * Hook to access the route prop of the parent screen anywhere.\n *\n * @returns Route prop of the parent screen.\n */\nexport default function useRoute<T extends RouteProp<ParamListBase>>(): T {\n  const route = React.useContext(NavigationRouteContext);\n\n  if (route === undefined) {\n    throw new Error(\n      \"Couldn't find a route object. Is your component inside a screen in a navigator?\"\n    );\n  }\n\n  return route as T;\n}\n"]}

package/lib/commonjs/useRouteCache.js

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useRouteCache;
+exports.CHILD_STATE = void 0;
+
+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; }
+
+/**
+ * Utilites such as `getFocusedRouteNameFromRoute` need to access state.
+ * So we need a way to suppress the warning for those use cases.
+ * This is fine since they are internal utilities and this is not public API.
+ */
+const CHILD_STATE = Symbol('CHILD_STATE');
+/**
+ * Hook to cache route props for each screen in the navigator.
+ * This lets add warnings and modifications to the route object but keep references between renders.
+ */
+
+exports.CHILD_STATE = CHILD_STATE;
+
+function useRouteCache(routes) {
+  // Cache object which holds route objects for each screen
+  const cache = React.useMemo(() => ({
+    current: new Map()
+  }), []);
+
+  if (process.env.NODE_ENV === 'production') {
+    // We don't want the overhead of creating extra maps every render in prod
+    return routes;
+  }
+
+  cache.current = routes.reduce((acc, route) => {
+    const previous = cache.current.get(route);
+
+    if (previous) {
+      // If a cached route object already exists, reuse it
+      acc.set(route, previous);
+    } else {
+      const {
+        state,
+        ...proxy
+      } = route;
+      Object.defineProperty(proxy, CHILD_STATE, {
+        enumerable: false,
+        value: state
+      });
+      acc.set(route, proxy);
+    }
+
+    return acc;
+  }, new Map());
+  return Array.from(cache.current.values());
+}
+//# sourceMappingURL=useRouteCache.js.map

package/lib/commonjs/useRouteCache.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useRouteCache.tsx"],"names":["CHILD_STATE","Symbol","useRouteCache","routes","cache","React","useMemo","current","Map","process","env","NODE_ENV","reduce","acc","route","previous","get","set","state","proxy","Object","defineProperty","enumerable","value","Array","from","values"],"mappings":";;;;;;;;AAKA;;;;;;AAMA;AACA;AACA;AACA;AACA;AACO,MAAMA,WAAW,GAAGC,MAAM,CAAC,aAAD,CAA1B;AAEP;AACA;AACA;AACA;;;;AACe,SAASC,aAAT,CACbC,MADa,EAEb;AACA;AACA,QAAMC,KAAK,GAAGC,KAAK,CAACC,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,WAAOR,MAAP;AACD;;AAEDC,EAAAA,KAAK,CAACG,OAAN,GAAgBJ,MAAM,CAACS,MAAP,CAAc,CAACC,GAAD,EAAMC,KAAN,KAAgB;AAC5C,UAAMC,QAAQ,GAAGX,KAAK,CAACG,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,EAA6BnB,WAA7B,EAA0C;AACxCsB,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,CAAWrB,KAAK,CAACG,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/commonjs/useScheduleUpdate.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useScheduleUpdate;
+exports.ScheduleUpdateContext = void 0;
+
+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; }
+
+const MISSING_CONTEXT_ERROR = "Couldn't find a schedule context.";
+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.
+ */
+
+exports.ScheduleUpdateContext = ScheduleUpdateContext;
+
+function useScheduleUpdate(callback) {
+  const {
+    scheduleUpdate,
+    flushUpdates
+  } = React.useContext(ScheduleUpdateContext);
+  scheduleUpdate(callback);
+  React.useEffect(flushUpdates);
+}
+//# sourceMappingURL=useScheduleUpdate.js.map

package/lib/commonjs/useScheduleUpdate.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useScheduleUpdate.tsx"],"names":["MISSING_CONTEXT_ERROR","ScheduleUpdateContext","React","createContext","scheduleUpdate","Error","flushUpdates","useScheduleUpdate","callback","useContext","useEffect"],"mappings":";;;;;;;;AAAA;;;;;;AAEA,MAAMA,qBAAqB,GAAG,mCAA9B;AAEO,MAAMC,qBAAqB,gBAAGC,KAAK,CAACC,aAAN,CAGlC;AACDC,EAAAA,cAAc,GAAG;AACf,UAAM,IAAIC,KAAJ,CAAUL,qBAAV,CAAN;AACD,GAHA;;AAIDM,EAAAA,YAAY,GAAG;AACb,UAAM,IAAID,KAAJ,CAAUL,qBAAV,CAAN;AACD;;AANA,CAHkC,CAA9B;AAYP;AACA;AACA;AACA;AACA;AACA;AACA;;;;AACe,SAASO,iBAAT,CAA2BC,QAA3B,EAAiD;AAC9D,QAAM;AAAEJ,IAAAA,cAAF;AAAkBE,IAAAA;AAAlB,MAAmCJ,KAAK,CAACO,UAAN,CACvCR,qBADuC,CAAzC;AAIAG,EAAAA,cAAc,CAACI,QAAD,CAAd;AAEAN,EAAAA,KAAK,CAACQ,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/commonjs/useSyncState.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useSyncState;
+
+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; }
+
+const UNINTIALIZED_STATE = {};
+/**
+ * This is definitely not compatible with concurrent mode, but we don't have a solution for sync state yet.
+ */
+
+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/commonjs/useSyncState.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useSyncState.tsx"],"names":["UNINTIALIZED_STATE","useSyncState","initialState","stateRef","React","useRef","isSchedulingRef","isMountedRef","useEffect","current","trackingState","setTrackingState","useState","getState","useCallback","setState","state","scheduleUpdate","callback","flushUpdates","useDebugValue"],"mappings":";;;;;;;AAAA;;;;;;AAEA,MAAMA,kBAAkB,GAAG,EAA3B;AAEA;AACA;AACA;;AACe,SAASC,YAAT,CAAyBC,YAAzB,EAAuD;AACpE,QAAMC,QAAQ,GAAGC,KAAK,CAACC,MAAN,CAAgBL,kBAAhB,CAAjB;AACA,QAAMM,eAAe,GAAGF,KAAK,CAACC,MAAN,CAAa,KAAb,CAAxB;AACA,QAAME,YAAY,GAAGH,KAAK,CAACC,MAAN,CAAa,IAAb,CAArB;AAEAD,EAAAA,KAAK,CAACI,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,MAAIN,QAAQ,CAACM,OAAT,KAAqBT,kBAAzB,EAA6C;AAC3CG,IAAAA,QAAQ,CAACM,OAAT,GACE;AACA,WAAOP,YAAP,KAAwB,UAAxB,GAAqCA,YAAY,EAAjD,GAAsDA,YAFxD;AAGD;;AAED,QAAM,CAACQ,aAAD,EAAgBC,gBAAhB,IAAoCP,KAAK,CAACQ,QAAN,CAAeT,QAAQ,CAACM,OAAxB,CAA1C;AAEA,QAAMI,QAAQ,GAAGT,KAAK,CAACU,WAAN,CAAkB,MAAMX,QAAQ,CAACM,OAAjC,EAA0C,EAA1C,CAAjB;AAEA,QAAMM,QAAQ,GAAGX,KAAK,CAACU,WAAN,CAAmBE,KAAD,IAAc;AAC/C,QAAIA,KAAK,KAAKb,QAAQ,CAACM,OAAnB,IAA8B,CAACF,YAAY,CAACE,OAAhD,EAAyD;AACvD;AACD;;AAEDN,IAAAA,QAAQ,CAACM,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,GAAGb,KAAK,CAACU,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,GAAGf,KAAK,CAACU,WAAN,CAAkB,MAAM;AAC3C,QAAI,CAACP,YAAY,CAACE,OAAlB,EAA2B;AACzB;AACD,KAH0C,CAK3C;AACA;;;AACAE,IAAAA,gBAAgB,CAACR,QAAQ,CAACM,OAAV,CAAhB;AACD,GARoB,EAQlB,EARkB,CAArB,CA7CoE,CAuDpE;AACA;;AACA,MAAIC,aAAa,KAAKP,QAAQ,CAACM,OAA/B,EAAwC;AACtCE,IAAAA,gBAAgB,CAACR,QAAQ,CAACM,OAAV,CAAhB;AACD;;AAED,QAAMO,KAAK,GAAGb,QAAQ,CAACM,OAAvB;AAEAL,EAAAA,KAAK,CAACgB,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/commonjs/validatePathConfig.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = validatePathConfig;
+
+const formatToList = items => items.map(key => `- ${key}`).join('\n');
+
+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/commonjs/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;;AAGe,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"]}