@bleedingdev/modern-js-plugin-tanstack 3.5.0-ultramodern.3 → 3.5.0-ultramodern.31

package/dist/esm-node/runtime/rsc/payloadRouter.mjs

@@ -1,77 +1,9 @@
 import "node:module";
-import { isRouteErrorResponse } from "@modern-js/runtime-utils/router";
-import { notFound, redirect } from "@tanstack/react-router";
-const payloadFetchCache = new Map();
-let payloadDecoder;
-function getRouteId(match) {
-    const routeId = match.routeId ?? match.route?.id ?? match.id;
-    return 'string' == typeof routeId ? routeId : void 0;
-}
-function getRouteStaticData(match) {
-    return match.route?.options?.staticData || {};
-}
-function getRouteParentId(match) {
-    const parentId = match.route?.parentRoute?.id;
-    return 'string' == typeof parentId ? parentId : void 0;
-}
-function toRoutePath(match) {
-    const path = match.route?.options?.path;
-    return 'string' == typeof path ? path : void 0;
-}
-function toPayloadRoute(match) {
-    const routeId = getRouteId(match);
-    if (!routeId) return;
-    const staticData = getRouteStaticData(match);
-    const params = match.params && 'object' == typeof match.params ? match.params : {};
-    const pathname = 'string' == typeof match.pathname ? match.pathname : '';
-    return {
-        handle: staticData.modernRouteHandle,
-        hasAction: Boolean(staticData.modernRouteHasAction || staticData.modernRouteAction),
-        hasErrorBoundary: false,
-        hasLoader: Boolean(staticData.modernRouteHasLoader),
-        hasClientLoader: Boolean(staticData.modernRouteHasClientLoader),
-        id: routeId,
-        index: Boolean(match.route?.options?.index) || void 0,
-        params,
-        parentId: getRouteParentId(match),
-        path: toRoutePath(match),
-        pathname,
-        pathnameBase: 'string' == typeof match.pathnameBase ? match.pathnameBase : pathname
-    };
-}
-function shouldRedactServerError(status = 500) {
-    return status >= 500 && 'development' !== process.env.NODE_ENV && 'test' !== process.env.NODE_ENV;
-}
-function serializePayloadError(error) {
-    if (isRouteErrorResponse(error)) {
-        if (shouldRedactServerError(error.status)) return {
-            status: error.status,
-            statusText: 'Internal Server Error',
-            data: 'Unexpected Server Error',
-            __type: 'RouteErrorResponse'
-        };
-        return {
-            ...error,
-            __type: 'RouteErrorResponse'
-        };
-    }
-    if (error instanceof Error) {
-        if (shouldRedactServerError()) return {
-            message: 'Unexpected Server Error',
-            stack: void 0,
-            __type: 'Error'
-        };
-        return {
-            message: error.message,
-            stack: error.stack,
-            __type: 'Error',
-            ...'Error' !== error.name ? {
-                __subType: error.name
-            } : {}
-        };
-    }
-    return error;
-}
+import { notFound } from "@tanstack/react-router";
+import { serializeTanstackRscFlightValues } from "./flightSerialization.mjs";
+import { isSerializedNotFound, serializePayloadError, toRouteErrors, toRouteLoaderData } from "./payloadErrors.mjs";
+import { __setTanstackRscPayloadDecoderForTests, createPayloadFetchKey, fetchTanstackRscPayload, payloadFetchCache } from "./payloadFetch.mjs";
+import { toPayloadRoute, toPlainLocation } from "./payloadRoutes.mjs";
 function createTanstackRscServerPayload(router, options = {}) {
     const matches = Array.isArray(router.state?.matches) ? router.state.matches : [];
     const routes = [];
@@ -81,7 +13,7 @@ function createTanstackRscServerPayload(router, options = {}) {
         const payloadRoute = toPayloadRoute(match);
         if (payloadRoute) {
             routes.push(payloadRoute);
-            if ('loaderData' in match && void 0 !== match.loaderData && !(options.omitClientLoaderData && payloadRoute.hasClientLoader)) loaderData[payloadRoute.id] = match.loaderData;
+            if ('loaderData' in match && void 0 !== match.loaderData && !(options.omitClientLoaderData && payloadRoute.hasClientLoader)) loaderData[payloadRoute.id] = serializeTanstackRscFlightValues(match.loaderData);
             if (void 0 !== match.error) errors[payloadRoute.id] = serializePayloadError(match.error);
         }
     }
@@ -90,14 +22,17 @@ function createTanstackRscServerPayload(router, options = {}) {
         actionData: null,
         errors: Object.keys(errors).length > 0 ? errors : null,
         loaderData,
-        location: router.state?.location,
+        location: toPlainLocation(router.state?.location),
         routes
     };
 }
 function handleTanstackRscRedirect(headers, basename, status) {
     const newHeaders = new Headers(headers);
     let redirectUrl = headers.get('Location') || '/';
-    if ('/' !== basename) redirectUrl = redirectUrl.replace(basename, '') || '/';
+    if ('/' !== basename) {
+        if (redirectUrl === basename) redirectUrl = '/';
+        else if (redirectUrl.startsWith(`${basename}/`)) redirectUrl = redirectUrl.slice(basename.length);
+    }
     newHeaders.set('X-Modernjs-Redirect', redirectUrl);
     newHeaders.set('X-Modernjs-BaseUrl', basename);
     newHeaders.delete('Location');
@@ -109,69 +44,17 @@ function handleTanstackRscRedirect(headers, basename, status) {
 function isTanstackRscPayloadNavigationEnabled() {
     return "u" > typeof window;
 }
-async function decodePayload(stream) {
-    if (payloadDecoder) return payloadDecoder(stream);
-    const runtime = await import("@modern-js/runtime/rsc/client");
-    return runtime.createFromReadableStream(stream);
-}
-function isServerPayload(value) {
-    return Boolean(value) && 'object' == typeof value && 'render' === value.type && Array.isArray(value.routes);
-}
-function createPayloadFetchKey(request) {
-    return request.url;
-}
-function isAbsoluteUrl(value) {
-    try {
-        new URL(value);
-        return true;
-    } catch  {
-        return false;
-    }
-}
-async function fetchTanstackRscPayload(request) {
-    const headers = new Headers(request.headers);
-    headers.set('x-rsc-tree', 'true');
-    const response = await fetch(request.url, {
-        credentials: 'same-origin',
-        headers,
-        method: 'GET',
-        signal: request.signal
-    });
-    const redirectLocation = response.headers.get('X-Modernjs-Redirect');
-    if (redirectLocation) {
-        if (isAbsoluteUrl(redirectLocation)) throw redirect({
-            href: redirectLocation
-        });
-        throw redirect({
-            to: redirectLocation || '/'
-        });
-    }
-    if (404 === response.status && !response.body) throw notFound();
-    if (!response.body) throw new Error('TanStack RSC payload response body is null.');
-    const payload = await decodePayload(response.body);
-    if (!isServerPayload(payload)) throw new Error('Unexpected TanStack RSC payload type.');
-    return payload;
-}
 function loadTanstackRscPayload(request) {
     const key = createPayloadFetchKey(request);
     let payloadPromise = payloadFetchCache.get(key);
     if (!payloadPromise) {
         payloadPromise = fetchTanstackRscPayload(request).finally(()=>{
-            payloadFetchCache.delete(key);
+            payloadFetchCache["delete"](key);
         });
         payloadFetchCache.set(key, payloadPromise);
     }
     return payloadPromise;
 }
-function isSerializedNotFound(value) {
-    return Boolean(value) && 'object' == typeof value && true === value.isNotFound;
-}
-function toRouteErrors(payload) {
-    return payload.errors && 'object' == typeof payload.errors ? payload.errors : {};
-}
-function toRouteLoaderData(payload) {
-    return payload.loaderData && 'object' == typeof payload.loaderData ? payload.loaderData : {};
-}
 async function loadTanstackRscRouteData({ hasClientLoader, loadClientData, request, routeId }) {
     if (hasClientLoader) return loadClientData();
     if (!routeId) return loadClientData();
@@ -190,8 +73,4 @@ async function loadTanstackRscRouteData({ hasClientLoader, loadClientData, reque
     const payloadRoute = payload.routes.find((route)=>route.id === routeId);
     if (payloadRoute && payloadRoute.hasClientLoader) return loadClientData();
 }
-function __setTanstackRscPayloadDecoderForTests(decoder) {
-    payloadDecoder = decoder;
-    payloadFetchCache.clear();
-}
 export { __setTanstackRscPayloadDecoderForTests, createTanstackRscServerPayload, handleTanstackRscRedirect, isTanstackRscPayloadNavigationEnabled, loadTanstackRscPayload, loadTanstackRscRouteData };

package/dist/esm-node/runtime/rsc/payloadRoutes.mjs

@@ -0,0 +1,51 @@
+import "node:module";
+function toPlainRecord(value) {
+    if (!value || 'object' != typeof value) return {};
+    return Object.fromEntries(Object.entries(value));
+}
+function toPlainLocation(location) {
+    if (!location || 'object' != typeof location) return location;
+    const plainLocation = toPlainRecord(location);
+    for (const key of [
+        'search',
+        'state'
+    ])if (plainLocation[key] && 'object' == typeof plainLocation[key] && !Array.isArray(plainLocation[key])) plainLocation[key] = toPlainRecord(plainLocation[key]);
+    return plainLocation;
+}
+function getRouteId(match) {
+    const routeId = match.routeId ?? match.route?.id ?? match.id;
+    return 'string' == typeof routeId ? routeId : void 0;
+}
+function getRouteStaticData(match) {
+    return match.route?.options?.staticData || {};
+}
+function getRouteParentId(match) {
+    const parentId = match.route?.parentRoute?.id;
+    return 'string' == typeof parentId ? parentId : void 0;
+}
+function toRoutePath(match) {
+    const path = match.route?.options?.path;
+    return 'string' == typeof path ? path : void 0;
+}
+function toPayloadRoute(match) {
+    const routeId = getRouteId(match);
+    if (!routeId) return;
+    const staticData = getRouteStaticData(match);
+    const params = match.params && 'object' == typeof match.params ? toPlainRecord(match.params) : {};
+    const pathname = 'string' == typeof match.pathname ? match.pathname : '';
+    return {
+        handle: staticData.modernRouteHandle,
+        hasAction: Boolean(staticData.modernRouteHasAction || staticData.modernRouteAction),
+        hasErrorBoundary: false,
+        hasLoader: Boolean(staticData.modernRouteHasLoader),
+        hasClientLoader: Boolean(staticData.modernRouteHasClientLoader),
+        id: routeId,
+        index: Boolean(match.route?.options?.index) || void 0,
+        params,
+        parentId: getRouteParentId(match),
+        path: toRoutePath(match),
+        pathname,
+        pathnameBase: 'string' == typeof match.pathnameBase ? match.pathnameBase : pathname
+    };
+}
+export { getRouteId, getRouteParentId, getRouteStaticData, toPayloadRoute, toPlainLocation, toPlainRecord, toRoutePath };

package/dist/esm-node/runtime/rsc/payloadStorage.mjs

@@ -0,0 +1,15 @@
+import "node:module";
+import { storage } from "@modern-js/runtime-utils/node";
+const setTanstackRscServerPayload = (payload)=>{
+    const storageContext = storage.useContext?.();
+    if (storageContext) storageContext.serverPayload = payload;
+};
+const setTanstackRscRouter = (router)=>{
+    const storageContext = storage.useContext?.();
+    if (storageContext) storageContext.tanstackRscRouter = router;
+};
+const getTanstackRscRouter = ()=>{
+    const storageContext = storage.useContext?.();
+    return storageContext?.tanstackRscRouter;
+};
+export { getTanstackRscRouter, setTanstackRscRouter, setTanstackRscServerPayload };

package/dist/esm-node/runtime/rsc/server.mjs

@@ -1,27 +1,12 @@
 import "node:module";
 import { Fragment, jsx } from "react/jsx-runtime";
-import { createFromReadableStream, renderRsc } from "@modern-js/runtime/rsc/server";
-import { createSerializationAdapter } from "@tanstack/react-router";
-import { RawStream } from "@tanstack/router-core";
-import { createElement, use } from "react";
+import { renderRsc } from "@modern-js/runtime/rsc/server";
+import { RawStream, createSerializationAdapter } from "@tanstack/router-core";
+import { createElement } from "react";
 import { ClientSlot } from "./ClientSlot.mjs";
-import { createRscProxy } from "./createRscProxy.mjs";
 import { ReplayableStream } from "./ReplayableStream.mjs";
 import { sanitizeSlotArgs } from "./slotUsageSanitizer.mjs";
-import { RSC_SLOT_USAGES_STREAM, SERVER_COMPONENT_STREAM, isRenderableServerComponent, isServerComponent } from "./symbols.mjs";
-function createTreeGetter(stream) {
-    let ready = false;
-    let tree;
-    const treePromise = Promise.resolve(createFromReadableStream(stream.createReplayStream())).then((value)=>{
-        tree = value;
-        ready = true;
-        return value;
-    });
-    return ()=>{
-        if (ready) return tree;
-        return use(treePromise);
-    };
-}
+import { RENDERABLE_RSC, RSC_SLOT_USAGES_STREAM, SERVER_COMPONENT_STREAM, isRenderableServerComponent, isServerComponent } from "./symbols.mjs";
 function createSlotProxy(options) {
     const cache = new Map();
     return new Proxy({}, {
@@ -45,6 +30,17 @@ function createSlotProxy(options) {
         }
     });
 }
+function createServerRscValue(options) {
+    return {
+        [SERVER_COMPONENT_STREAM]: options.stream,
+        ...options.renderable ? {
+            [RENDERABLE_RSC]: true
+        } : {},
+        ...options.slotUsagesStream ? {
+            [RSC_SLOT_USAGES_STREAM]: options.slotUsagesStream
+        } : {}
+    };
+}
 function toReplayableFlightStream(node, handlers) {
     const flightStream = renderRsc({
         element: node
@@ -58,7 +54,7 @@ async function renderServerComponent(node) {
     const streamWrapper = {
         createReplayStream: ()=>stream.createReplayStream()
     };
-    return createRscProxy(createTreeGetter(streamWrapper), {
+    return createServerRscValue({
         renderable: true,
         stream: streamWrapper
     });
@@ -87,7 +83,7 @@ async function createCompositeComponent(component) {
     const streamWrapper = {
         createReplayStream: ()=>flightStream.createReplayStream()
     };
-    return createRscProxy(createTreeGetter(streamWrapper), {
+    return createServerRscValue({
         renderable: false,
         slotUsagesStream: slotUsagesEmitter?.stream,
         stream: streamWrapper

package/dist/esm-node/runtime/rsc/shared.mjs

@@ -0,0 +1,22 @@
+import "node:module";
+import { RSC_PROXY_GET_TREE, RSC_PROXY_PATH } from "./symbols.mjs";
+const TANSTACK_RSC_FLIGHT_VALUE = '__modernTanstackRsc';
+function isSerializedTanstackRscFlightValue(value) {
+    return Boolean(value) && 'object' == typeof value && true === value[TANSTACK_RSC_FLIGHT_VALUE] && ('renderable' === value.kind || 'composite' === value.kind) && value.stream instanceof ReadableStream;
+}
+function EmptyFallback() {
+    return null;
+}
+function selectTreePath(tree, path) {
+    let current = tree;
+    for (const key of path){
+        if (null === current || 'object' != typeof current) return null;
+        current = current[key];
+    }
+    return current;
+}
+function renderSelectedTree(src, { getTree = src[RSC_PROXY_GET_TREE], missingTreeError }) {
+    if (!getTree) throw new Error(missingTreeError);
+    return selectTreePath(getTree(), src[RSC_PROXY_PATH] || []);
+}
+export { EmptyFallback, TANSTACK_RSC_FLIGHT_VALUE, isSerializedTanstackRscFlightValue, renderSelectedTree, selectTreePath };

package/dist/esm-node/runtime/rsc/treeGetter.mjs

@@ -0,0 +1,35 @@
+import "node:module";
+"use client";
+import { use } from "react";
+let modernRscClientRuntimePromise;
+function loadModernRscClientRuntime() {
+    modernRscClientRuntimePromise ??= import("@modern-js/runtime/rsc/client").then((runtime)=>{
+        runtime.setServerCallback(runtime.callServer);
+        return runtime;
+    });
+    return modernRscClientRuntimePromise;
+}
+async function createFromFlightStream(stream) {
+    if ("u" < typeof window) {
+        const runtime = await import("react-server-dom-rspack/client.edge");
+        return runtime.createFromReadableStream(stream);
+    }
+    const runtime = await loadModernRscClientRuntime();
+    return runtime.createFromReadableStream(stream, {
+        callServer: runtime.callServer
+    });
+}
+function createTreeGetterFromFlightStream(stream) {
+    let ready = false;
+    let tree;
+    const treePromise = createFromFlightStream(stream).then((value)=>{
+        tree = value;
+        ready = true;
+        return value;
+    });
+    return ()=>{
+        if (ready) return tree;
+        return use(treePromise);
+    };
+}
+export { createTreeGetterFromFlightStream };

package/dist/esm-node/runtime/ssrManagedTags.mjs

@@ -0,0 +1,54 @@
+import "node:module";
+async function waitForRouterSerialization(tanstackRouter) {
+    const serverSsr = tanstackRouter.serverSsr;
+    if (!serverSsr || 'function' != typeof serverSsr.onSerializationFinished || serverSsr.isSerializationFinished?.()) return;
+    await new Promise((resolve)=>{
+        serverSsr.onSerializationFinished?.(resolve);
+    });
+}
+function htmlEscapeAttr(value) {
+    return value.replace(/&/g, '&').replace(/"/g, '"');
+}
+function routerManagedTagToHtml(tag) {
+    if (!tag || 'object' != typeof tag) return '';
+    const managedTag = tag;
+    if (!managedTag || "script" !== managedTag.tag) return '';
+    const attrs = managedTag.attrs || {};
+    const attrsStr = Object.entries(attrs).filter(([, v])=>null != v && false !== v).map(([k, v])=>{
+        const name = 'className' === k ? 'class' : k;
+        if (true === v) return name;
+        return `${name}="${htmlEscapeAttr(String(v))}"`;
+    }).join(' ');
+    const open = attrsStr.length ? `<script ${attrsStr}>` : "<script>";
+    const children = 'string' == typeof managedTag.children ? managedTag.children : '';
+    return `${open}${children}</script>`;
+}
+function routerManagedTagsToHtml(tags) {
+    const normalizedTags = Array.isArray(tags) ? tags : [
+        tags
+    ];
+    return normalizedTags.map(routerManagedTagToHtml).filter(Boolean);
+}
+function createGetSsrHref(request) {
+    const url = new URL(request.url);
+    return `${url.pathname}${url.search}${url.hash}`;
+}
+function collectRouterErrors(tanstackRouter) {
+    const state = tanstackRouter.state;
+    const matches = Array.isArray(state.matches) ? state.matches : [];
+    const errors = matches.reduce((acc, match)=>{
+        if (!match.error) return acc;
+        const routeId = 'string' == typeof match.routeId ? match.routeId : 'string' == typeof match.route?.id ? match.route.id : `match-${Object.keys(acc).length}`;
+        acc[routeId] = match.error;
+        return acc;
+    }, {});
+    return Object.keys(errors).length > 0 ? errors : void 0;
+}
+async function attachServerSsrUtils(router) {
+    const { attachRouterServerSsrUtils } = await import("@tanstack/router-core/ssr/server");
+    attachRouterServerSsrUtils({
+        router,
+        manifest: void 0
+    });
+}
+export { attachServerSsrUtils, collectRouterErrors, createGetSsrHref, routerManagedTagsToHtml, waitForRouterSerialization };

package/dist/esm-node/runtime/ssrPreload.mjs

@@ -0,0 +1,52 @@
+import "node:module";
+function isPromiseLike(value) {
+    return Boolean(value && 'function' == typeof value.then);
+}
+function isPreloadableRouteComponent(component) {
+    if (!component || 'function' != typeof component) return false;
+    const preloadable = component;
+    return 'function' == typeof preloadable.load || 'function' == typeof preloadable.preload;
+}
+function isReactLazyRouteComponent(component) {
+    return null != component && 'object' == typeof component && 'function' == typeof component._init && '_payload' in component;
+}
+async function preloadReactLazyRouteComponent(component) {
+    try {
+        component._init?.(component._payload);
+    } catch (thrown) {
+        if (!isPromiseLike(thrown)) throw thrown;
+        await thrown;
+        component._init?.(component._payload);
+    }
+}
+async function preloadRouteComponent(component, preloadedComponents) {
+    if (isReactLazyRouteComponent(component)) {
+        if (preloadedComponents.has(component)) return;
+        preloadedComponents.add(component);
+        await preloadReactLazyRouteComponent(component);
+        return;
+    }
+    if (!isPreloadableRouteComponent(component)) return;
+    if (preloadedComponents.has(component)) return;
+    preloadedComponents.add(component);
+    if ('function' == typeof component.load) return void await component.load({});
+    await component.preload?.({});
+}
+async function preloadMatchedRouteComponents(tanstackRouter) {
+    const matches = Array.isArray(tanstackRouter.state.matches) ? tanstackRouter.state.matches : [];
+    const routesById = tanstackRouter.routesById || {};
+    const preloadedComponents = new Set();
+    await Promise.all(matches.map(async (match)=>{
+        const routeId = 'string' == typeof match.routeId ? match.routeId : 'string' == typeof match.route?.id ? match.route.id : void 0;
+        const route = routeId ? routesById[routeId] : match.route;
+        const options = route?.options;
+        if (!options) return;
+        await Promise.all([
+            preloadRouteComponent(options.component, preloadedComponents),
+            preloadRouteComponent(options.pendingComponent, preloadedComponents),
+            preloadRouteComponent(options.errorComponent, preloadedComponents),
+            preloadRouteComponent(options.notFoundComponent, preloadedComponents)
+        ]);
+    }));
+}
+export { preloadMatchedRouteComponents };

package/dist/esm-node/runtime/ssrTypes.mjs

@@ -0,0 +1 @@
+import "node:module";

package/dist/esm-node/runtime/submitAction.mjs

@@ -0,0 +1,121 @@
+import "node:module";
+import { formDataToTextPlain, formDataToUrlSearchParams, toFormData } from "./formData.mjs";
+class RouteActionResponseError extends Error {
+    constructor(response, data){
+        super(`Route action failed with status ${response.status}`);
+        this.name = 'RouteActionResponseError';
+        this.response = response;
+        this.data = data;
+    }
+}
+function resolveRouteHandlers(router, actionTo) {
+    const builtLocation = router.buildLocation({
+        to: actionTo
+    });
+    const href = router.getParsedLocationHref(builtLocation);
+    const matchedRoutes = router.getMatchedRoutes(builtLocation.pathname);
+    const routeStaticData = matchedRoutes.foundRoute?.options?.staticData;
+    const action = routeStaticData?.modernRouteAction;
+    const loader = routeStaticData?.modernRouteLoader;
+    return {
+        action,
+        loader,
+        href,
+        params: matchedRoutes.routeParams || {}
+    };
+}
+function isRedirectResponse(value) {
+    if (!(value instanceof Response)) return false;
+    return [
+        301,
+        302,
+        303,
+        307,
+        308
+    ].includes(value.status);
+}
+async function parseResponseData(response) {
+    if (204 === response.status) return null;
+    const contentType = response.headers.get('Content-Type') || '';
+    if (contentType.includes('application/json')) return response.json();
+    return response.text();
+}
+async function parseResponseResultOrThrow(response) {
+    const parsed = await parseResponseData(response);
+    if (!response.ok) throw new RouteActionResponseError(response, parsed);
+    return parsed;
+}
+async function submitRouteAction({ router, target, options = {}, isFetcher = false, onInvalidateStart }) {
+    const method = (options.method || 'post').toLowerCase();
+    const encType = options.encType || 'application/x-www-form-urlencoded';
+    const actionTo = options.action || '.';
+    const formData = toFormData(target);
+    const resolved = resolveRouteHandlers(router, actionTo);
+    if ('get' === method) {
+        const search = formDataToUrlSearchParams(formData).toString();
+        const requestUrl = new URL(resolved.href, window.location.origin);
+        requestUrl.search = search;
+        if (isFetcher && resolved.loader) {
+            const result = await resolved.loader({
+                request: new Request(requestUrl, {
+                    method: 'GET'
+                }),
+                params: resolved.params
+            });
+            if (result instanceof Response) {
+                const redirectTo = result.headers.get('X-Modernjs-Redirect') || result.headers.get('Location');
+                if (redirectTo || isRedirectResponse(result)) {
+                    await router.navigate({
+                        to: redirectTo || '/'
+                    });
+                    return parseResponseData(result);
+                }
+                return parseResponseResultOrThrow(result);
+            }
+            return result;
+        }
+        await router.navigate({
+            href: `${requestUrl.pathname}${requestUrl.search}${requestUrl.hash}`
+        });
+        return;
+    }
+    if (!resolved.action) throw new Error(`No route action found for "${actionTo}"`);
+    const headers = new Headers();
+    let body = null;
+    if (encType.includes('application/json')) {
+        headers.set('Content-Type', 'application/json');
+        body = JSON.stringify(Object.fromEntries(formDataToUrlSearchParams(formData).entries()));
+    } else if (encType.includes('text/plain')) {
+        headers.set('Content-Type', 'text/plain;charset=UTF-8');
+        body = formDataToTextPlain(formData);
+    } else if (encType.includes('application/x-www-form-urlencoded')) {
+        headers.set('Content-Type', 'application/x-www-form-urlencoded;charset=UTF-8');
+        body = formDataToUrlSearchParams(formData);
+    } else body = formData;
+    const request = new Request(new URL(resolved.href, window.location.origin), {
+        method: method.toUpperCase(),
+        headers,
+        body
+    });
+    const result = await resolved.action({
+        request,
+        params: resolved.params
+    });
+    if (result instanceof Response) {
+        const redirectTo = result.headers.get('X-Modernjs-Redirect') || result.headers.get('Location');
+        if (redirectTo || isRedirectResponse(result)) {
+            await router.navigate({
+                to: redirectTo || '/'
+            });
+            return parseResponseData(result);
+        }
+        const parsed = isFetcher ? await parseResponseResultOrThrow(result) : await parseResponseData(result);
+        onInvalidateStart?.();
+        await router.invalidate();
+        return parsed;
+    }
+    onInvalidateStart?.();
+    await router.invalidate();
+    return result;
+}
+export { RouteActionResponseError, submitRouteAction };