@remix-run/router 0.0.0-experimental-63b6834e → 0.0.0-experimental-cf9637ce

package/dist/index.d.ts

@@ -1,8 +1,7 @@
-export type { ActionFunction, ActionFunctionArgs, AgnosticDataIndexRouteObject, AgnosticDataNonIndexRouteObject, AgnosticDataRouteMatch, AgnosticDataRouteObject, AgnosticIndexRouteObject, AgnosticNonIndexRouteObject, AgnosticRouteMatch, AgnosticRouteObject, LazyRouteFunction, TrackedPromise, FormEncType, FormMethod, JsonFunction, LoaderFunction, LoaderFunctionArgs, ParamParseKey, Params, PathMatch, PathPattern, RedirectFunction, ShouldRevalidateFunction, Submission, } from "./utils";
+export type { ActionFunction, ActionFunctionArgs, AgnosticDataIndexRouteObject, AgnosticDataNonIndexRouteObject, AgnosticDataRouteMatch, AgnosticDataRouteObject, AgnosticIndexRouteObject, AgnosticNonIndexRouteObject, AgnosticRouteMatch, AgnosticRouteObject, TrackedPromise, FormEncType, FormMethod, JsonFunction, LoaderFunction, LoaderFunctionArgs, ParamParseKey, Params, PathMatch, PathPattern, RedirectFunction, ShouldRevalidateFunction, Submission, } from "./utils";
 export { AbortedDeferredError, ErrorResponse, defer, generatePath, getToPathname, isRouteErrorResponse, joinPaths, json, matchPath, matchRoutes, normalizePathname, redirect, resolvePath, resolveTo, stripBasename, warning, } from "./utils";
 export type { BrowserHistory, BrowserHistoryOptions, HashHistory, HashHistoryOptions, History, InitialEntry, Location, MemoryHistory, MemoryHistoryOptions, Path, To, } from "./history";
 export { Action, createBrowserHistory, createPath, createHashHistory, createMemoryHistory, invariant, parsePath, } from "./history";
 export * from "./router";
 /** @internal */
-export type { RouteManifest as UNSAFE_RouteManifest } from "./utils";
 export { DeferredData as UNSAFE_DeferredData, convertRoutesToDataRoutes as UNSAFE_convertRoutesToDataRoutes, getPathContributingMatches as UNSAFE_getPathContributingMatches, } from "./utils";

package/dist/router.cjs.js

@@ -1,5 +1,5 @@
 /**
- * @remix-run/router v0.0.0-experimental-63b6834e
+ * @remix-run/router v0.0.0-experimental-cf9637ce
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -565,54 +565,40 @@ let ResultType;
   ResultType["error"] = "error";
 })(ResultType || (ResultType = {}));
 
-const immutableRouteKeys = new Set(["caseSensitive", "path", "id", "index", "children"]);
-/**
- * lazy() function to load a route definition, which can add non-matching
- * related properties to a route
- */
-
 function isIndexRoute(route) {
   return route.index === true;
 } // Walk the route tree generating unique IDs where necessary so we are working
 // solely with AgnosticDataRouteObject's within the Router
 
 
