@remix-run/router 1.0.3 → 1.0.4-pre.1

package/dist/router.cjs.js

@@ -1,5 +1,5 @@
 /**
- * @remix-run/router v1.0.3
+ * @remix-run/router v1.0.4-pre.1
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -113,8 +113,13 @@ function createMemoryHistory(options) {
       return typeof to === "string" ? to : createPath(to);
     },
 
-    encodeLocation(location) {
-      return location;
+    encodeLocation(to) {
+      let path = typeof to === "string" ? parsePath(to) : to;
+      return {
+        pathname: path.pathname || "",
+        search: path.search || "",
+        hash: path.hash || ""
+      };
     },
 
     push(to, state) {
@@ -472,14 +477,14 @@ function getUrlBasedHistory(getLocation, createHref, validateLocation, options)
       return createHref(window, to);
     },
 
-    encodeLocation(location) {
+    encodeLocation(to) {
       // Encode a Location the same way window.location would
-      let url = createURL(createPath(location));
-      return _extends({}, location, {
+      let url = createURL(typeof to === "string" ? to : createPath(to));
+      return {
         pathname: url.pathname,
         search: url.search,
         hash: url.hash
-      });
+      };
     },
 
     push,
@@ -1254,10 +1259,21 @@ const redirect = function redirect(url, init) {
  */
 
 class ErrorResponse {
-  constructor(status, statusText, data) {
+  constructor(status, statusText, data, internal) {
+    if (internal === void 0) {
+      internal = false;
+    }
+
     this.status = status;
     this.statusText = statusText || "";
-    this.data = data;
+    this.internal = internal;
+
+    if (data instanceof Error) {
+      this.data = data.toString();
+      this.error = data;
+    } else {
+      this.data = data;
+    }
   }
 
 }
@@ -1277,6 +1293,12 @@ function isRouteErrorResponse(e) {
  * A Router instance manages all navigation and data loading/mutations
  */
 
+const validActionMethodsArr = ["post", "put", "patch", "delete"];
+const validActionMethods = new Set(validActionMethodsArr);
+const validRequestMethodsArr = ["get", ...validActionMethodsArr];
+const validRequestMethods = new Set(validRequestMethodsArr);
+const redirectStatusCodes = new Set([301, 302, 303, 307, 308]);
+const redirectPreserveMethodStatusCodes = new Set([307, 308]);
 const IDLE_NAVIGATION = {
   state: "idle",
   location: undefined,
@@ -1327,11 +1349,13 @@ function createRouter(init) {
   if (initialMatches == null) {
     // 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, {
+      pathname: init.history.location.pathname
+    });
     let {
       matches,
-      route,
-      error
-    } = getNotFoundMatches(dataRoutes);
+      route
+    } = getShortCircuitMatches(dataRoutes);
     initialMatches = matches;
     initialErrors = {
       [route.id]: error
@@ -1507,7 +1531,7 @@ function createRouter(init) {
     // the same encoding we'd get from a history.pushState/window.location read
     // without having to touch history
 
-    location = init.history.encodeLocation(location);
+    location = _extends({}, location, init.history.encodeLocation(location));
     let historyAction = (opts && opts.replace) === true || submission != null ? exports.Action.Replace : exports.Action.Push;
     let preventScrollReset = opts && "preventScrollReset" in opts ? opts.preventScrollReset === true : undefined;
     return await startNavigation(historyAction, location, {
@@ -1571,11 +1595,13 @@ function createRouter(init) {
     let matches = matchRoutes(dataRoutes, location, init.basename); // Short circuit with a 404 on the root error boundary if we match nothing
 
     if (!matches) {
+      let error = getInternalRouterError(404, {
+        pathname: location.pathname
+      });
       let {
         matches: notFoundMatches,
-        route,
-        error
-      } = getNotFoundMatches(dataRoutes); // Cancel all pending deferred on 404s since we don't keep any routes
+        route
+      } = getShortCircuitMatches(dataRoutes); // Cancel all pending deferred on 404s since we don't keep any routes
 
       cancelActiveDeferreds();
       completeNavigation(location, {
@@ -1671,7 +1697,14 @@ function createRouter(init) {
     let actionMatch = getTargetMatch(matches, location);
 
     if (!actionMatch.route.action) {
-      result = getMethodNotAllowedResult(location);
+      result = {
+        type: ResultType.error,
+        error: getInternalRouterError(405, {
+          method: request.method,
+          pathname: location.pathname,
+          routeId: actionMatch.route.id
+        })
+      };
     } else {
       result = await callLoaderOrAction("action", request, actionMatch, matches, router.basename);
 
@@ -1683,12 +1716,7 @@ function createRouter(init) {
     }
 
     if (isRedirectResult(result)) {
-      let redirectNavigation = _extends({
-        state: "loading",
-        location: createLocation(state.location, result.location)
-      }, submission);
-
-      await startRedirectNavigation(result, redirectNavigation, opts && opts.replace);
+      await startRedirectNavigation(state, result, opts && opts.replace === true);
       return {
         shortCircuited: true
       };
@@ -1815,8 +1843,7 @@ function createRouter(init) {
     let redirect = findRedirect(results);
 
     if (redirect) {
-      let redirectNavigation = getLoaderRedirect(state, redirect);
-      await startRedirectNavigation(redirect, redirectNavigation, replace);
+      await startRedirectNavigation(state, redirect, replace);
       return {
         shortCircuited: true
       };
@@ -1862,7 +1889,9 @@ function createRouter(init) {
     let matches = matchRoutes(dataRoutes, href, init.basename);
 
     if (!matches) {
-      setFetcherError(key, routeId, new ErrorResponse(404, "Not Found", null));
+      setFetcherError(key, routeId, getInternalRouterError(404, {
+        pathname: href
+      }));
       return;
     }
 
@@ -1890,9 +1919,11 @@ function createRouter(init) {
     fetchLoadMatches.delete(key);
 
     if (!match.route.action) {
-      let {
-        error
-      } = getMethodNotAllowedResult(path);
+      let error = getInternalRouterError(405, {
+        method: submission.formMethod,
+        pathname: path,
+        routeId: routeId
+      });
       setFetcherError(key, routeId, error);
       return;
     } // Put this fetcher into it's submitting state
@@ -1940,14 +1971,7 @@ function createRouter(init) {
       updateState({
         fetchers: new Map(state.fetchers)
       });
-
-      let redirectNavigation = _extends({
-        state: "loading",
-        location: createLocation(state.location, actionResult.location)
-      }, submission);
-
-      await startRedirectNavigation(actionResult, redirectNavigation);
-      return;
+      return startRedirectNavigation(state, actionResult);
     } // Process any non-redirect errors thrown
 
 
@@ -2021,9 +2045,7 @@ function createRouter(init) {
     let redirect = findRedirect(results);
 
     if (redirect) {
-      let redirectNavigation = getLoaderRedirect(state, redirect);
-      await startRedirectNavigation(redirect, redirectNavigation);
-      return;
+      return startRedirectNavigation(state, redirect);
     } // Process and commit output from loaders
 
 
@@ -2108,8 +2130,7 @@ function createRouter(init) {
 
 
     if (isRedirectResult(result)) {
-      let redirectNavigation = getLoaderRedirect(state, result);
-      await startRedirectNavigation(result, redirectNavigation);
+      await startRedirectNavigation(state, result);
       return;
     } // Process any non-redirect errors thrown
 
@@ -2165,19 +2186,60 @@ function createRouter(init) {
    */
 
 
-  async function startRedirectNavigation(redirect, navigation, replace) {
+  async function startRedirectNavigation(state, redirect, replace) {
     if (redirect.revalidate) {
       isRevalidationRequired = true;
     }
 
-    invariant(navigation.location, "Expected a location on the redirect navigation"); // There's no need to abort on redirects, since we don't detect the
+    let redirectLocation = createLocation(state.location, redirect.location);
+    invariant(redirectLocation, "Expected a location on the redirect navigation");
+
+    if (redirect.external && typeof window !== "undefined" && typeof window.location !== "undefined") {
+      if (replace) {
+        window.location.replace(redirect.location);
+      } else {
+        window.location.assign(redirect.location);
+      }
+
+      return;
+    } // There's no need to abort on redirects, since we don't detect the
     // redirect until the action/loaders have settled
 
+
     pendingNavigationController = null;
     let redirectHistoryAction = replace === true ? exports.Action.Replace : exports.Action.Push;
-    await startNavigation(redirectHistoryAction, navigation.location, {
-      overrideNavigation: navigation
-    });
+    let {
+      formMethod,
+      formAction,
+      formEncType,
+      formData
+    } = state.navigation; // If this was a 307/308 submission we want to preserve the HTTP method and
+    // re-submit the POST/PUT/PATCH/DELETE as a submission navigation to the
+    // redirected location
+
+    if (redirectPreserveMethodStatusCodes.has(redirect.status) && formMethod && isSubmissionMethod(formMethod) && formEncType && formData) {
+      await startNavigation(redirectHistoryAction, redirectLocation, {
+        submission: {
+          formMethod,
+          formAction: redirect.location,
+          formEncType,
+          formData
+        }
+      });
+    } else {
+      // Otherwise, we kick off a new loading navigation, preserving the
+      // submission info for the duration of this navigation
+      await startNavigation(redirectHistoryAction, redirectLocation, {
+        overrideNavigation: {
+          state: "loading",
+          location: redirectLocation,
+          formMethod: formMethod || undefined,
+          formAction: formAction || undefined,
+          formEncType: formEncType || undefined,
+          formData: formData || undefined
+        }
+      });
+    }
   }
 
   async function callLoadersAndMaybeResolveData(currentMatches, matches, matchesToLoad, fetchersToLoad, request) {
@@ -2381,6 +2443,7 @@ function createRouter(init) {
     // Passthrough to history-aware createHref used by useHref so we get proper
     // hash-aware URLs in DOM paths
     createHref: to => init.history.createHref(to),
+    encodeLocation: to => init.history.encodeLocation(to),
     getFetcher,
     deleteFetcher,
     dispose,
@@ -2393,11 +2456,10 @@ function createRouter(init) {
 //#region createStaticHandler
 ////////////////////////////////////////////////////////////////////////////////
 
-const validActionMethods = new Set(["POST", "PUT", "PATCH", "DELETE"]);
-const validRequestMethods = new Set(["GET", "HEAD", ...validActionMethods]);
-function unstable_createStaticHandler(routes) {
+function unstable_createStaticHandler(routes, opts) {
   invariant(routes.length > 0, "You must provide a non-empty routes array to unstable_createStaticHandler");
   let dataRoutes = convertRoutesToDataRoutes(routes);
+  let basename = (opts ? opts.basename : null) || "/";
   /**
    * The query() method is intended for document requests, in which we want to
    * call an optional action and potentially multiple loaders for all nested
@@ -2420,16 +2482,20 @@ function unstable_createStaticHandler(routes) {
 
   async function query(request) {
     let url = new URL(request.url);
+    let method = request.method.toLowerCase();
     let location = createLocation("", createPath(url), null, "default");
-    let matches = matchRoutes(dataRoutes, location);
+    let matches = matchRoutes(dataRoutes, location, basename); // SSR supports HEAD requests while SPA doesn't
 
-    if (!validRequestMethods.has(request.method)) {
+    if (!isValidMethod(method) && method !== "head") {
+      let error = getInternalRouterError(405, {
+        method
+      });
       let {
         matches: methodNotAllowedMatches,
-        route,
-        error
-      } = getMethodNotAllowedMatches(dataRoutes);
+        route
+      } = getShortCircuitMatches(dataRoutes);
       return {
+        basename,
         location,
         matches: methodNotAllowedMatches,
         loaderData: {},
@@ -2442,12 +2508,15 @@ function unstable_createStaticHandler(routes) {
         actionHeaders: {}
       };
     } else if (!matches) {
+      let error = getInternalRouterError(404, {
+        pathname: location.pathname
+      });
       let {
         matches: notFoundMatches,
-        route,
-        error
-      } = getNotFoundMatches(dataRoutes);
+        route
+      } = getShortCircuitMatches(dataRoutes);
       return {
+        basename,
         location,
         matches: notFoundMatches,
         loaderData: {},
@@ -2471,7 +2540,8 @@ function unstable_createStaticHandler(routes) {
 
 
     return _extends({
-      location
+      location,
+      basename
     }, result);
   }
   /**
@@ -2487,35 +2557,42 @@ function unstable_createStaticHandler(routes) {
    * can do proper boundary identification in Remix where a thrown Response
    * must go to the Catch Boundary but a returned Response is happy-path.
    *
-   * One thing to note is that any Router-initiated thrown Response (such as a
-   * 404 or 405) will have a custom X-Remix-Router-Error: "yes" header on it
-   * in order to differentiate from responses thrown from user actions/loaders.
+   * One thing to note is that any Router-initiated Errors that make sense
+   * to associate with a status code will be thrown as an ErrorResponse
+   * instance which include the raw Error, such that the calling context can
+   * serialize the error as they see fit while including the proper response
+   * code.  Examples here are 404 and 405 errors that occur prior to reaching
+   * any user-defined loaders.
    */
 
 
   async function queryRoute(request, routeId) {
     let url = new URL(request.url);
+    let method = request.method.toLowerCase();
     let location = createLocation("", createPath(url), null, "default");
-    let matches = matchRoutes(dataRoutes, location);
+    let matches = matchRoutes(dataRoutes, location, basename); // SSR supports HEAD requests while SPA doesn't
 
-    if (!validRequestMethods.has(request.method)) {
-      throw createRouterErrorResponse(null, {
-        status: 405,
-        statusText: "Method Not Allowed"
+    if (!isValidMethod(method) && method !== "head") {
+      throw getInternalRouterError(405, {
+        method
       });
     } else if (!matches) {
-      throw createRouterErrorResponse(null, {
-        status: 404,
-        statusText: "Not Found"
+      throw getInternalRouterError(404, {
+        pathname: location.pathname
       });
     }
 
     let match = routeId ? matches.find(m => m.route.id === routeId) : getTargetMatch(matches, location);
 
-    if (!match) {
-      throw createRouterErrorResponse(null, {
-        status: 404,
-        statusText: "Not Found"
+    if (routeId && !match) {
+      throw getInternalRouterError(403, {
+        pathname: location.pathname,
+        routeId
+      });
+    } else if (!match) {
+      // This should never hit I don't think?
+      throw getInternalRouterError(404, {
+        pathname: location.pathname
       });
     }
 
@@ -2544,7 +2621,7 @@ function unstable_createStaticHandler(routes) {
     invariant(request.signal, "query()/queryRoute() requests must contain an AbortController signal");
 
     try {
-      if (validActionMethods.has(request.method)) {
+      if (isSubmissionMethod(request.method.toLowerCase())) {
         let result = await submit(request, matches, routeMatch || getTargetMatch(matches, location), routeMatch != null);
         return result;
       }
@@ -2580,17 +2657,22 @@ function unstable_createStaticHandler(routes) {
     let result;
 
     if (!actionMatch.route.action) {
+      let error = getInternalRouterError(405, {
+        method: request.method,
+        pathname: createURL(request.url).pathname,
+        routeId: actionMatch.route.id
+      });
+
       if (isRouteRequest) {
-        throw createRouterErrorResponse(null, {
-          status: 405,
-          statusText: "Method Not Allowed"
-        });
+        throw error;
       }
 
-      result = getMethodNotAllowedResult(request.url);
+      result = {
+        type: ResultType.error,
+        error
+      };
     } else {
-      result = await callLoaderOrAction("action", request, actionMatch, matches, undefined, // Basename not currently supported in static handlers
-      true, isRouteRequest);
+      result = await callLoaderOrAction("action", request, actionMatch, matches, basename, true, isRouteRequest);
 
       if (request.signal.aborted) {
         let method = isRouteRequest ? "queryRoute" : "query";
@@ -2619,20 +2701,7 @@ function unstable_createStaticHandler(routes) {
       // Note: This should only be non-Response values if we get here, since
       // isRouteRequest should throw any Response received in callLoaderOrAction
       if (isErrorResult(result)) {
-        let boundaryMatch = findNearestBoundary(matches, actionMatch.route.id);
-        return {
-          matches: [actionMatch],
-          loaderData: {},
-          actionData: null,
-          errors: {
-            [boundaryMatch.route.id]: result.error
-          },
-          // Note: statusCode + headers are unused here since queryRoute will
-          // return the raw Response or value
-          statusCode: 500,
-          loaderHeaders: {},
-          actionHeaders: {}
-        };
+        throw result.error;
       }
 
       return {
@@ -2681,9 +2750,18 @@ function unstable_createStaticHandler(routes) {
   }
 
   async function loadRouteData(request, matches, routeMatch, pendingActionError) {
-    let isRouteRequest = routeMatch != null;
+    let isRouteRequest = routeMatch != null; // Short circuit if we have no loaders to run (queryRoute())
+
+    if (isRouteRequest && !(routeMatch != null && routeMatch.route.loader)) {
+      throw getInternalRouterError(400, {
+        method: request.method,
+        pathname: createURL(request.url).pathname,
+        routeId: routeMatch == null ? void 0 : routeMatch.route.id
+      });
+    }
+
     let requestMatches = routeMatch ? [routeMatch] : getLoaderMatchesUntilBoundary(matches, Object.keys(pendingActionError || {})[0]);
-    let matchesToLoad = requestMatches.filter(m => m.route.loader); // Short circuit if we have no loaders to run
+    let matchesToLoad = requestMatches.filter(m => m.route.loader); // Short circuit if we have no loaders to run (query())
 
     if (matchesToLoad.length === 0) {
       return {
@@ -2695,8 +2773,7 @@ function unstable_createStaticHandler(routes) {
       };
     }
 
-    let results = await Promise.all([...matchesToLoad.map(match => callLoaderOrAction("loader", request, match, matches, undefined, // Basename not currently supported in static handlers
-    true, isRouteRequest))]);
+    let results = await Promise.all([...matchesToLoad.map(match => callLoaderOrAction("loader", request, match, matches, basename, true, isRouteRequest))]);
 
     if (request.signal.aborted) {
       let method = isRouteRequest ? "queryRoute" : "query";
@@ -2717,14 +2794,6 @@ function unstable_createStaticHandler(routes) {
     });
   }
 
-  function createRouterErrorResponse(body, init) {
-    return new Response(body, _extends({}, init, {
-      headers: _extends({}, init.headers, {
-        "X-Remix-Router-Error": "yes"
-      })
-    }));
-  }
-
   return {
     dataRoutes,
     query,
@@ -2749,9 +2818,14 @@ function getStaticContextFromError(routes, context, error) {
   });
 
   return newContext;
+}
+
+function isSubmissionNavigation(opts) {
+  return opts != null && "formData" in opts;
 } // Normalize navigation options by converting formMethod=GET formData objects to
 // URLSearchParams so they behave identically to links with query params
 
+
 function normalizeNavigateOptions(to, opts, isFetcher) {
   if (isFetcher === void 0) {
     isFetcher = false;
@@ -2759,14 +2833,23 @@ function normalizeNavigateOptions(to, opts, isFetcher) {
 
   let path = typeof to === "string" ? to : createPath(to); // Return location verbatim on non-submission navigations
 
-  if (!opts || !("formMethod" in opts) && !("formData" in opts)) {
+  if (!opts || !isSubmissionNavigation(opts)) {
     return {
       path
     };
+  }
+
+  if (opts.formMethod && !isValidMethod(opts.formMethod)) {
+    return {
+      path,
+      error: getInternalRouterError(405, {
+        method: opts.formMethod
+      })
+    };
   } // Create a Submission on non-GET navigations
 
 
-  if (opts.formMethod != null && opts.formMethod !== "get") {
+  if (opts.formMethod && isSubmissionMethod(opts.formMethod)) {
     return {
       path,
       submission: {
@@ -2776,13 +2859,6 @@ function normalizeNavigateOptions(to, opts, isFetcher) {
         formData: opts.formData
       }
     };
-  } // No formData to flatten for GET submission
-
-
-  if (!opts.formData) {
-    return {
-      path
-    };
   } // Flatten submission onto URLSearchParams for GET submissions
 
 
@@ -2801,31 +2877,13 @@ function normalizeNavigateOptions(to, opts, isFetcher) {
   } catch (e) {
     return {
       path,
-      error: new ErrorResponse(400, "Bad Request", "Cannot submit binary form data using GET")
+      error: getInternalRouterError(400)
     };
   }
 
   return {
     path: createPath(parsedPath)
   };
-}
-
-function getLoaderRedirect(state, redirect) {
-  let {
-    formMethod,
-    formAction,
-    formEncType,
-    formData
-  } = state.navigation;
-  let navigation = {
-    state: "loading",
-    location: createLocation(state.location, redirect.location),
-    formMethod: formMethod || undefined,
-    formAction: formAction || undefined,
-    formEncType: formEncType || undefined,
-    formData: formData || undefined
-  };
-  return navigation;
 } // Filter out all routes below any caught error as they aren't going to
 // render so we don't need to load them
 
@@ -2926,6 +2984,10 @@ function shouldRevalidateLoader(currentLocation, currentMatch, submission, locat
 }
 
 async function callLoaderOrAction(type, request, match, matches, basename, isStaticRequest, isRouteRequest) {
+  if (basename === void 0) {
+    basename = "/";
+  }
+
   if (isStaticRequest === void 0) {
     isStaticRequest = false;
   }
@@ -2951,6 +3013,7 @@ async function callLoaderOrAction(type, request, match, matches, basename, isSta
       request,
       params: match.params
     }), abortPromise]);
+    invariant(result !== undefined, "You defined " + (type === "action" ? "an action" : "a loader") + " for route " + ("\"" + match.route.id + "\" but didn't return anything from your `" + type + "` ") + "function. Please return a value or `null`.");
   } catch (e) {
     resultType = ResultType.error;
     result = e;
@@ -2961,26 +3024,31 @@ async function callLoaderOrAction(type, request, match, matches, basename, isSta
   if (result instanceof Response) {
     let status = result.status; // Process redirects
 
-    if (status >= 300 && status <= 399) {
+    if (redirectStatusCodes.has(status)) {
       let location = result.headers.get("Location");
-      invariant(location, "Redirects returned/thrown from loaders/actions must have a Location header"); // Support relative routing in redirects
+      invariant(location, "Redirects returned/thrown from loaders/actions must have a Location header"); // Check if this an external redirect that goes to a new origin
 
-      let activeMatches = matches.slice(0, matches.indexOf(match) + 1);
-      let routePathnames = getPathContributingMatches(activeMatches).map(match => match.pathnameBase);
-      let requestPath = createURL(request.url).pathname;
-      let resolvedLocation = resolveTo(location, routePathnames, requestPath);
-      invariant(createPath(resolvedLocation), "Unable to resolve redirect location: " + result.headers.get("Location")); // Prepend the basename to the redirect location if we have one
+      let external = createURL(location).origin !== createURL("/").origin; // Support relative routing in internal redirects
 
-      if (basename) {
-        let path = resolvedLocation.pathname;
-        resolvedLocation.pathname = path === "/" ? basename : joinPaths([basename, path]);
-      }
+      if (!external) {
+        let activeMatches = matches.slice(0, matches.indexOf(match) + 1);
+        let routePathnames = getPathContributingMatches(activeMatches).map(match => match.pathnameBase);
+        let requestPath = createURL(request.url).pathname;
+        let resolvedLocation = resolveTo(location, routePathnames, requestPath);
+        invariant(createPath(resolvedLocation), "Unable to resolve redirect location: " + location); // Prepend the basename to the redirect location if we have one
+
+        if (basename) {
+          let path = resolvedLocation.pathname;
+          resolvedLocation.pathname = path === "/" ? basename : joinPaths([basename, path]);
+        }
 
-      location = createPath(resolvedLocation); // Don't process redirects in the router during static requests requests.
+        location = createPath(resolvedLocation);
+      } // Don't process redirects in the router during static requests requests.
       // Instead, throw the Response and let the server handle it with an HTTP
       // redirect.  We also update the Location header in place in this flow so
       // basename and relative routing is taken into account
 
+
       if (isStaticRequest) {
         result.headers.set("Location", location);
         throw result;
@@ -2990,7 +3058,8 @@ async function callLoaderOrAction(type, request, match, matches, basename, isSta
         type: ResultType.redirect,
         status,
         location,
-        revalidate: result.headers.get("X-Remix-Revalidate") !== null
+        revalidate: result.headers.get("X-Remix-Revalidate") !== null,
+        external
       };
     } // For SSR single-route requests, we want to hand Responses back directly
     // without unwrapping.  We do this with the QueryRouteResponse wrapper
@@ -3218,10 +3287,10 @@ function findNearestBoundary(matches, routeId) {
   return eligibleMatches.reverse().find(m => m.route.hasErrorBoundary === true) || matches[0];
 }
 
-function getShortCircuitMatches(routes, status, statusText) {
+function getShortCircuitMatches(routes) {
   // Prefer a root layout route if present, otherwise shim in a route object
   let route = routes.find(r => r.index || !r.path || r.path === "/") || {
-    id: "__shim-" + status + "-route__"
+    id: "__shim-error-route__"
   };
   return {
     matches: [{
@@ -3230,26 +3299,45 @@ function getShortCircuitMatches(routes, status, statusText) {
       pathnameBase: "",
       route
     }],
-    route,
-    error: new ErrorResponse(status, statusText, null)
+    route
   };
 }
 
-function getNotFoundMatches(routes) {
-  return getShortCircuitMatches(routes, 404, "Not Found");
-}
+function getInternalRouterError(status, _temp) {
+  let {
+    pathname,
+    routeId,
+    method,
+    message
+  } = _temp === void 0 ? {} : _temp;
+  let statusText = "Unknown Server Error";
+  let errorMessage = "Unknown @remix-run/router error";
+
+  if (status === 400) {
+    statusText = "Bad Request";
+
+    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 {
+      errorMessage = "Cannot submit binary form data using GET";
+    }
+  } else if (status === 403) {
+    statusText = "Forbidden";
+    errorMessage = "Route \"" + routeId + "\" does not match URL \"" + pathname + "\"";
+  } else if (status === 404) {
+    statusText = "Not Found";
+    errorMessage = "No route matches URL \"" + pathname + "\"";
+  } else if (status === 405) {
+    statusText = "Method Not Allowed";
 
-function getMethodNotAllowedMatches(routes) {
-  return getShortCircuitMatches(routes, 405, "Method Not Allowed");
-}
+    if (method && pathname && routeId) {
+      errorMessage = "You made a " + method.toUpperCase() + " request to \"" + pathname + "\" but " + ("did not provide an `action` for route \"" + routeId + "\", ") + "so there is no way to handle the request.";
+    } else if (method) {
+      errorMessage = "Invalid request method \"" + method.toUpperCase() + "\"";
+    }
+  }
 
-function getMethodNotAllowedResult(path) {
-  let href = typeof path === "string" ? path : createPath(path);
-  console.warn("You're trying to submit to a route that does not have an action.  To " + "fix this, please add an `action` function to the route for " + ("[" + href + "]"));
-  return {
-    type: ResultType.error,
-    error: new ErrorResponse(405, "Method Not Allowed", "")
-  };
+  return new ErrorResponse(status || 500, statusText, new Error(errorMessage), true);
 } // Find any returned redirect errors, starting from the lowest match
 
 
@@ -3300,6 +3388,14 @@ function isQueryRouteResponse(obj) {
   return obj && obj.response instanceof Response && (obj.type === ResultType.data || ResultType.error);
 }
 
+function isValidMethod(method) {
+  return validRequestMethods.has(method);
+}
+
+function isSubmissionMethod(method) {
+  return validActionMethods.has(method);
+}
+
 async function resolveDeferredResults(currentMatches, matchesToLoad, results, signal, isFetcher, currentLoaderData) {
   for (let index = 0; index < results.length; index++) {
     let result = results[index];