@react-navigation/core 8.0.0-alpha.22 → 8.0.0-alpha.24

package/src/getPathFromState.tsx

@@ -22,6 +22,23 @@ type ConfigItem = {
   screens?: Record<string, ConfigItem> | undefined;
 };
 
+const encodePathParam = (value: string) => {
+  let result = '';
+
+  for (const char of value) {
+    const charCode = char.charCodeAt(0);
+    const safe =
+      (charCode >= 65 && charCode <= 90) ||
+      (charCode >= 97 && charCode <= 122) ||
+      (charCode >= 48 && charCode <= 57) ||
+      "-._~!$&'()*+,;=:@".includes(char);
+
+    result += safe ? char : encodeURIComponent(char);
+  }
+
+  return result;
+};
+
 const getActiveRoute = (
   state: State
 ): { name: string; params?: object | undefined } => {
@@ -190,30 +207,31 @@ export function getPathFromState<ParamList extends {}>(
 
       if (route.params) {
         const options = config;
+        const params = route.params as Record<string, unknown>;
+        const currentParams: Record<string, string> = {};
+
+        for (const key in params) {
+          const value = params[key];
 
-        const currentParams = Object.fromEntries(
-          Object.entries(route.params)
-            .map(([key, value]): [string, string] | null => {
-              if (value === undefined) {
-                if (options) {
-                  const optional = options.parts?.find(
-                    (part) => part.param === key
-                  )?.optional;
-
-                  if (optional) {
-                    return null;
-                  }
-                } else {
-                  return null;
-                }
+          if (value === undefined) {
+            let optional = false;
+
+            for (const part of options.parts ?? []) {
+              if (part.param === key) {
+                optional = part.optional === true;
+                break;
               }
+            }
 
-              const stringify = options?.stringify?.[key] ?? String;
+            if (optional) {
+              continue;
+            }
+          }
 
-              return [key, stringify(value)];
-            })
-            .filter((entry) => entry != null)
-        );
+          const stringify = options.stringify?.[key] ?? String;
+
+          currentParams[key] = stringify(value);
+        }
 
         if (parts?.length) {
           Object.assign(allParams, currentParams);
@@ -222,19 +240,24 @@ export function getPathFromState<ParamList extends {}>(
         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 };
-
-          parts
-            // eslint-disable-next-line no-loop-func
-            ?.forEach(({ param }) => {
-              if (param) {
-                // 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[param];
-                }
+          focusedParams = {};
+
+          for (const key in currentParams) {
+            let inPattern = false;
+
+            for (const part of parts ?? []) {
+              if (part.param === key) {
+                inPattern = true;
+                break;
               }
-            });
+            }
+
+            const value = currentParams[key];
+
+            if (!inPattern && value !== undefined && value !== 'undefined') {
+              focusedParams[key] = value;
+            }
+          }
         }
       }
 
@@ -268,13 +291,22 @@ export function getPathFromState<ParamList extends {}>(
     }
 
     if (currentOptions[route.name] != null) {
-      path += parts
-        ?.map(({ segment, param, optional }) => {
+      if (parts) {
+        let index = 0;
+
+        for (const { segment, param, optional } of parts) {
+          if (index > 0) {
+            path += '/';
+          }
+
+          index++;
+
           // 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 (segment === '*') {
-            return route.name;
+            path += route.name;
+            continue;
           }
 
           // If the path has a pattern for a param, put the param in the path
@@ -283,46 +315,39 @@ export function getPathFromState<ParamList extends {}>(
 
             if (value === undefined && optional) {
               // Optional params without value assigned in route.params should be ignored
-              return '';
+              continue;
             }
 
             // Valid characters according to
             // https://datatracker.ietf.org/doc/html/rfc3986#section-3.3 (see pchar definition)
-            return Array.from(String(value))
-              .map((char) =>
-                /[^A-Za-z0-9\-._~!$&'()*+,;=:@]/g.test(char)
-                  ? encodeURIComponent(char)
-                  : char
-              )
-              .join('');
+            path += encodePathParam(String(value));
+            continue;
           }
 
-          return encodeURIComponent(segment);
-        })
-        .join('/');
+          path += encodeURIComponent(segment);
+        }
+      }
     } else {
       path += encodeURIComponent(route.name);
     }
 
     if (!focusedParams && focusedRoute.params) {
-      focusedParams = Object.fromEntries(
-        Object.entries(focusedRoute.params).map(([key, value]) => [
-          key,
-          String(value),
-        ])
-      );
+      focusedParams = {};
+
+      const params = focusedRoute.params as Record<string, unknown>;
+
+      for (const key in params) {
+        const value = String(params[key]);
+
+        if (value !== 'undefined') {
+          focusedParams[key] = value;
+        }
+      }
     }
 
     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) {
@@ -399,11 +424,17 @@ const createConfigItem = (
 const createNormalizedConfigs = (
   options: PathConfigMap<object>,
   parts?: PatternPart[]
-): Record<string, ConfigItem> =>
-  Object.fromEntries(
-    Object.entries(options).map(([name, c]) => {
-      const result = createConfigItem(c, parts);
+): Record<string, ConfigItem> => {
+  const configs: Record<string, ConfigItem> = {};
+  const screens = options as Record<string, PathConfig<{}> | string>;
 
-      return [name, result];
-    })
-  );
+  for (const name in screens) {
+    const config = screens[name];
+
+    if (config !== undefined) {
+      configs[name] = createConfigItem(config, parts);
+    }
+  }
+
+  return configs;
+};