-function convertRoutesToDataRoutes(routes, hasErrorBoundary, parentPath, manifest) {
+function convertRoutesToDataRoutes(routes, parentPath, allIds) {
   if (parentPath === void 0) {
     parentPath = [];
   }
 
-  if (manifest === void 0) {
-    manifest = {};
+  if (allIds === void 0) {
+    allIds = new Set();
   }
 
   return routes.map((route, index) => {
     let treePath = [...parentPath, index];
     let id = typeof route.id === "string" ? route.id : treePath.join("-");
     invariant(route.index !== true || !route.children, "Cannot specify children on an index route");
-    invariant(!manifest[id], "Found a route id collision on id \"" + id + "\".  Route " + "id's must be globally unique within Data Router usages");
+    invariant(!allIds.has(id), "Found a route id collision on id \"" + id + "\".  Route " + "id's must be globally unique within Data Router usages");
+    allIds.add(id);
 
     if (isIndexRoute(route)) {
       let indexRoute = _extends({}, route, {
-        hasErrorBoundary: hasErrorBoundary(route),
         id
       });
 
-      manifest[id] = indexRoute;
       return indexRoute;
     } else {
       let pathOrLayoutRoute = _extends({}, route, {
         id,
-        hasErrorBoundary: hasErrorBoundary(route),
-        children: undefined
+        children: route.children ? convertRoutesToDataRoutes(route.children, treePath, allIds) : undefined
       });
 
-      manifest[id] = pathOrLayoutRoute;
-
-      if (route.children) {
-        pathOrLayoutRoute.children = convertRoutesToDataRoutes(route.children, hasErrorBoundary, treePath, manifest);
-      }
-
       return pathOrLayoutRoute;
     }
   });
@@ -1492,9 +1478,7 @@ const IDLE_BLOCKER = {
 };
 const ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
 const isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined";
-const isServer = !isBrowser;
-
-const defaultHasErrorBoundary = route => Boolean(route.hasErrorBoundary); //#endregion
+const isServer = !isBrowser; //#endregion
 ////////////////////////////////////////////////////////////////////////////////
 //#region createRouter
 ////////////////////////////////////////////////////////////////////////////////
@@ -1503,14 +1487,10 @@ const defaultHasErrorBoundary = route => Boolean(route.hasErrorBoundary); //#end
  * Create a router and listen to history POP navigations
  */
 
-
 function createRouter(init) {
   invariant(init.routes.length > 0, "You must provide a non-empty routes array to createRouter");
-  let hasErrorBoundary = init.hasErrorBoundary || defaultHasErrorBoundary; // Routes keyed by ID
-
-  let manifest = {}; // Routes in tree format for matching
-
-  let dataRoutes = convertRoutesToDataRoutes(init.routes, hasErrorBoundary, undefined, manifest); // Cleanup function for history
+  let dataRoutes = convertRoutesToDataRoutes(init.routes);
+  let inFlightDataRoutes; // Cleanup function for history
 
   let unlistenHistory = null; // Externally-provided functions to call on all state changes
 
@@ -1547,10 +1527,7 @@ function createRouter(init) {
     };
   }
 
-  let initialized = // All initialMatches need to be loaded before we're ready.  If we have lazy
-  // functions around still then we'll need to run them in initialize()
-  !initialMatches.some(m => m.route.lazy) && ( // And we have to either have no loaders or have been provided hydrationData
-  !initialMatches.some(m => m.route.loader) || init.hydrationData != null);
+  let initialized = !initialMatches.some(m => m.route.loader) || init.hydrationData != null;
   let router;
   let state = {
     historyAction: init.history.action,
@@ -1674,57 +1651,12 @@ function createRouter(init) {
       }
 
       return startNavigation(historyAction, location);
-    });
+    }); // Kick off initial data load if needed.  Use Pop to avoid modifying history
 
-    if (init.onInitialize) {
-      if (state.initialized) {
-        // We delay calling the onInitialize function until the next tick so
-        // this function has a chance to return the router instance, otherwise
-        // consumers will get an error if they try to use the returned router
-        // instance in their callback. Note that we also provide the router
-        // instance to the callback as a convenience and to avoid this ambiguity
-        // in the consumer code.
-        Promise.resolve().then(() => init.onInitialize({
-          router
-        }));
-      } else {
-        let unsubscribe = subscribe(updatedState => {
-          if (updatedState.initialized) {
-            unsubscribe();
-            init.onInitialize({
-              router
-            });
-          }
-        });
-      }
-    }
-
-    if (state.initialized) {
-      return router;
-    }
-
-    let lazyMatches = state.matches.filter(m => m.route.lazy);
-
-    if (lazyMatches.length === 0) {
-      // Kick off initial data load if needed.  Use Pop to avoid modifying history
+    if (!state.initialized) {
       startNavigation(exports.Action.Pop, state.location);
-      return router;
-    } // Load lazy modules, then kick off initial data load if needed
-
-
-    loadLazyRouteModules(lazyMatches, hasErrorBoundary, manifest).then(() => {
-      let initialized = !state.matches.some(m => m.route.loader) || init.hydrationData != null;
+    }
 
-      if (initialized) {
-        // We already have required loaderData so we can just set initialized
-        updateState({
-          initialized: true
-        });
-      } else {
-        // We still need to kick off initial data loads
-        startNavigation(exports.Action.Pop, state.location);
-      }
-    });
     return router;
   } // Clean up a router and it's side effects
 
