@remix-run/router 1.19.0 → 1.19.1

package/dist/router.umd.js

@@ -1,5 +1,5 @@
 /**
- * @remix-run/router v1.19.0
+ * @remix-run/router v1.19.1
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -1715,7 +1715,7 @@
     let inFlightDataRoutes;
     let basename = init.basename || "/";
     let dataStrategyImpl = init.unstable_dataStrategy || defaultDataStrategy;
-    let patchRoutesOnMissImpl = init.unstable_patchRoutesOnMiss;
+    let patchRoutesOnNavigationImpl = init.unstable_patchRoutesOnNavigation;
 
     // Config driven behavior flags
     let future = _extends({
@@ -1730,6 +1730,10 @@
     let unlistenHistory = null;
     // Externally-provided functions to call on all state changes
     let subscribers = new Set();
+    // FIFO queue of previously discovered routes to prevent re-calling on
+    // subsequent navigations to the same path
+    let discoveredRoutesMaxSize = 1000;
+    let discoveredRoutes = new Set();
     // Externally-provided object to hold scroll restoration locations during routing
     let savedScrollPositions = null;
     // Externally-provided function to get scroll restoration keys
@@ -1745,7 +1749,7 @@
     let initialScrollRestored = init.hydrationData != null;
     let initialMatches = matchRoutes(dataRoutes, init.history.location, basename);
     let initialErrors = null;
-    if (initialMatches == null && !patchRoutesOnMissImpl) {
+    if (initialMatches == null && !patchRoutesOnNavigationImpl) {
       // If we do not match a user-provided-route, fall back to the root
       // to allow the error boundary to take over
       let error = getInternalRouterError(404, {
@@ -1761,7 +1765,7 @@
       };
     }
 
-    // In SPA apps, if the user provided a patchRoutesOnMiss implementation and
+    // In SPA apps, if the user provided a patchRoutesOnNavigation implementation and
     // our initial match is a splat route, clear them out so we run through lazy
     // discovery on hydration in case there's a more accurate lazy route match.
     // In SSR apps (with `hydrationData`), we expect that the server will send
@@ -1779,7 +1783,7 @@
       initialMatches = [];
 
       // If partial hydration and fog of war is enabled, we will be running
-      // `patchRoutesOnMiss` during hydration so include any partial matches as
+      // `patchRoutesOnNavigation` during hydration so include any partial matches as
       // the initial matches so we can properly render `HydrateFallback`'s
       if (future.v7_partialHydration) {
         let fogOfWar = checkFogOfWar(null, dataRoutes, init.history.location.pathname);
@@ -1918,7 +1922,7 @@
     // we don't need to update UI state if they change
     let blockerFunctions = new Map();
 
-    // Map of pending patchRoutesOnMiss() promises (keyed by path/matches) so
+    // Map of pending patchRoutesOnNavigation() promises (keyed by path/matches) so
     // that we only kick them off once for a given combo
     let pendingPatchRoutes = new Map();
 
@@ -3542,7 +3546,16 @@
       return null;
     }
     function checkFogOfWar(matches, routesToUse, pathname) {
-      if (patchRoutesOnMissImpl) {
+      if (patchRoutesOnNavigationImpl) {
+        // Don't bother re-calling patchRouteOnMiss for a path we've already
+        // processed.  the last execution would have patched the route tree
+        // accordingly so `matches` here are already accurate.
+        if (discoveredRoutes.has(pathname)) {
+          return {
+            active: false,
+            matches
+          };
+        }
         if (!matches) {
           let fogMatches = matchRoutesImpl(routesToUse, pathname, basename, true);
           return {
@@ -3550,11 +3563,10 @@
             matches: fogMatches || []
           };
         } else {
-          let leafRoute = matches[matches.length - 1].route;
-          if (leafRoute.path && (leafRoute.path === "*" || leafRoute.path.endsWith("/*"))) {
-            // If we matched a splat, it might only be because we haven't yet fetched
-            // the children that would match with a higher score, so let's fetch
-            // around and find out
+          if (Object.keys(matches[0].params).length > 0) {
+            // If we matched a dynamic param or a splat, it might only be because
+            // we haven't yet discovered other routes that would match with a
+            // higher score.  Call patchRoutesOnNavigation just to be sure
             let partialMatches = matchRoutesImpl(routesToUse, pathname, basename, true);
             return {
               active: true,
@@ -3570,12 +3582,11 @@
     }
     async function discoverRoutes(matches, pathname, signal) {
       let partialMatches = matches;
-      let route = partialMatches.length > 0 ? partialMatches[partialMatches.length - 1].route : null;
       while (true) {
         let isNonHMR = inFlightDataRoutes == null;
         let routesToUse = inFlightDataRoutes || dataRoutes;
         try {
-          await loadLazyRouteChildren(patchRoutesOnMissImpl, pathname, partialMatches, routesToUse, manifest, mapRouteProperties, pendingPatchRoutes, signal);
+          await loadLazyRouteChildren(patchRoutesOnNavigationImpl, pathname, partialMatches, routesToUse, manifest, mapRouteProperties, pendingPatchRoutes, signal);
         } catch (e) {
           return {
             type: "error",
@@ -3599,52 +3610,32 @@
           };
         }
         let newMatches = matchRoutes(routesToUse, pathname, basename);
-        let matchedSplat = false;
         if (newMatches) {
-          let leafRoute = newMatches[newMatches.length - 1].route;
-          if (leafRoute.index) {
-            // If we found an index route, we can stop
-            return {
-              type: "success",
-              matches: newMatches
-            };
-          }
-          if (leafRoute.path && leafRoute.path.length > 0) {
-            if (leafRoute.path === "*") {
-              // If we found a splat route, we can't be sure there's not a
-              // higher-scoring route down some partial matches trail so we need
-              // to check that out
-              matchedSplat = true;
-            } else {
-              // If we found a non-splat route, we can stop
-              return {
-                type: "success",
-                matches: newMatches
-              };
-            }
-          }
-        }
-        let newPartialMatches = matchRoutesImpl(routesToUse, pathname, basename, true);
-
-        // If we are no longer partially matching anything, this was either a
-        // legit splat match above, or it's a 404.  Also avoid loops if the
-        // second pass results in the same partial matches
-        if (!newPartialMatches || partialMatches.map(m => m.route.id).join("-") === newPartialMatches.map(m => m.route.id).join("-")) {
+          addToFifoQueue(pathname, discoveredRoutes);
           return {
             type: "success",
-            matches: matchedSplat ? newMatches : null
+            matches: newMatches
           };
         }
-        partialMatches = newPartialMatches;
-        route = partialMatches[partialMatches.length - 1].route;
-        if (route.path === "*") {
-          // The splat is still our most accurate partial, so run with it
+        let newPartialMatches = matchRoutesImpl(routesToUse, pathname, basename, true);
+
+        // Avoid loops if the second pass results in the same partial matches
+        if (!newPartialMatches || partialMatches.length === newPartialMatches.length && partialMatches.every((m, i) => m.route.id === newPartialMatches[i].route.id)) {
+          addToFifoQueue(pathname, discoveredRoutes);
           return {
             type: "success",
-            matches: partialMatches
+            matches: null
           };
         }
+        partialMatches = newPartialMatches;
+      }
+    }
+    function addToFifoQueue(path, queue) {
+      if (queue.size >= discoveredRoutesMaxSize) {
+        let first = queue.values().next().value;
+        queue.delete(first);
       }
+      queue.add(path);
     }
     function _internalSetRoutes(newRoutes) {
       manifest = {};
@@ -4515,15 +4506,15 @@
   }
 
   /**
-   * Idempotent utility to execute patchRoutesOnMiss() to lazily load route
+   * Idempotent utility to execute patchRoutesOnNavigation() to lazily load route
    * definitions and update the routes/routeManifest
    */
