@react-navigation/core 6.0.2

package/lib/module/getPathFromState.js

@@ -0,0 +1,223 @@
+import * as queryString from 'query-string';
+import fromEntries from './fromEntries';
+import validatePathConfig from './validatePathConfig';
+
+const getActiveRoute = state => {
+  const route = typeof state.index === 'number' ? state.routes[state.index] : state.routes[state.routes.length - 1];
+
+  if (route.state) {
+    return getActiveRoute(route.state);
+  }
+
+  return route;
+};
+/**
+ * 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(state, options) {
+  if (state == null) {
+    throw Error("Got 'undefined' for the navigation state. You must pass a valid state object.");
+  }
+
+  if (options) {
+    validatePathConfig(options);
+  } // Create a normalized configs object which will be easier to use
+
+
+  const configs = options !== null && options !== void 0 && options.screens ? createNormalizedConfigs(options === null || options === void 0 ? void 0 : options.screens) : {};
+  let path = '/';
+  let current = state;
+  const allParams = {};
+
+  while (current) {
+    let index = typeof current.index === 'number' ? current.index : 0;
+    let route = current.routes[index];
+    let pattern;
+    let focusedParams;
+    let focusedRoute = getActiveRoute(state);
+    let currentOptions = configs; // Keep all the route names that appeared during going deeper in config in case the pattern is resolved to undefined
+
+    let nestedRouteNames = [];
+    let hasNext = true;
+
+    while (route.name in currentOptions && hasNext) {
+      pattern = currentOptions[route.name].pattern;
+      nestedRouteNames.push(route.name);
+
+      if (route.params) {
+        var _currentOptions$route;
+
+        const stringify = (_currentOptions$route = currentOptions[route.name]) === null || _currentOptions$route === void 0 ? void 0 : _currentOptions$route.stringify;
+        const currentParams = fromEntries(Object.entries(route.params).map(([key, value]) => [key, stringify !== null && stringify !== void 0 && stringify[key] ? stringify[key](value) : String(value)]));
+
+        if (pattern) {
+          Object.assign(allParams, currentParams);
+        }
+
+        if (focusedRoute === route) {
+          var _pattern;
+
+          // If this is the focused route, keep the params for later use
+          // We save it here since it's been stringified already
+          focusedParams = { ...currentParams
+          };
+          (_pattern = pattern) === null || _pattern === void 0 ? void 0 : _pattern.split('/').filter(p => p.startsWith(':')) // eslint-disable-next-line no-loop-func
+          .forEach(p => {
+            const name = getParamName(p); // Remove the params present in the pattern since we'll only use the rest for query string
+
+            if (focusedParams) {
+              // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+              delete focusedParams[name];
+            }
+          });
+        }
+      } // If there is no `screens` property or no nested state, we return pattern
+
+
+      if (!currentOptions[route.name].screens || route.state === undefined) {
+        hasNext = false;
+      } else {
+        index = typeof route.state.index === 'number' ? route.state.index : route.state.routes.length - 1;
+        const nextRoute = route.state.routes[index];
+        const nestedConfig = currentOptions[route.name].screens; // if there is config for next route name, we go deeper
+
+        if (nestedConfig && nextRoute.name in nestedConfig) {
+          route = nextRoute;
+          currentOptions = nestedConfig;
+        } else {
+          // If not, there is no sense in going deeper in config
+          hasNext = false;
+        }
+      }
+    }
+
+    if (pattern === undefined) {
+      pattern = nestedRouteNames.join('/');
+    }
+
+    if (currentOptions[route.name] !== undefined) {
+      path += pattern.split('/').map(p => {
+        const name = getParamName(p); // We don't know what to show for wildcard patterns
+        // Showing the route name seems ok, though whatever we show here will be incorrect
+        // Since the page doesn't actually exist
+
+        if (p === '*') {
+          return route.name;
+        } // If the path has a pattern for a param, put the param in the path
+
+
+        if (p.startsWith(':')) {
+          const value = allParams[name];
+
+          if (value === undefined && p.endsWith('?')) {
+            // Optional params without value assigned in route.params should be ignored
+            return '';
+          }
+
+          return encodeURIComponent(value);
+        }
+
+        return encodeURIComponent(p);
+      }).join('/');
+    } else {
+      path += encodeURIComponent(route.name);
+    }
+
+    if (!focusedParams) {
+      focusedParams = focusedRoute.params;
+    }
+
+    if (route.state) {
+      path += '/';
+    } else if (focusedParams) {
+      for (let param in focusedParams) {
+        if (focusedParams[param] === 'undefined') {
+          // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+          delete focusedParams[param];
+        }
+      }
+
+      const query = queryString.stringify(focusedParams, {
+        sort: false
+      });
+
+      if (query) {
+        path += `?${query}`;
+      }
+    }
+
+    current = route.state;
+  } // Remove multiple as well as trailing slashes
+
+
+  path = path.replace(/\/+/g, '/');
+  path = path.length > 1 ? path.replace(/\/$/, '') : path;
+  return path;
+}
+
+const getParamName = pattern => pattern.replace(/^:/, '').replace(/\?$/, '');
+
+const joinPaths = (...paths) => [].concat(...paths.map(p => p.split('/'))).filter(Boolean).join('/');
+
+const createConfigItem = (config, parentPattern) => {
+  var _pattern2;
+
+  if (typeof config === 'string') {
+    // If a string is specified as the value of the key(e.g. Foo: '/path'), use it as the pattern
+    const pattern = parentPattern ? joinPaths(parentPattern, config) : config;
+    return {
+      pattern
+    };
+  } // If an object is specified as the value (e.g. Foo: { ... }),
+  // It can have `path` property and `screens` prop which has nested configs
+
+
+  let pattern;
+
+  if (config.exact && config.path === undefined) {
+    throw new Error("A 'path' needs to be specified when specifying 'exact: true'. If you don't want this screen in the URL, specify it as empty string, e.g. `path: ''`.");
+  }
+
+  pattern = config.exact !== true ? joinPaths(parentPattern || '', config.path || '') : config.path || '';
+  const screens = config.screens ? createNormalizedConfigs(config.screens, pattern) : undefined;
+  return {
+    // Normalize pattern to remove any leading, trailing slashes, duplicate slashes etc.
+    pattern: (_pattern2 = pattern) === null || _pattern2 === void 0 ? void 0 : _pattern2.split('/').filter(Boolean).join('/'),
+    stringify: config.stringify,
+    screens
+  };
+};
+
+const createNormalizedConfigs = (options, pattern) => fromEntries(Object.entries(options).map(([name, c]) => {
+  const result = createConfigItem(c, pattern);
+  return [name, result];
+}));
+//# sourceMappingURL=getPathFromState.js.map

package/lib/module/getPathFromState.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["getPathFromState.tsx"],"names":["queryString","fromEntries","validatePathConfig","getActiveRoute","state","route","index","routes","length","getPathFromState","options","Error","configs","screens","createNormalizedConfigs","path","current","allParams","pattern","focusedParams","focusedRoute","currentOptions","nestedRouteNames","hasNext","name","push","params","stringify","currentParams","Object","entries","map","key","value","String","assign","split","filter","p","startsWith","forEach","getParamName","undefined","nextRoute","nestedConfig","join","endsWith","encodeURIComponent","param","query","sort","replace","joinPaths","paths","concat","Boolean","createConfigItem","config","parentPattern","exact","c","result"],"mappings":"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","sourcesContent":["import type {\n  NavigationState,\n  PartialState,\n  Route,\n} from '@react-navigation/routers';\nimport * as queryString from 'query-string';\n\nimport fromEntries from './fromEntries';\nimport type { PathConfig, PathConfigMap } from './types';\nimport validatePathConfig from './validatePathConfig';\n\ntype Options<ParamList> = {\n  initialRouteName?: string;\n  screens: PathConfigMap<ParamList>;\n};\n\ntype State = NavigationState | Omit<PartialState<NavigationState>, 'stale'>;\n\ntype StringifyConfig = Record<string, (value: any) => string>;\n\ntype ConfigItem = {\n  pattern?: string;\n  stringify?: StringifyConfig;\n  screens?: Record<string, ConfigItem>;\n};\n\nconst getActiveRoute = (state: State): { name: string; params?: object } => {\n  const route =\n    typeof state.index === 'number'\n      ? state.routes[state.index]\n      : state.routes[state.routes.length - 1];\n\n  if (route.state) {\n    return getActiveRoute(route.state);\n  }\n\n  return route;\n};\n\n/**\n * Utility to serialize a navigation state object to a path string.\n *\n * @example\n * ```js\n * getPathFromState(\n *   {\n *     routes: [\n *       {\n *         name: 'Chat',\n *         params: { author: 'Jane', id: 42 },\n *       },\n *     ],\n *   },\n *   {\n *     screens: {\n *       Chat: {\n *         path: 'chat/:author/:id',\n *         stringify: { author: author => author.toLowerCase() }\n *       }\n *     }\n *   }\n * )\n * ```\n *\n * @param state Navigation state to serialize.\n * @param options Extra options to fine-tune how to serialize the path.\n * @returns Path representing the state, e.g. /foo/bar?count=42.\n */\nexport default function getPathFromState<ParamList extends {}>(\n  state: State,\n  options?: Options<ParamList>\n): string {\n  if (state == null) {\n    throw Error(\n      \"Got 'undefined' for the navigation state. You must pass a valid state object.\"\n    );\n  }\n\n  if (options) {\n    validatePathConfig(options);\n  }\n\n  // Create a normalized configs object which will be easier to use\n  const configs: Record<string, ConfigItem> = options?.screens\n    ? createNormalizedConfigs(options?.screens)\n    : {};\n\n  let path = '/';\n  let current: State | undefined = state;\n\n  const allParams: Record<string, any> = {};\n\n  while (current) {\n    let index = typeof current.index === 'number' ? current.index : 0;\n    let route = current.routes[index] as Route<string> & {\n      state?: State;\n    };\n\n    let pattern: string | undefined;\n\n    let focusedParams: Record<string, any> | undefined;\n    let focusedRoute = getActiveRoute(state);\n    let currentOptions = configs;\n\n    // Keep all the route names that appeared during going deeper in config in case the pattern is resolved to undefined\n    let nestedRouteNames = [];\n\n    let hasNext = true;\n\n    while (route.name in currentOptions && hasNext) {\n      pattern = currentOptions[route.name].pattern;\n\n      nestedRouteNames.push(route.name);\n\n      if (route.params) {\n        const stringify = currentOptions[route.name]?.stringify;\n\n        const currentParams = fromEntries(\n          Object.entries(route.params).map(([key, value]) => [\n            key,\n            stringify?.[key] ? stringify[key](value) : String(value),\n          ])\n        );\n\n        if (pattern) {\n          Object.assign(allParams, currentParams);\n        }\n\n        if (focusedRoute === route) {\n          // If this is the focused route, keep the params for later use\n          // We save it here since it's been stringified already\n          focusedParams = { ...currentParams };\n\n          pattern\n            ?.split('/')\n            .filter((p) => p.startsWith(':'))\n            // eslint-disable-next-line no-loop-func\n            .forEach((p) => {\n              const name = getParamName(p);\n\n              // Remove the params present in the pattern since we'll only use the rest for query string\n              if (focusedParams) {\n                // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n                delete focusedParams[name];\n              }\n            });\n        }\n      }\n\n      // If there is no `screens` property or no nested state, we return pattern\n      if (!currentOptions[route.name].screens || route.state === undefined) {\n        hasNext = false;\n      } else {\n        index =\n          typeof route.state.index === 'number'\n            ? route.state.index\n            : route.state.routes.length - 1;\n\n        const nextRoute = route.state.routes[index];\n        const nestedConfig = currentOptions[route.name].screens;\n\n        // if there is config for next route name, we go deeper\n        if (nestedConfig && nextRoute.name in nestedConfig) {\n          route = nextRoute as Route<string> & { state?: State };\n          currentOptions = nestedConfig;\n        } else {\n          // If not, there is no sense in going deeper in config\n          hasNext = false;\n        }\n      }\n    }\n\n    if (pattern === undefined) {\n      pattern = nestedRouteNames.join('/');\n    }\n\n    if (currentOptions[route.name] !== undefined) {\n      path += pattern\n        .split('/')\n        .map((p) => {\n          const name = getParamName(p);\n\n          // We don't know what to show for wildcard patterns\n          // Showing the route name seems ok, though whatever we show here will be incorrect\n          // Since the page doesn't actually exist\n          if (p === '*') {\n            return route.name;\n          }\n\n          // If the path has a pattern for a param, put the param in the path\n          if (p.startsWith(':')) {\n            const value = allParams[name];\n\n            if (value === undefined && p.endsWith('?')) {\n              // Optional params without value assigned in route.params should be ignored\n              return '';\n            }\n\n            return encodeURIComponent(value);\n          }\n\n          return encodeURIComponent(p);\n        })\n        .join('/');\n    } else {\n      path += encodeURIComponent(route.name);\n    }\n\n    if (!focusedParams) {\n      focusedParams = focusedRoute.params;\n    }\n\n    if (route.state) {\n      path += '/';\n    } else if (focusedParams) {\n      for (let param in focusedParams) {\n        if (focusedParams[param] === 'undefined') {\n          // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n          delete focusedParams[param];\n        }\n      }\n\n      const query = queryString.stringify(focusedParams, { sort: false });\n\n      if (query) {\n        path += `?${query}`;\n      }\n    }\n\n    current = route.state;\n  }\n\n  // Remove multiple as well as trailing slashes\n  path = path.replace(/\\/+/g, '/');\n  path = path.length > 1 ? path.replace(/\\/$/, '') : path;\n\n  return path;\n}\n\nconst getParamName = (pattern: string) =>\n  pattern.replace(/^:/, '').replace(/\\?$/, '');\n\nconst joinPaths = (...paths: string[]): string =>\n  ([] as string[])\n    .concat(...paths.map((p) => p.split('/')))\n    .filter(Boolean)\n    .join('/');\n\nconst createConfigItem = (\n  config: PathConfig<object> | string,\n  parentPattern?: string\n): ConfigItem => {\n  if (typeof config === 'string') {\n    // If a string is specified as the value of the key(e.g. Foo: '/path'), use it as the pattern\n    const pattern = parentPattern ? joinPaths(parentPattern, config) : config;\n\n    return { pattern };\n  }\n\n  // If an object is specified as the value (e.g. Foo: { ... }),\n  // It can have `path` property and `screens` prop which has nested configs\n  let pattern: string | undefined;\n\n  if (config.exact && config.path === undefined) {\n    throw new Error(\n      \"A 'path' needs to be specified when specifying 'exact: true'. If you don't want this screen in the URL, specify it as empty string, e.g. `path: ''`.\"\n    );\n  }\n\n  pattern =\n    config.exact !== true\n      ? joinPaths(parentPattern || '', config.path || '')\n      : config.path || '';\n\n  const screens = config.screens\n    ? createNormalizedConfigs(config.screens, pattern)\n    : undefined;\n\n  return {\n    // Normalize pattern to remove any leading, trailing slashes, duplicate slashes etc.\n    pattern: pattern?.split('/').filter(Boolean).join('/'),\n    stringify: config.stringify,\n    screens,\n  };\n};\n\nconst createNormalizedConfigs = (\n  options: PathConfigMap<object>,\n  pattern?: string\n): Record<string, ConfigItem> =>\n  fromEntries(\n    Object.entries(options).map(([name, c]) => {\n      const result = createConfigItem(c, pattern);\n\n      return [name, result];\n    })\n  );\n"]}

package/lib/module/getStateFromPath.js

@@ -0,0 +1,434 @@
+import escape from 'escape-string-regexp';
+import * as queryString from 'query-string';
+import findFocusedRoute from './findFocusedRoute';
+import validatePathConfig from './validatePathConfig';
+
+/**
+ * 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(path, options) {
+  if (options) {
+    validatePathConfig(options);
+  }
+
+  let initialRoutes = [];
+
+  if (options !== null && options !== void 0 && options.initialRouteName) {
+    initialRoutes.push({
+      initialRouteName: options.initialRouteName,
+      parentScreens: []
+    });
+  }
+
+  const screens = options === null || options === void 0 ? void 0 : options.screens;
+  let remaining = path.replace(/\/+/g, '/') // Replace multiple slash (//) with single ones
+  .replace(/^\//, '') // Remove extra leading slash
+  .replace(/\?.*$/, ''); // Remove query params which we will handle later
+  // Make sure there is a trailing slash
+
+  remaining = remaining.endsWith('/') ? remaining : `${remaining}/`;
+
+  if (screens === undefined) {
+    // When no config is specified, use the path segments as route names
+    const routes = remaining.split('/').filter(Boolean).map(segment => {
+      const name = decodeURIComponent(segment);
+      return {
+        name
+      };
+    });
+
+    if (routes.length) {
+      return createNestedStateObject(path, routes, initialRoutes);
+    }
+
+    return undefined;
+  } // Create a normalized configs array which will be easier to use
+
+
+  const configs = [].concat(...Object.keys(screens).map(key => createNormalizedConfigs(key, screens, [], initialRoutes, []))).sort((a, b) => {
+    // Sort config so that:
+    // - the most exhaustive ones are always at the beginning
+    // - patterns with wildcard are always at the end
+    // If 2 patterns are same, move the one with less route names up
+    // This is an error state, so it's only useful for consistent error messages
+    if (a.pattern === b.pattern) {
+      return b.routeNames.join('>').localeCompare(a.routeNames.join('>'));
+    } // If one of the patterns starts with the other, it's more exhaustive
+    // So move it up
+
+
+    if (a.pattern.startsWith(b.pattern)) {
+      return -1;
+    }
+
+    if (b.pattern.startsWith(a.pattern)) {
+      return 1;
+    }
+
+    const aParts = a.pattern.split('/');
+    const bParts = b.pattern.split('/');
+
+    for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
+      // if b is longer, b get higher priority
+      if (aParts[i] == null) {
+        return 1;
+      } // if a is longer, a get higher priority
+
+
+      if (bParts[i] == null) {
+        return -1;
+      }
+
+      const aWildCard = aParts[i] === '*' || aParts[i].startsWith(':');
+      const bWildCard = bParts[i] === '*' || bParts[i].startsWith(':'); // if both are wildcard we compare next component
+
+      if (aWildCard && bWildCard) {
+        continue;
+      } // if only a is wild card, b get higher priority
+
+
+      if (aWildCard) {
+        return 1;
+      } // if only b is wild card, a get higher priority
+
+
+      if (bWildCard) {
+        return -1;
+      }
+    }
+
+    return bParts.length - aParts.length;
+  }); // Check for duplicate patterns in the config
+
+  configs.reduce((acc, config) => {
+    if (acc[config.pattern]) {
+      const a = acc[config.pattern].routeNames;
+      const b = config.routeNames; // It's not a problem if the path string omitted from a inner most screen
+      // For example, it's ok if a path resolves to `A > B > C` or `A > B`
+
+      const intersects = a.length > b.length ? b.every((it, i) => a[i] === it) : a.every((it, i) => b[i] === it);
+
+      if (!intersects) {
+        throw new Error(`Found conflicting screens with the same pattern. The pattern '${config.pattern}' resolves to both '${a.join(' > ')}' and '${b.join(' > ')}'. Patterns must be unique and cannot resolve to more than one screen.`);
+      }
+    }
+
+    return Object.assign(acc, {
+      [config.pattern]: config
+    });
+  }, {});
+
+  if (remaining === '/') {
+    // We need to add special handling of empty path so navigation to empty path also works
+    // When handling empty path, we should only look at the root level config
+    const match = configs.find(config => config.path === '' && config.routeNames.every( // Make sure that none of the parent configs have a non-empty path defined
+    name => {
+      var _configs$find;
+
+      return !((_configs$find = configs.find(c => c.screen === name)) !== null && _configs$find !== void 0 && _configs$find.path);
+    }));
+
+    if (match) {
+      return createNestedStateObject(path, match.routeNames.map(name => ({
+        name
+      })), initialRoutes, configs);
+    }
+
+    return undefined;
+  }
+
+  let result;
+  let current; // We match the whole path against the regex instead of segments
+  // This makes sure matches such as wildcard will catch any unmatched routes, even if nested
+
+  const {
+    routes,
+    remainingPath
+  } = matchAgainstConfigs(remaining, configs.map(c => ({ ...c,
+    // Add `$` to the regex to make sure it matches till end of the path and not just beginning
+    regex: c.regex ? new RegExp(c.regex.source + '$') : undefined
+  })));
+
+  if (routes !== undefined) {
+    // This will always be empty if full path matched
+    current = createNestedStateObject(path, routes, initialRoutes, configs);
+    remaining = remainingPath;
+    result = current;
+  }
+
+  if (current == null || result == null) {
+    return undefined;
+  }
+
+  return result;
+}
+
+const joinPaths = (...paths) => [].concat(...paths.map(p => p.split('/'))).filter(Boolean).join('/');
+
+const matchAgainstConfigs = (remaining, configs) => {
+  let routes;
+  let remainingPath = remaining; // Go through all configs, and see if the next path segment matches our regex
+
+  for (const config of configs) {
+    if (!config.regex) {
+      continue;
+    }
+
+    const match = remainingPath.match(config.regex); // If our regex matches, we need to extract params from the path
+
+    if (match) {
+      var _config$pattern;
+
+      const matchedParams = (_config$pattern = config.pattern) === null || _config$pattern === void 0 ? void 0 : _config$pattern.split('/').filter(p => p.startsWith(':')).reduce((acc, p, i) => Object.assign(acc, {
+        // The param segments appear every second item starting from 2 in the regex match result
+        [p]: match[(i + 1) * 2].replace(/\//, '')
+      }), {});
+      routes = config.routeNames.map(name => {
+        var _config$path;
+
+        const config = configs.find(c => c.screen === name);
+        const params = config === null || config === void 0 ? void 0 : (_config$path = config.path) === null || _config$path === void 0 ? void 0 : _config$path.split('/').filter(p => p.startsWith(':')).reduce((acc, p) => {
+          const value = matchedParams[p];
+
+          if (value) {
+            var _config$parse;
+
+            const key = p.replace(/^:/, '').replace(/\?$/, '');
+            acc[key] = (_config$parse = config.parse) !== null && _config$parse !== void 0 && _config$parse[key] ? config.parse[key](value) : value;
+          }
+
+          return acc;
+        }, {});
+
+        if (params && Object.keys(params).length) {
+          return {
+            name,
+            params
+          };
+        }
+
+        return {
+          name
+        };
+      });
+      remainingPath = remainingPath.replace(match[1], '');
+      break;
+    }
+  }
+
+  return {
+    routes,
+    remainingPath
+  };
+};
+
+const createNormalizedConfigs = (screen, routeConfig, routeNames = [], initials, parentScreens, parentPattern) => {
+  const configs = [];
+  routeNames.push(screen);
+  parentScreens.push(screen); // @ts-expect-error: we can't strongly typecheck this for now
+
+  const config = routeConfig[screen];
+
+  if (typeof config === 'string') {
+    // If a string is specified as the value of the key(e.g. Foo: '/path'), use it as the pattern
+    const pattern = parentPattern ? joinPaths(parentPattern, config) : config;
+    configs.push(createConfigItem(screen, routeNames, pattern, config));
+  } else if (typeof config === 'object') {
+    let pattern; // if an object is specified as the value (e.g. Foo: { ... }),
+    // it can have `path` property and
+    // it could have `screens` prop which has nested configs
+
+    if (typeof config.path === 'string') {
+      if (config.exact && config.path === undefined) {
+        throw new Error("A 'path' needs to be specified when specifying 'exact: true'. If you don't want this screen in the URL, specify it as empty string, e.g. `path: ''`.");
+      }
+
+      pattern = config.exact !== true ? joinPaths(parentPattern || '', config.path || '') : config.path || '';
+      configs.push(createConfigItem(screen, routeNames, pattern, config.path, config.parse));
+    }
+
+    if (config.screens) {
+      // property `initialRouteName` without `screens` has no purpose
+      if (config.initialRouteName) {
+        initials.push({
+          initialRouteName: config.initialRouteName,
+          parentScreens
+        });
+      }
+
+      Object.keys(config.screens).forEach(nestedConfig => {
+        var _pattern;
+
+        const result = createNormalizedConfigs(nestedConfig, config.screens, routeNames, initials, [...parentScreens], (_pattern = pattern) !== null && _pattern !== void 0 ? _pattern : parentPattern);
+        configs.push(...result);
+      });
+    }
+  }
+
+  routeNames.pop();
+  return configs;
+};
+
+const createConfigItem = (screen, routeNames, pattern, path, parse) => {
+  // Normalize pattern to remove any leading, trailing slashes, duplicate slashes etc.
+  pattern = pattern.split('/').filter(Boolean).join('/');
+  const regex = pattern ? new RegExp(`^(${pattern.split('/').map(it => {
+    if (it.startsWith(':')) {
+      return `(([^/]+\\/)${it.endsWith('?') ? '?' : ''})`;
+    }
+
+    return `${it === '*' ? '.*' : escape(it)}\\/`;
+  }).join('')})`) : undefined;
+  return {
+    screen,
+    regex,
+    pattern,
+    path,
+    // The routeNames array is mutated, so copy it to keep the current state
+    routeNames: [...routeNames],
+    parse
+  };
+};
+
+const findParseConfigForRoute = (routeName, flatConfig) => {
+  for (const config of flatConfig) {
+    if (routeName === config.routeNames[config.routeNames.length - 1]) {
+      return config.parse;
+    }
+  }
+
+  return undefined;
+}; // Try to find an initial route connected with the one passed
+
+
+const findInitialRoute = (routeName, parentScreens, initialRoutes) => {
+  for (const config of initialRoutes) {
+    if (parentScreens.length === config.parentScreens.length) {
+      let sameParents = true;
+
+      for (let i = 0; i < parentScreens.length; i++) {
+        if (parentScreens[i].localeCompare(config.parentScreens[i]) !== 0) {
+          sameParents = false;
+          break;
+        }
+      }
+
+      if (sameParents) {
+        return routeName !== config.initialRouteName ? config.initialRouteName : undefined;
+      }
+    }
+  }
+
+  return undefined;
+}; // returns state object with values depending on whether
+// it is the end of state and if there is initialRoute for this level
+
+
+const createStateObject = (initialRoute, route, isEmpty) => {
+  if (isEmpty) {
+    if (initialRoute) {
+      return {
+        index: 1,
+        routes: [{
+          name: initialRoute
+        }, route]
+      };
+    } else {
+      return {
+        routes: [route]
+      };
+    }
+  } else {
+    if (initialRoute) {
+      return {
+        index: 1,
+        routes: [{
+          name: initialRoute
+        }, { ...route,
+          state: {
+            routes: []
+          }
+        }]
+      };
+    } else {
+      return {
+        routes: [{ ...route,
+          state: {
+            routes: []
+          }
+        }]
+      };
+    }
+  }
+};
+
+const createNestedStateObject = (path, routes, initialRoutes, flatConfig) => {
+  let state;
+  let route = routes.shift();
+  const parentScreens = [];
+  let initialRoute = findInitialRoute(route.name, parentScreens, initialRoutes);
+  parentScreens.push(route.name);
+  state = createStateObject(initialRoute, route, routes.length === 0);
+
+  if (routes.length > 0) {
+    let nestedState = state;
+
+    while (route = routes.shift()) {
+      initialRoute = findInitialRoute(route.name, parentScreens, initialRoutes);
+      const nestedStateIndex = nestedState.index || nestedState.routes.length - 1;
+      nestedState.routes[nestedStateIndex].state = createStateObject(initialRoute, route, routes.length === 0);
+
+      if (routes.length > 0) {
+        nestedState = nestedState.routes[nestedStateIndex].state;
+      }
+
+      parentScreens.push(route.name);
+    }
+  }
+
+  route = findFocusedRoute(state);
+  route.path = path;
+  const params = parseQueryParams(path, flatConfig ? findParseConfigForRoute(route.name, flatConfig) : undefined);
+
+  if (params) {
+    route.params = { ...route.params,
+      ...params
+    };
+  }
+
+  return state;
+};
+
+const parseQueryParams = (path, parseConfig) => {
+  const query = path.split('?')[1];
+  const params = queryString.parse(query);
+
+  if (parseConfig) {
+    Object.keys(params).forEach(name => {
+      if (parseConfig[name] && typeof params[name] === 'string') {
+        params[name] = parseConfig[name](params[name]);
+      }
+    });
+  }
+
+  return Object.keys(params).length ? params : undefined;
+};
+//# sourceMappingURL=getStateFromPath.js.map