@react-navigation/core 8.0.0-alpha.4 → 8.0.0-alpha.41

package/src/getPatternParts.tsx

@@ -1,8 +1,11 @@
+export type PatternPartRepeat = 'zero-or-more' | 'one-or-more';
+
 export type PatternPart = {
   segment: string;
-  param?: string;
-  regex?: string;
+  name?: string;
+  pattern?: string;
   optional?: boolean;
+  repeat?: PatternPartRepeat;
 };
 
 /**
@@ -15,6 +18,9 @@ export function getPatternParts(path: string): PatternPart[] {
 
   let isRegex = false;
   let isParam = false;
+  let hasRepeat = false;
+  let isEscaped = false;
+  let isInCharClass = false;
   let regexInnerParens = 0;
 
   // One extra iteration to add the last character
@@ -34,7 +40,7 @@ export function getPatternParts(path: string): PatternPart[] {
           `Encountered ':' in the middle of a segment in path: ${path}`
         );
       }
-    } else if (char === '(') {
+    } else if (char === '(' && !isEscaped && !isInCharClass) {
       if (isParam) {
         if (isRegex) {
           // The '(' is part of the regex if we're already inside one
@@ -47,13 +53,13 @@ export function getPatternParts(path: string): PatternPart[] {
           `Encountered '(' without preceding ':' in path: ${path}`
         );
       }
-    } else if (char === ')') {
+    } else if (char === ')' && !isEscaped && !isInCharClass) {
       if (isParam && isRegex) {
         if (regexInnerParens) {
           // The ')' is part of the regex if we're already inside one
           regexInnerParens--;
-          current.regex += char;
         } else {
+          current.pattern += char;
           isRegex = false;
           isParam = false;
         }
@@ -62,8 +68,8 @@ export function getPatternParts(path: string): PatternPart[] {
           `Encountered ')' without preceding '(' in path: ${path}`
         );
       }
-    } else if (char === '?') {
-      if (current.param) {
+    } else if (char === '?' && !isRegex) {
+      if (current.name) {
         isParam = false;
 
         current.optional = true;
@@ -72,6 +78,27 @@ export function getPatternParts(path: string): PatternPart[] {
           `Encountered '?' without preceding ':' in path: ${path}`
         );
       }
+    } else if (
+      current.name &&
+      !isRegex &&
+      (char === '*' || char === '+') &&
+      (path[i + 1] == null ||
+        path[i + 1] === '/' ||
+        path[i + 1] === '?' ||
+        path[i + 1] === '*' ||
+        path[i + 1] === '+')
+    ) {
+      if (
+        current.optional ||
+        (path[i + 1] !== undefined && path[i + 1] !== '/')
+      ) {
+        throw new Error(`Cannot combine path param modifiers in path: ${path}`);
+      }
+
+      isParam = false;
+
+      current.repeat = char === '*' ? 'zero-or-more' : 'one-or-more';
+      hasRepeat = true;
     } else if (char == null || (char === '/' && !isRegex)) {
       isParam = false;
 
@@ -82,12 +109,12 @@ export function getPatternParts(path: string): PatternPart[] {
         continue;
       }
 
-      if (current.param) {
-        current.param = current.param.replace(/^:/, '');
+      if (current.name) {
+        current.name = current.name.replace(/^:/, '');
       }
 
-      if (current.regex) {
-        current.regex = current.regex.replace(/^\(/, '').replace(/\)$/, '');
+      if (current.pattern) {
+        current.pattern = current.pattern.replace(/^\(/, '').replace(/\)$/, '');
       }
 
       parts.push(current);
@@ -100,13 +127,24 @@ export function getPatternParts(path: string): PatternPart[] {
     }
 
     if (isRegex) {
-      current.regex = current.regex || '';
-      current.regex += char;
+      current.pattern = current.pattern || '';
+      current.pattern += char;
+
+      // Track escapes and character classes so parens inside them are not special
+      if (isEscaped) {
+        isEscaped = false;
+      } else if (char === '\\') {
+        isEscaped = true;
+      } else if (char === '[') {
+        isInCharClass = true;
+      } else if (char === ']') {
+        isInCharClass = false;
+      }
     }
 
     if (isParam && !isRegex) {
-      current.param = current.param || '';
-      current.param += char;
+      current.name = current.name || '';
+      current.name += char;
     }
   }
 
@@ -114,7 +152,7 @@ export function getPatternParts(path: string): PatternPart[] {
     throw new Error(`Could not find closing ')' in path: ${path}`);
   }
 
-  const params = parts.map((part) => part.param).filter(Boolean);
+  const params = parts.map((part) => part.name).filter(Boolean);
 
   for (const [index, param] of params.entries()) {
     if (params.indexOf(param) !== index) {
@@ -122,5 +160,49 @@ export function getPatternParts(path: string): PatternPart[] {
     }
   }
 
+  if (hasRepeat) {
+    validateRepeatedParts(parts, path);
+  }
+
   return parts;
 }
+
+function validateRepeatedParts(parts: PatternPart[], path: string) {
+  let variablePart: PatternPart | undefined;
+
+  for (const part of parts) {
+    if (!part.name && part.segment !== '*') {
+      variablePart = undefined;
+      continue;
+    }
+
+    if (!part.repeat && !part.optional && part.segment !== '*') {
+      continue;
+    }
+
+    if (variablePart && (variablePart.repeat || part.repeat)) {
+      throw new Error(
+        `A repeated param must be separated from optional, repeated, or wildcard segments by a static segment: ${path}`
+      );
+    }
+
+    variablePart = part;
+  }
+}
+
+export function combinePatternParts<T extends PatternPart>(
+  parentParts: T[],
+  parts: T[],
+  exact = false
+): T[] {
+  const combined = exact ? parts : [...parentParts, ...parts];
+
+  if (combined.some((part) => part.repeat)) {
+    validateRepeatedParts(
+      combined,
+      combined.map((part) => part.segment).join('/')
+    );
+  }
+
+  return combined;
+}