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

package/lib/module/getPathFromState.js

@@ -0,0 +1,212 @@
+"use strict";
+
+import * as queryString from 'query-string';
+import { validatePathConfig } from "./validatePathConfig.js";
+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;
+};
+const cachedNormalizedConfigs = new WeakMap();
+const getNormalizedConfigs = options => {
+  if (!options?.screens) return {};
+  const cached = cachedNormalizedConfigs.get(options?.screens);
+  if (cached) return cached;
+  const normalizedConfigs = createNormalizedConfigs(options.screens);
+  cachedNormalizedConfigs.set(options.screens, normalizedConfigs);
+  return normalizedConfigs;
+};
+
+/**
+ * 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 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);
+  }
+  const configs = getNormalizedConfigs(options);
+  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;
+    const 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
+    const nestedRouteNames = [];
+    let hasNext = true;
+    while (route.name in currentOptions && hasNext) {
+      pattern = currentOptions[route.name].pattern;
+      nestedRouteNames.push(route.name);
+      if (route.params) {
+        const stringify = currentOptions[route.name]?.stringify;
+        const currentParams = Object.fromEntries(Object.entries(route.params).map(([key, value]) => [key, stringify?.[key] ? stringify[key](value) : String(value)]));
+        if (pattern) {
+          Object.assign(allParams, currentParams);
+        }
+        if (focusedRoute === route) {
+          // 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?.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 '';
+          }
+
+          // Valid characters according to
+          // https://datatracker.ietf.org/doc/html/rfc3986#section-3.3 (see pchar definition)
+          return String(value).replace(/[^A-Za-z0-9\-._~!$&'()*+,;=:@]/g, char => encodeURIComponent(char));
+        }
+        return encodeURIComponent(p);
+      }).join('/');
+    } else {
+      path += encodeURIComponent(route.name);
+    }
+    if (!focusedParams) {
+      focusedParams = focusedRoute.params;
+    }
+    if (route.state) {
+      path += '/';
+    } else if (focusedParams) {
+      for (const 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;
+
+  // Include the root path if specified
+  if (options?.path) {
+    path = joinPaths(options.path, 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) => {
+  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 (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: ''`.");
+  }
+
+  // If an object is specified as the value (e.g. Foo: { ... }),
+  // It can have `path` property and `screens` prop which has nested configs
+  const 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: pattern?.split('/').filter(Boolean).join('/'),
+    stringify: config.stringify,
+    screens
+  };
+};
+const createNormalizedConfigs = (options, pattern) => Object.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,"names":["queryString","validatePathConfig","getActiveRoute","state","route","index","routes","length","cachedNormalizedConfigs","WeakMap","getNormalizedConfigs","options","screens","cached","get","normalizedConfigs","createNormalizedConfigs","set","getPathFromState","Error","configs","path","current","allParams","pattern","focusedParams","focusedRoute","currentOptions","nestedRouteNames","hasNext","name","push","params","stringify","currentParams","Object","fromEntries","entries","map","key","value","String","assign","split","filter","p","startsWith","forEach","getParamName","undefined","nextRoute","nestedConfig","join","endsWith","replace","char","encodeURIComponent","param","query","sort","joinPaths","paths","concat","Boolean","createConfigItem","config","parentPattern","exact","c","result"],"sourceRoot":"../../src","sources":["getPathFromState.tsx"],"mappings":"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","ignoreList":[]}

package/lib/module/getStateFromPath.js

@@ -0,0 +1,468 @@
+"use strict";
+
+import escape from 'escape-string-regexp';
+import * as queryString from 'query-string';
+import { findFocusedRoute } from "./findFocusedRoute.js";
+import { validatePathConfig } from "./validatePathConfig.js";
+/**
+ * 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 function getStateFromPath(path, options) {
+  const {
+    initialRoutes,
+    configs,
+    configWithRegexes
+  } = getConfigResources(options);
+  const screens = 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}/`;
+  const prefix = options?.path?.replace(/^\//, ''); // Remove extra leading slash
+
+  if (prefix) {
+    // Make sure there is a trailing slash
+    const normalizedPrefix = prefix.endsWith('/') ? prefix : `${prefix}/`;
+
+    // If the path doesn't start with the prefix, it's not a match
+    if (!remaining.startsWith(normalizedPrefix)) {
+      return undefined;
+    }
+
+    // Remove the prefix from the path
+    remaining = remaining.replace(normalizedPrefix, '');
+  }
+  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;
+  }
+  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 => !configs.find(c => c.screen === name)?.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, configWithRegexes);
+  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;
+}
+
+/**
+ * Reference to the last used config resources. This is used to avoid recomputing the config resources when the options are the same.
+ */
+const cachedConfigResources = new WeakMap();
+function getConfigResources(options) {
+  if (!options) return prepareConfigResources();
+  const cached = cachedConfigResources.get(options);
+  if (cached) return cached;
+  const resources = prepareConfigResources(options);
+  cachedConfigResources.set(options, resources);
+  return resources;
+}
+function prepareConfigResources(options) {
+  if (options) {
+    validatePathConfig(options);
+  }
+  const initialRoutes = getInitialRoutes(options);
+  const configs = getNormalizedConfigs(initialRoutes, options?.screens);
+  checkForDuplicatedConfigs(configs);
+  const configWithRegexes = getConfigsWithRegexes(configs);
+  return {
+    initialRoutes,
+    configs,
+    configWithRegexes
+  };
+}
+function getInitialRoutes(options) {
+  const initialRoutes = [];
+  if (options?.initialRouteName) {
+    initialRoutes.push({
+      initialRouteName: options.initialRouteName,
+      parentScreens: []
+    });
+  }
+  return initialRoutes;
+}
+function getNormalizedConfigs(initialRoutes, screens = {}) {
+  // Create a normalized configs array which will be easier to use
+  return [].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;
+  });
+}
+function checkForDuplicatedConfigs(configs) {
+  // 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
+    });
+  }, {});
+}
+function getConfigsWithRegexes(configs) {
+  return 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
+  }));
+}
+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) {
+      const matchResult = config.pattern?.split('/').reduce((acc, p, index) => {
+        if (!p.startsWith(':')) {
+          return acc;
+        }
+
+        // Path parameter so increment position for the segment
+        acc.pos += 1;
+        const decodedParamSegment = decodeURIComponent(
+        // The param segments appear every second item starting from 2 in the regex match result
+        match[(acc.pos + 1) * 2]
+        // Remove trailing slash
+        .replace(/\/$/, ''));
+        Object.assign(acc.matchedParams, {
+          [p]: Object.assign(acc.matchedParams[p] || {}, {
+            [index]: decodedParamSegment
+          })
+        });
+        return acc;
+      }, {
+        pos: -1,
+        matchedParams: {}
+      });
+      const matchedParams = matchResult.matchedParams || {};
+      routes = config.routeNames.map(name => {
+        const routeConfig = configs.find(c => {
+          // Check matching name AND pattern in case same screen is used at different levels in config
+          return c.screen === name && config.pattern.startsWith(c.pattern);
+        });
+
+        // Normalize pattern to remove any leading, trailing slashes, duplicate slashes etc.
+        const normalizedPath = routeConfig?.path.split('/').filter(Boolean).join('/');
+
+        // Get the number of segments in the initial pattern
+        const numInitialSegments = routeConfig?.pattern
+        // Extract the prefix from the pattern by removing the ending path pattern (e.g pattern=`a/b/c/d` and normalizedPath=`c/d` becomes `a/b`)
+        .replace(new RegExp(`${escape(normalizedPath)}$`), '')?.split('/').length;
+        const params = normalizedPath?.split('/').reduce((acc, p, index) => {
+          if (!p.startsWith(':')) {
+            return acc;
+          }
+
+          // Get the real index of the path parameter in the matched path
+          // by offsetting by the number of segments in the initial pattern
+          const offset = numInitialSegments ? numInitialSegments - 1 : 0;
+          const value = matchedParams[p]?.[index + offset];
+          if (value) {
+            const key = p.replace(/^:/, '').replace(/\?$/, '');
+            acc[key] = routeConfig?.parse?.[key] ? routeConfig.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 => {
+        const result = createNormalizedConfigs(nestedConfig, config.screens, routeNames, initials, [...parentScreens], 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 route = routes.shift();
+  const parentScreens = [];
+  let initialRoute = findInitialRoute(route.name, parentScreens, initialRoutes);
+  parentScreens.push(route.name);
+  const 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 (Object.hasOwnProperty.call(parseConfig, name) && typeof params[name] === 'string') {
+        params[name] = parseConfig[name](params[name]);
+      }
+    });
+  }
+  return Object.keys(params).length ? params : undefined;
+};
+//# sourceMappingURL=getStateFromPath.js.map