@@ -1794,6 +1726,12 @@ function createRouter(init) {
 
 
     let preventScrollReset = pendingPreventScrollReset === true || state.navigation.formMethod != null && isMutationMethod(state.navigation.formMethod) && ((_location$state2 = location.state) == null ? void 0 : _location$state2._isRedirect) !== true;
+
+    if (inFlightDataRoutes) {
+      dataRoutes = inFlightDataRoutes;
+      inFlightDataRoutes = undefined;
+    }
+
     updateState(_extends({}, newState, {
       // matches, errors, fetchers go through as-is
       actionData,
@@ -1949,8 +1887,9 @@ function createRouter(init) {
 
     saveScrollPosition(state.location, state.matches);
     pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;
+    let routesToUse = inFlightDataRoutes || dataRoutes;
     let loadingNavigation = opts && opts.overrideNavigation;
-    let matches = matchRoutes(dataRoutes, location, init.basename); // Short circuit with a 404 on the root error boundary if we match nothing
+    let matches = matchRoutes(routesToUse, location, init.basename); // Short circuit with a 404 on the root error boundary if we match nothing
 
     if (!matches) {
       let error = getInternalRouterError(404, {
@@ -1959,7 +1898,7 @@ function createRouter(init) {
       let {
         matches: notFoundMatches,
         route
-      } = getShortCircuitMatches(dataRoutes); // Cancel all pending deferred on 404s since we don't keep any routes
+      } = getShortCircuitMatches(routesToUse); // Cancel all pending deferred on 404s since we don't keep any routes
 
       cancelActiveDeferreds();
       completeNavigation(location, {
@@ -2063,16 +2002,6 @@ function createRouter(init) {
     let result;
     let actionMatch = getTargetMatch(matches, location);
 
-    if (actionMatch.route.lazy) {
-      await loadLazyRouteModules([actionMatch], hasErrorBoundary, manifest);
-
-      if (request.signal.aborted) {
-        return {
-          shortCircuited: true
-        };
-      }
-    }
-
     if (!actionMatch.route.action) {
       result = {
         type: ResultType.error,
@@ -2174,7 +2103,8 @@ function createRouter(init) {
       formData: loadingNavigation.formData,
       formEncType: loadingNavigation.formEncType
     } : undefined;
-    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, activeSubmission, location, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, pendingActionData, pendingError, fetchLoadMatches); // Cancel pending deferreds for no-longer-matched routes or routes we're
+    let routesToUse = inFlightDataRoutes || dataRoutes;
+    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, activeSubmission, location, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, fetchLoadMatches, routesToUse, init.basename, pendingActionData, pendingError); // Cancel pending deferreds for no-longer-matched routes or routes we're
     // about to reload.  Note that if this is an action reload we would have
     // already cancelled all pending deferreds so this would be a no-op
 
@@ -2226,18 +2156,6 @@ function createRouter(init) {
 
     pendingNavigationLoadId = ++incrementingLoadId;
     revalidatingFetchers.forEach(rf => fetchControllers.set(rf.key, pendingNavigationController));
-    let lazyMatches = matches.filter(m => m.route.lazy);
-
-    if (lazyMatches.length > 0) {
-      await loadLazyRouteModules(lazyMatches, hasErrorBoundary, manifest);
-
-      if (request.signal.aborted) {
-        return {
-          shortCircuited: true
-        };
-      }
-    }
-
     let {
       results,
       loaderResults,
@@ -2303,7 +2221,8 @@ function createRouter(init) {
     }
 
     if (fetchControllers.has(key)) abortFetcher(key);
-    let matches = matchRoutes(dataRoutes, href, init.basename);
+    let routesToUse = inFlightDataRoutes || dataRoutes;
+    let matches = matchRoutes(routesToUse, href, init.basename);
 
     if (!matches) {
       setFetcherError(key, routeId, getInternalRouterError(404, {
@@ -2328,9 +2247,7 @@ function createRouter(init) {
 
     fetchLoadMatches.set(key, {
       routeId,
-      path,
-      match,
-      matches
+      path
     });
     handleFetcherLoader(key, routeId, path, match, matches, submission);
   } // Call the action for the matched fetcher.submit(), and then handle redirects,
@@ -2341,7 +2258,7 @@ function createRouter(init) {
     interruptActiveLoads();
     fetchLoadMatches.delete(key);
 
-    if (!match.route.lazy && !match.route.action) {
+    if (!match.route.action) {
       let error = getInternalRouterError(405, {
         method: submission.formMethod,
         pathname: path,
@@ -2369,25 +2286,6 @@ function createRouter(init) {
     let abortController = new AbortController();
     let fetchRequest = createClientSideRequest(init.history, path, abortController.signal, submission);
     fetchControllers.set(key, abortController);
-
-    if (match.route.lazy) {
-      await loadLazyRouteModules([match], hasErrorBoundary, manifest);
-
-      if (fetchRequest.signal.aborted) {
-        return;
-      }
-
-      if (!match.route.action) {
-        let error = getInternalRouterError(405, {
-          method: submission.formMethod,
-          pathname: path,
-          routeId: routeId
-        });
-        setFetcherError(key, routeId, error);
-        return;
-      }
-    }
-
     let actionResult = await callLoaderOrAction("action", fetchRequest, match, requestMatches, router.basename);
 
     if (fetchRequest.signal.aborted) {
@@ -2436,7 +2334,8 @@ function createRouter(init) {
 
     let nextLocation = state.navigation.location || state.location;
     let revalidationRequest = createClientSideRequest(init.history, nextLocation, abortController.signal);
-    let matches = state.navigation.state !== "idle" ? matchRoutes(dataRoutes, state.navigation.location, init.basename) : state.matches;
+    let routesToUse = inFlightDataRoutes || dataRoutes;
+    let matches = state.navigation.state !== "idle" ? matchRoutes(routesToUse, state.navigation.location, init.basename) : state.matches;
     invariant(matches, "Didn't find any matches after fetcher action");
     let loadId = ++incrementingLoadId;
     fetchReloadIds.set(key, loadId);
@@ -2449,10 +2348,10 @@ function createRouter(init) {
     });
 
     state.fetchers.set(key, loadFetcher);
-    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, submission, nextLocation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, {
+    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, submission, nextLocation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, fetchLoadMatches, routesToUse, init.basename, {
       [match.route.id]: actionResult.data
-    }, undefined, // No need to send through errors since we short circuit above
-    fetchLoadMatches); // Put all revalidating fetchers into the loading state, except for the
+    }, undefined // No need to send through errors since we short circuit above
+    ); // Put all revalidating fetchers into the loading state, except for the
     // current fetcher which we want to keep in it's current loading state which
     // contains it's action submission info + action data
 
@@ -2474,16 +2373,6 @@ function createRouter(init) {
     updateState({
       fetchers: new Map(state.fetchers)
     });
-    let lazyMatches = matches.filter(m => m.route.lazy);
-
-    if (match.route.lazy) {
-      await loadLazyRouteModules(lazyMatches, hasErrorBoundary, manifest);
-
-      if (revalidationRequest.signal.aborted) {
-        return;
-      }
-    }
-
     let {
       results,
       loaderResults,
@@ -2568,15 +2457,6 @@ function createRouter(init) {
     let abortController = new AbortController();
     let fetchRequest = createClientSideRequest(init.history, path, abortController.signal);
     fetchControllers.set(key, abortController);
-
-    if (match.route.lazy) {
-      await loadLazyRouteModules([match], hasErrorBoundary, manifest);
-
-      if (fetchRequest.signal.aborted) {
-        return;
-      }
-    }
-
     let result = await callLoaderOrAction("loader", fetchRequest, match, matches, router.basename); // Deferred isn't supported for fetcher loads, await everything and treat it
     // as a normal load.  resolveDeferredData will return undefined if this
     // fetcher gets aborted, so we just leave result untouched and short circuit
@@ -2745,7 +2625,19 @@ function createRouter(init) {
     // Call all navigation loaders and revalidating fetcher loaders in parallel,
     // then slice off the results into separate arrays so we can handle them
     // accordingly
-    let results = await Promise.all([...matchesToLoad.map(match => callLoaderOrAction("loader", request, match, matches, router.basename)), ...fetchersToLoad.map(f => callLoaderOrAction("loader", createClientSideRequest(init.history, f.path, request.signal), f.match, f.matches, router.basename))]);
+    let results = await Promise.all([...matchesToLoad.map(match => callLoaderOrAction("loader", request, match, matches, router.basename)), ...fetchersToLoad.map(f => {
+      if (f.matches && f.match) {
+        return callLoaderOrAction("loader", createClientSideRequest(init.history, f.path, request.signal), f.match, f.matches, router.basename);
+      } else {
+        let error = {
+          type: ResultType.error,
+          error: getInternalRouterError(404, {
+            pathname: f.path
+          })
+        };
+        return error;
+      }
+    })]);
     let loaderResults = results.slice(0, matchesToLoad.length);
     let fetcherResults = results.slice(matchesToLoad.length);
     await Promise.all([resolveDeferredResults(currentMatches, matchesToLoad, loaderResults, request.signal, false, state.loaderData), resolveDeferredResults(currentMatches, fetchersToLoad.map(f => f.match), fetcherResults, request.signal, true)]);
@@ -2980,6 +2872,10 @@ function createRouter(init) {
     return null;
   }
 
+  function _internalSetRoutes(newRoutes) {
+    inFlightDataRoutes = newRoutes;
+  }
+
   router = {
     get basename() {
       return init.basename;
@@ -3009,7 +2905,10 @@ function createRouter(init) {
     getBlocker,
     deleteBlocker,
     _internalFetchControllers: fetchControllers,
-    _internalActiveDeferreds: activeDeferreds
+    _internalActiveDeferreds: activeDeferreds,
+    // TODO: Remove setRoutes, it's temporary to avoid dealing with
+    // updating the tree while validating the update algorithm.
+    _internalSetRoutes
   };
   return router;
 } //#endregion
@@ -3020,9 +2919,7 @@ function createRouter(init) {
 const UNSAFE_DEFERRED_SYMBOL = Symbol("deferred");
 function createStaticHandler(routes, opts) {
   invariant(routes.length > 0, "You must provide a non-empty routes array to createStaticHandler");
-  let manifest = {};
-  let hasErrorBoundary = (opts == null ? void 0 : opts.hasErrorBoundary) || defaultHasErrorBoundary;
-  let dataRoutes = convertRoutesToDataRoutes(routes, hasErrorBoundary, undefined, manifest);
+  let dataRoutes = convertRoutesToDataRoutes(routes);
   let basename = (opts ? opts.basename : null) || "/";
   /**
    * The query() method is intended for document requests, in which we want to
@@ -3207,16 +3104,6 @@ function createStaticHandler(routes, opts) {
 
   async function queryImpl(request, location, matches, requestContext, routeMatch) {
     invariant(request.signal, "query()/queryRoute() requests must contain an AbortController signal");
-    let lazyMatches = matches.filter(m => m.route.lazy);
-
-    if (lazyMatches.length > 0) {
-      await loadLazyRouteModules(lazyMatches, hasErrorBoundary, manifest);
-
-      if (request.signal.aborted) {
-        let method = routeMatch != null ? "queryRoute" : "query";
-        throw new Error(method + "() call aborted");
-      }
-    }
 
     try {
       if (isMutationMethod(request.method.toLowerCase())) {
@@ -3522,7 +3409,7 @@ function getLoaderMatchesUntilBoundary(matches, boundaryId) {
   return boundaryMatches;
 }
 
-function getMatchesToLoad(history, state, matches, submission, location, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, pendingActionData, pendingError, fetchLoadMatches) {
+function getMatchesToLoad(history, state, matches, submission, location, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, fetchLoadMatches, routesToUse, basename, pendingActionData, pendingError) {
   let actionResult = pendingError ? Object.values(pendingError)[0] : pendingActionData ? Object.values(pendingActionData)[0] : undefined;
   let currentUrl = history.createURL(state.location);
   let nextUrl = history.createURL(location);
@@ -3534,11 +3421,6 @@ function getMatchesToLoad(history, state, matches, submission, location, isReval
   let boundaryId = pendingError ? Object.keys(pendingError)[0] : undefined;
   let boundaryMatches = getLoaderMatchesUntilBoundary(matches, boundaryId);
   let navigationMatches = boundaryMatches.filter((match, index) => {
-    if (match.route.lazy) {
-      // We haven't loaded this route yet so we don't know if it's got a loader!
-      return true;
-    }
-
     if (match.route.loader == null) {
       return false;
     } // Always call the loader on new route instances and pending defer cancellations
@@ -3566,36 +3448,56 @@ function getMatchesToLoad(history, state, matches, submission, location, isReval
   }); // Pick fetcher.loads that need to be revalidated
 
   let revalidatingFetchers = [];
-  fetchLoadMatches && fetchLoadMatches.forEach((f, key) => {
+  fetchLoadMatches.forEach((f, key) => {
+    // Don't revalidate if fetcher won't be present in the subsequent render
     if (!matches.some(m => m.route.id === f.routeId)) {
-      // This fetcher is not going to be present in the subsequent render so
-      // there's no need to revalidate it
       return;
-    } else if (cancelledFetcherLoads.includes(key)) {
-      // This fetcher was cancelled from a prior action submission - force reload
+    }
+
+    let fetcherMatches = matchRoutes(routesToUse, f.path, basename); // If the fetcher path no longer matches, push it in with null matches so
+    // we can trigger a 404 in callLoadersAndMaybeResolveData
+
+    if (!fetcherMatches) {
       revalidatingFetchers.push(_extends({
         key
-      }, f));
-    } else {
-      // Revalidating fetchers are decoupled from the route matches since they
-      // hit a static href, so they _always_ check shouldRevalidate and the
-      // default is strictly if a revalidation is explicitly required (action
-      // submissions, useRevalidator, X-Remix-Revalidate).
-      let shouldRevalidate = shouldRevalidateLoader(f.match, _extends({
-        currentUrl,
-        currentParams: state.matches[state.matches.length - 1].params,
-        nextUrl,
-        nextParams: matches[matches.length - 1].params
-      }, submission, {
-        actionResult,
-        defaultShouldRevalidate
+      }, f, {
+        matches: null,
+        match: null
       }));
+      return;
+    }
 
-      if (shouldRevalidate) {
-        revalidatingFetchers.push(_extends({
-          key
-        }, f));
-      }
+    let fetcherMatch = getTargetMatch(fetcherMatches, f.path);
+
+    if (cancelledFetcherLoads.includes(key)) {
+      revalidatingFetchers.push(_extends({
+        key,
+        matches: fetcherMatches,
+        match: fetcherMatch
+      }, f));
+      return;
+    } // Revalidating fetchers are decoupled from the route matches since they
+    // hit a static href, so they _always_ check shouldRevalidate and the
+    // default is strictly if a revalidation is explicitly required (action
+    // submissions, useRevalidator, X-Remix-Revalidate).
+
+
+    let shouldRevalidate = shouldRevalidateLoader(fetcherMatch, _extends({
+      currentUrl,
+      currentParams: state.matches[state.matches.length - 1].params,
+      nextUrl,
+      nextParams: matches[matches.length - 1].params
+    }, submission, {
+      actionResult,
+      defaultShouldRevalidate
+    }));
+
+    if (shouldRevalidate) {
+      revalidatingFetchers.push(_extends({
+        key,
+        matches: fetcherMatches,
+        match: fetcherMatch
+      }, f));
     }
   });
   return [navigationMatches, revalidatingFetchers];
@@ -3632,57 +3534,6 @@ function shouldRevalidateLoader(loaderMatch, arg) {
 
   return arg.defaultShouldRevalidate;
 }
-/**
- * Execute route.lazy() methods to lazily load route modules (loader, action,
- * shouldRevalidate) and update the routeManifest in place which shares objects
- * with dataRoutes so those get updated as well.
- */
-
-
-async function loadLazyRouteModules(lazyMatches, hasErrorBoundary, manifest) {
-  await Promise.all(lazyMatches.map(async match => {
-    let mod = await match.route.lazy(); // If the lazy route function has already been executed and removed from
-    // the route object by another call while we were waiting for the promise
-    // to resolve then we don't want to resolve the same route again.
-
-    if (!match.route.lazy) {
-      return;
-    }
-
-    let routeToUpdate = manifest[match.route.id];
-    invariant(routeToUpdate, "No route found in manifest"); // For now, we update in place.  We think this is ok since there's no way
-    // we could yet be sitting on this route since we can't get there without
-    // resolving through here first.  This is different than the HMR "update"
-    // use-case where we may actively be on the route being updated.  The main
-    // concern boils down to "does this mutation affect any ongoing navigations
-    // or any current state.matches values?".  If not, I think it's safe to
-    // mutate in place.  It's also worth noting that this is a more targeted
-    // update that cannot touch things like path/index/children so it cannot
-    // affect the routes we've already matched.
-
-    let routeUpdates = {};
-
-    for (let k in mod) {
-      if (!immutableRouteKeys.has(k)) {
-        routeUpdates[k] = mod[k];
-      }
-    } // Mutate the route with the provided updates.  Do this first so we pass
-    // the updated version to hasErrorBoundary
-
-
-    Object.assign(routeToUpdate, routeUpdates); // Mutate the `hasErrorBoundary` property on the route based on the route
-    // updates and remove the `lazy` function so we don't resolve the lazy
-    // route again.
-
-    Object.assign(routeToUpdate, {
-      // To keep things framework agnostic, we use the provided
-      // `hasErrorBoundary` function to set the `hasErrorBoundary` route
-      // property since the logic will differ between frameworks.
-      hasErrorBoundary: hasErrorBoundary(_extends({}, routeToUpdate)),
-      lazy: undefined
-    });
-  }));
-}
 
 async function callLoaderOrAction(type, request, match, matches, basename, isStaticRequest, isRouteRequest, requestContext) {
   if (basename === void 0) {
@@ -3816,9 +3667,13 @@ async function callLoaderOrAction(type, request, match, matches, basename, isSta
   }
 
   if (result instanceof DeferredData) {
+    var _result$init, _result$init2;
+
     return {
       type: ResultType.deferred,
-      deferredData: result
+      deferredData: result,
+      statusCode: (_result$init = result.init) == null ? void 0 : _result$init.status,
+      headers: ((_result$init2 = result.init) == null ? void 0 : _result$init2.headers) && new Headers(result.init.headers)
     };
   }
 
@@ -3955,7 +3810,7 @@ function processLoaderData(state, matches, matchesToLoad, results, pendingError,
     let result = fetcherResults[index]; // Process fetcher non-redirect errors
 
     if (isErrorResult(result)) {
-      let boundaryMatch = findNearestBoundary(state.matches, match.route.id);
+      let boundaryMatch = findNearestBoundary(state.matches, match == null ? void 0 : match.route.id);
 
       if (!(errors && errors[boundaryMatch.route.id])) {
         errors = _extends({}, errors, {
@@ -4002,7 +3857,9 @@ function mergeLoaderData(loaderData, newLoaderData, matches, errors) {
       if (newLoaderData[id] !== undefined) {
         mergedLoaderData[id] = newLoaderData[id];
       }
-    } else if (loaderData[id] !== undefined) {
+    } else if (loaderData[id] !== undefined && match.route.loader) {
+      // Preserve existing keys not included in newLoaderData and where a loader
+      // wasn't removed by HMR
       mergedLoaderData[id] = loaderData[id];
     }
 
@@ -4139,7 +3996,14 @@ function isMutationMethod(method) {
 async function resolveDeferredResults(currentMatches, matchesToLoad, results, signal, isFetcher, currentLoaderData) {
   for (let index = 0; index < results.length; index++) {
     let result = results[index];
-    let match = matchesToLoad[index];
+    let match = matchesToLoad[index]; // If we don't have a match, then we can have a deferred result to do
+    // anything with.  This is for revalidating fetchers where the route was
+    // removed during HMR
+
+    if (!match) {
+      continue;
+    }
+
     let currentMatch = currentMatches.find(m => m.route.id === match.route.id);
     let isRevalidatingLoader = currentMatch != null && !isNewRouteInstance(currentMatch, match) && (currentLoaderData && currentLoaderData[match.route.id]) !== undefined;