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

package/dist/router.umd.js

@@ -1,5 +1,5 @@
 /**
- * @remix-run/router v1.0.3
+ * @remix-run/router v1.0.4-pre.1
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -115,8 +115,13 @@
         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) {
@@ -474,14 +479,14 @@
         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,
@@ -1256,10 +1261,21 @@
    */
 
   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;
+      }
     }
 
   }
@@ -1279,6 +1295,12 @@
    * 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,
@@ -1329,11 +1351,13 @@
     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
@@ -1509,7 +1533,7 @@
       // 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, {
@@ -1573,11 +1597,13 @@
       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, {
@@ -1673,7 +1699,14 @@
       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);
 
@@ -1685,12 +1718,7 @@
       }
 
       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
         };
@@ -1817,8 +1845,7 @@
       let redirect = findRedirect(results);
 
       if (redirect) {
-        let redirectNavigation = getLoaderRedirect(state, redirect);
-        await startRedirectNavigation(redirect, redirectNavigation, replace);
+        await startRedirectNavigation(state, redirect, replace);
         return {
           shortCircuited: true
         };
@@ -1864,7 +1891,9 @@
       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;
       }
 
@@ -1892,9 +1921,11 @@
       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
@@ -1942,14 +1973,7 @@
         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
 
 
@@ -2023,9 +2047,7 @@
       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
 
 
@@ -2110,8 +2132,7 @@
 
 
       if (isRedirectResult(result)) {
-        let redirectNavigation = getLoaderRedirect(state, result);
-        await startRedirectNavigation(result, redirectNavigation);
+        await startRedirectNavigation(state, result);
         return;
       } // Process any non-redirect errors thrown
 
@@ -2167,19 +2188,60 @@
      */
 
 
-    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) {
@@ -2383,6 +2445,7 @@
       // 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,
@@ -2395,11 +2458,10 @@
   //#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
@@ -2422,16 +2484,20 @@
 
     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: {},
@@ -2444,12 +2510,15 @@
           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: {},
@@ -2473,7 +2542,8 @@
 
 
       return _extends({
-        location
+        location,
+        basename
       }, result);
     }
     /**
@@ -2489,35 +2559,42 @@
      * 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
         });
       }
 
@@ -2546,7 +2623,7 @@
       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;
         }
@@ -2582,17 +2659,22 @@
       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";
@@ -2621,20 +2703,7 @@
         // 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 {
@@ -2683,9 +2752,18 @@
     }
 
     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 {
@@ -2697,8 +2775,7 @@
         };
       }
 
-      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";
@@ -2719,14 +2796,6 @@
       });
     }
 
-    function createRouterErrorResponse(body, init) {
-      return new Response(body, _extends({}, init, {
-        headers: _extends({}, init.headers, {
-          "X-Remix-Router-Error": "yes"
-        })
-      }));
-    }
-
     return {
       dataRoutes,
       query,
@@ -2751,9 +2820,14 @@
     });
 
     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;
@@ -2761,14 +2835,23 @@
 
     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: {
@@ -2778,13 +2861,6 @@
           formData: opts.formData
         }
       };
-    } // No formData to flatten for GET submission
-
-
-    if (!opts.formData) {
-      return {
-        path
-      };
     } // Flatten submission onto URLSearchParams for GET submissions
 
 
@@ -2803,31 +2879,13 @@
     } 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
 
@@ -2928,6 +2986,10 @@
   }
 
   async function callLoaderOrAction(type, request, match, matches, basename, isStaticRequest, isRouteRequest) {
+    if (basename === void 0) {
+      basename = "/";
+    }
+
     if (isStaticRequest === void 0) {
       isStaticRequest = false;
     }
@@ -2953,6 +3015,7 @@
         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;
@@ -2963,26 +3026,31 @@
     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;
@@ -2992,7 +3060,8 @@
           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
@@ -3220,10 +3289,10 @@
     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: [{
@@ -3232,26 +3301,45 @@
         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
 
 
@@ -3302,6 +3390,14 @@
     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];