@remix-run/router 1.19.0 → 1.19.1

package/dist/router.d.ts

@@ -1,6 +1,6 @@
 import type { History, Location, Path, To } from "./history";
 import { Action as HistoryAction } from "./history";
-import type { AgnosticDataRouteMatch, AgnosticDataRouteObject, AgnosticRouteObject, DataStrategyFunction, DeferredData, DetectErrorBoundaryFunction, FormEncType, HTMLFormMethod, MapRoutePropertiesFunction, RouteData, Submission, UIMatch, AgnosticPatchRoutesOnMissFunction, DataWithResponseInit } from "./utils";
+import type { AgnosticDataRouteMatch, AgnosticDataRouteObject, AgnosticRouteObject, DataStrategyFunction, DeferredData, DetectErrorBoundaryFunction, FormEncType, HTMLFormMethod, MapRoutePropertiesFunction, RouteData, Submission, UIMatch, AgnosticPatchRoutesOnNavigationFunction, DataWithResponseInit } from "./utils";
 /**
  * A Router instance manages all navigation and data loading/mutations
  */
@@ -285,7 +285,7 @@ export interface RouterInit {
     future?: Partial<FutureConfig>;
     hydrationData?: HydrationState;
     window?: Window;
-    unstable_patchRoutesOnMiss?: AgnosticPatchRoutesOnMissFunction;
+    unstable_patchRoutesOnNavigation?: AgnosticPatchRoutesOnNavigationFunction;
     unstable_dataStrategy?: DataStrategyFunction;
 }
 /**

package/dist/router.js

@@ -1,5 +1,5 @@
 /**
- * @remix-run/router v1.19.0
+ * @remix-run/router v1.19.1
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -1363,7 +1363,7 @@ function createRouter(init) {
   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({
     v7_fetcherPersist: false,
@@ -1377,6 +1377,10 @@ function createRouter(init) {
   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
@@ -1392,7 +1396,7 @@ function createRouter(init) {
   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, {
@@ -1407,7 +1411,7 @@ function createRouter(init) {
       [route.id]: error
     };
   }
-  // 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
@@ -1424,7 +1428,7 @@ function createRouter(init) {
     initialized = false;
     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);
@@ -1541,7 +1545,7 @@ function createRouter(init) {
   // Store blocker functions in a separate Map outside of router state since
   // 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();
   // Flag to ignore the next history update, so we can revert the URL change on
@@ -3082,7 +3086,16 @@ function createRouter(init) {
     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 {
@@ -3090,11 +3103,10 @@ function createRouter(init) {
           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,
@@ -3110,12 +3122,11 @@ function createRouter(init) {
   }
   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",
@@ -3139,51 +3150,31 @@ function createRouter(init) {
         };
       }
       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 = {};
@@ -4012,15 +4003,15 @@ function shouldRevalidateLoader(loaderMatch, arg) {
   return arg.defaultShouldRevalidate;
 }
 /**
- * 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) => {
@@ -4607,7 +4598,7 @@ function getInternalRouterError(status, _temp5) {
   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") {