-  async function loadLazyRouteChildren(patchRoutesOnMissImpl, path, matches, routes, manifest, mapRouteProperties, pendingRouteChildren, signal) {
+  async function loadLazyRouteChildren(patchRoutesOnNavigationImpl, path, matches, routes, manifest, mapRouteProperties, pendingRouteChildren, signal) {
     let key = [path, ...matches.map(m => m.route.id)].join("-");
     try {
       let pending = pendingRouteChildren.get(key);
       if (!pending) {
-        pending = patchRoutesOnMissImpl({
+        pending = patchRoutesOnNavigationImpl({
           path,
           matches,
           patch: (routeId, children) => {
@@ -5130,7 +5121,7 @@
     if (status === 400) {
       statusText = "Bad Request";
       if (type === "route-discovery") {
-        errorMessage = "Unable to match URL \"" + pathname + "\" - the `unstable_patchRoutesOnMiss()` " + ("function threw the following error:\n" + message);
+        errorMessage = "Unable to match URL \"" + pathname + "\" - the `unstable_patchRoutesOnNavigation()` " + ("function threw the following error:\n" + message);
       } else if (method && pathname && routeId) {
         errorMessage = "You made a " + method + " request to \"" + pathname + "\" but " + ("did not provide a `loader` for route \"" + routeId + "\", ") + "so there is no way to handle the request.";
       } else if (type === "defer-action") {