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

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

@@ -2,173 +2,8 @@ import "node:module";
 import { jsx } from "react/jsx-runtime";
 import { useRouter } from "@tanstack/react-router";
 import { useCallback, useRef, useState } from "react";
-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 formDataToUrlSearchParams(formData) {
-    const searchParams = new URLSearchParams();
-    formData.forEach((value, key)=>{
-        if ('string' == typeof value) searchParams.append(key, value);
-    });
-    return searchParams;
-}
-function formDataToTextPlain(formData) {
-    return Array.from(formData.entries()).map(([key, value])=>`${key}=${String(value)}`).join('\n');
-}
-function toFormData(target) {
-    if (target instanceof HTMLFormElement) return new FormData(target);
-    if (target instanceof FormData) return target;
-    if (target instanceof URLSearchParams) {
-        const formData = new FormData();
-        target.forEach((value, key)=>{
-            formData.append(key, value);
-        });
-        return formData;
-    }
-    const formData = new FormData();
-    Object.entries(target).forEach(([key, value])=>{
-        if (null == value) return;
-        formData.append(key, String(value));
-    });
-    return formData;
-}
-function getSubmitter(event) {
-    const nativeEvent = event.nativeEvent;
-    const submitter = nativeEvent?.submitter;
-    if (submitter instanceof HTMLButtonElement || submitter instanceof HTMLInputElement) return submitter;
-    return null;
-}
-function createFormDataFromSubmit({ form, submitter }) {
-    if (submitter) try {
-        return new FormData(form, submitter);
-    } catch  {}
-    return new FormData(form);
-}
-function resolveSubmitOptionsFromForm({ form, submitter, action, method, encType }) {
-    const resolvedAction = submitter?.getAttribute('formaction') || action || form.getAttribute('action') || '.';
-    const resolvedMethod = (submitter?.getAttribute('formmethod') || method || form.getAttribute('method') || 'get').toLowerCase();
-    const resolvedEncType = submitter?.getAttribute('formenctype') || encType || form.getAttribute('enctype') || 'application/x-www-form-urlencoded';
-    return {
-        action: resolvedAction,
-        method: resolvedMethod,
-        encType: resolvedEncType
-    };
-}
-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: search ? `${resolved.href}?${search}` : resolved.href
-        });
-        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;
-}
+import { createFormDataFromSubmit, getSubmitter, resolveSubmitOptionsFromForm } from "./formData.mjs";
+import { RouteActionResponseError, submitRouteAction } from "./submitAction.mjs";
 function Form({ action, method = 'get', encType, reloadDocument, onSubmit, ...rest }) {
     const router = useRouter();
     const handleSubmit = useCallback(async (event)=>{

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

@@ -0,0 +1,64 @@
+import "node:module";
+function formDataToUrlSearchParams(formData) {
+    const searchParams = new URLSearchParams();
+    formData.forEach((value, key)=>{
+        if ('string' == typeof value) searchParams.append(key, value);
+    });
+    return searchParams;
+}
+function formDataToTextPlain(formData) {
+    return Array.from(formData.entries()).map(([key, value])=>`${key}=${String(value)}`).join('\n');
+}
+function toFormData(target) {
+    if (target instanceof HTMLFormElement) return new FormData(target);
+    if (target instanceof FormData) return target;
+    if (target instanceof URLSearchParams) {
+        const formData = new FormData();
+        target.forEach((value, key)=>{
+            formData.append(key, value);
+        });
+        return formData;
+    }
+    const formData = new FormData();
+    Object.entries(target).forEach(([key, value])=>{
+        if (null == value) return;
+        formData.append(key, String(value));
+    });
+    return formData;
+}
+function getSubmitter(event) {
+    const nativeEvent = event.nativeEvent;
+    const submitter = nativeEvent?.submitter;
+    if (submitter instanceof HTMLButtonElement || submitter instanceof HTMLInputElement) return submitter;
+    return null;
+}
+function appendSubmitterValue(formData, form, submitter) {
+    if (submitter.form !== form || submitter.disabled) return;
+    if (submitter instanceof HTMLInputElement && 'image' === submitter.type) {
+        const namePrefix = submitter.name ? `${submitter.name}.` : '';
+        formData.append(`${namePrefix}x`, '0');
+        formData.append(`${namePrefix}y`, '0');
+        return;
+    }
+    if (!submitter.name || 'button' === submitter.type || 'reset' === submitter.type) return;
+    formData.append(submitter.name, submitter.value);
+}
+function createFormDataFromSubmit({ form, submitter }) {
+    if (submitter) try {
+        return new FormData(form, submitter);
+    } catch  {}
+    const formData = new FormData(form);
+    if (submitter) appendSubmitterValue(formData, form, submitter);
+    return formData;
+}
+function resolveSubmitOptionsFromForm({ form, submitter, action, method, encType }) {
+    const resolvedAction = submitter?.getAttribute('formaction') || action || form.getAttribute('action') || '.';
+    const resolvedMethod = (submitter?.getAttribute('formmethod') || method || form.getAttribute('method') || 'get').toLowerCase();
+    const resolvedEncType = submitter?.getAttribute('formenctype') || encType || form.getAttribute('enctype') || 'application/x-www-form-urlencoded';
+    return {
+        action: resolvedAction,
+        method: resolvedMethod,
+        encType: resolvedEncType
+    };
+}
+export { createFormDataFromSubmit, formDataToTextPlain, formDataToUrlSearchParams, getSubmitter, resolveSubmitOptionsFromForm, toFormData };

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

@@ -96,7 +96,10 @@ function modernLoaderToTanstack(opts, modernLoader) {
             const signal = getLoaderSignal(ctx);
             const baseRequest = ctx?.context?.request instanceof Request ? ctx.context.request : void 0;
             const href = getLoaderHref(ctx);
-            const request = void 0 !== baseRequest ? new Request(baseRequest, {
+            const request = void 0 !== baseRequest && '' !== href ? new Request(new URL(href, baseRequest.url).href, {
+                headers: baseRequest.headers,
+                signal
+            }) : void 0 !== baseRequest ? new Request(baseRequest, {
                 signal
             }) : new Request(href, {
                 signal

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

@@ -5,123 +5,18 @@ import { normalizePathname } from "@modern-js/runtime-utils/url";
 import { RouterProvider, createBrowserHistory, createHashHistory, createRouter, useLocation, useNavigate, useRouter } from "@tanstack/react-router";
 import { useContext, useMemo } from "react";
 import { createModernBasepathRewrite } from "./basepathRewrite.mjs";
+import { wrapRouterSubscribeWithBlockState } from "./blockingSubscribe.mjs";
+import { isSegmentPrefix } from "./clientBasepath.mjs";
+import { ModernRouterClient, getTanstackSsrHydrationPromise, hasTanstackSsrHydrationRecord } from "./clientHydration.mjs";
 import { routerProviderRegistryHooks } from "./hooks.mjs";
 import { wrapTanstackSsrHydrationBoundary } from "./hydrationBoundary.mjs";
 import { applyRouterRuntimeState } from "./lifecycle.mjs";
-import { withModernRouteMatchContext } from "./outlet.mjs";
-import { getFinalRouteConfig, getMergedRouterConfig } from "./pluginCore.mjs";
+import { createTanstackRouteObjects, getMergedRouterConfig, getTanstackRouteConfig, joinBasename } from "./pluginShared.mjs";
 import { Link } from "./prefetchLink.mjs";
 import { useMatches } from "./routeHooks.mjs";
 import { createRouteTreeFromRouteObjects } from "./routeTree.mjs";
 import { getTanstackRscSerializationAdapters } from "./rsc/client.mjs";
 import { getModernTanstackRouterFastDefaults } from "./types.mjs";
-import { createRouteObjectsFromConfig, urlJoin } from "./utils.mjs";
-const BLOCKING_SUBSCRIBE_SYMBOL = Symbol.for('@modern-js/plugin-tanstack:blocking-subscribe');
-const BLOCKING_STATE_SYMBOL = Symbol.for('@modern-js/plugin-tanstack:blocking-state');
-function normalizeBase(b) {
-    if (b.length > 1 && b.endsWith('/')) return b.slice(0, -1);
-    return b || '/';
-}
-function isSegmentPrefix(pathname, base) {
-    const b = normalizeBase(base);
-    const p = pathname || '/';
-    return p === b || p.startsWith(`${b}/`);
-}
-function wrapRouterSubscribeWithBlockState(router, getBlockNavState) {
-    if (!router || 'object' != typeof router) return;
-    const target = router;
-    target[BLOCKING_STATE_SYMBOL] = getBlockNavState;
-    if (target[BLOCKING_SUBSCRIBE_SYMBOL] || 'function' != typeof target.subscribe) return;
-    const originSubscribe = target.subscribe.bind(target);
-    target.subscribe = (eventType, listener)=>{
-        const wrappedListener = (...args)=>{
-            const blockRoute = target[BLOCKING_STATE_SYMBOL]?.() || false;
-            if (blockRoute) return;
-            return listener(...args);
-        };
-        return originSubscribe(eventType, wrappedListener);
-    };
-    target[BLOCKING_SUBSCRIBE_SYMBOL] = true;
-}
-const routerHydrationRecords = new WeakMap();
-const routeModulesKey = '_routeModules';
-function pickRouteModuleComponent(routeModule, seen = new Set()) {
-    if ('function' == typeof routeModule || routeModule && 'object' == typeof routeModule && '$$typeof' in routeModule) return routeModule;
-    if (!routeModule || 'object' != typeof routeModule) return;
-    if (seen.has(routeModule)) return;
-    seen.add(routeModule);
-    const module = routeModule;
-    for (const candidate of [
-        module.default,
-        module.Component
-    ]){
-        const component = pickRouteModuleComponent(candidate, seen);
-        if (component) return component;
-    }
-}
-function getCachedRouteModule(routeId) {
-    if ("u" < typeof window) return;
-    return window[routeModulesKey]?.[routeId];
-}
-function preloadHydratedRouteComponents(router) {
-    const preloadableRouter = router;
-    const routesById = preloadableRouter.routesById || {};
-    const matches = preloadableRouter.stores.matches.get();
-    return Promise.all(matches.map((match)=>{
-        if (void 0 === match.routeId || '' === match.routeId) return;
-        const route = routesById[match.routeId];
-        const component = route?.options?.component;
-        const preload = component?.load || component?.preload;
-        if ('function' != typeof preload) return;
-        return Promise.resolve(preload.call(component)).then((routeModule)=>{
-            const modernRouteId = route?.options?.staticData?.modernRouteId;
-            const cachedRouteModule = 'string' == typeof modernRouteId && '' !== modernRouteId ? getCachedRouteModule(modernRouteId) : void 0;
-            const resolvedComponent = pickRouteModuleComponent(cachedRouteModule ?? routeModule);
-            if (void 0 !== resolvedComponent && 'string' == typeof modernRouteId && '' !== modernRouteId) route.options.component = withModernRouteMatchContext(resolvedComponent, modernRouteId);
-        });
-    })).then(()=>void 0);
-}
-function hydrateTanstackRouter(router) {
-    return import("@tanstack/react-router/ssr/client").then(({ hydrate })=>hydrate(router));
-}
-function getTanstackSsrHydrationRecord(router) {
-    const existingHydrationRecord = routerHydrationRecords.get(router);
-    if (void 0 !== existingHydrationRecord) return existingHydrationRecord;
-    const hydrationRecord = {
-        promise: Promise.resolve(),
-        status: 'pending'
-    };
-    routerHydrationRecords.set(router, hydrationRecord);
-    try {
-        hydrationRecord.promise = hydrateTanstackRouter(router).then((value)=>preloadHydratedRouteComponents(router).then(()=>value)).then((value)=>{
-            hydrationRecord.status = 'fulfilled';
-            return value;
-        }, (error)=>{
-            hydrationRecord.status = 'rejected';
-            hydrationRecord.error = error;
-            throw error;
-        });
-    } catch (error) {
-        hydrationRecord.status = 'rejected';
-        hydrationRecord.error = error;
-        hydrationRecord.promise = Promise.reject(error);
-        hydrationRecord.promise.catch(()=>{});
-    }
-    return hydrationRecord;
-}
-function getTanstackSsrHydrationPromise(router) {
-    return getTanstackSsrHydrationRecord(router).promise;
-}
-function hasTanstackSsrHydrationRecord(router) {
-    return routerHydrationRecords.has(router);
-}
-function ModernRouterClient({ router }) {
-    const hydrationRecord = getTanstackSsrHydrationRecord(router);
-    if ('rejected' === hydrationRecord.status) throw hydrationRecord.error;
-    return /*#__PURE__*/ jsx(RouterProvider, {
-        router: router
-    });
-}
 const tanstackRouterPlugin = (userConfig = {})=>{
     const plugin = {
         name: '@modern-js/plugin-router-tanstack',
@@ -135,13 +30,10 @@ const tanstackRouterPlugin = (userConfig = {})=>{
             const getMergedConfig = ()=>getMergedRouterConfig(api, userConfig);
             const getRouteObjects = ()=>{
                 if (void 0 !== cachedRouteObjects) return cachedRouteObjects;
-                const mergedConfig = getMergedConfig();
-                const { createRoutes } = mergedConfig;
-                const finalRouteConfig = getFinalRouteConfig(mergedConfig);
-                const routeObjects = createRoutes ? createRoutes() : createRouteObjectsFromConfig({
-                    routesConfig: finalRouteConfig
-                }) || [];
-                cachedRouteObjects = hooks.modifyRoutes.call(routeObjects);
+                cachedRouteObjects = createTanstackRouteObjects({
+                    hooks,
+                    routeConfig: getTanstackRouteConfig(api, userConfig)
+                });
                 return cachedRouteObjects;
             };
             const getRouteTree = ()=>{
@@ -161,7 +53,7 @@ const tanstackRouterPlugin = (userConfig = {})=>{
             const getClientBasename = (runtimeContext)=>{
                 const { basename = '' } = getMergedConfig();
                 const baseUrl = selectBasePath(location.pathname).replace(/^\/*/, '/');
-                return '/' === baseUrl ? urlJoin(baseUrl, runtimeContext._internalRouterBaseName || basename || '') : baseUrl;
+                return '/' === baseUrl ? joinBasename(baseUrl, runtimeContext._internalRouterBaseName || basename || '') : baseUrl;
             };
             const getRouter = (runtimeContext, _basename)=>{
                 const routeTree = getRouteTree();
@@ -188,8 +80,12 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                 const history = supportHtml5History ? createBrowserHistory() : createHashHistory();
                 const rewrite = createModernBasepathRewrite(_basename);
                 const serializationAdapters = getGlobalEnableRsc() ? getTanstackRscSerializationAdapters() : void 0;
+                const routerFastDefaults = getModernTanstackRouterFastDefaults(mergedConfig);
                 cachedRouter = createRouter({
-                    ...getModernTanstackRouterFastDefaults(mergedConfig),
+                    ...routerFastDefaults,
+                    ...serializationAdapters ? {
+                        defaultStructuralSharing: false
+                    } : {},
                     routeTree,
                     basepath: '/',
                     rewrite,

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

@@ -1,7 +1,7 @@
 import "node:module";
 import { jsx } from "react/jsx-runtime";
 import { InternalRuntimeContext, getGlobalEnableRsc } from "@modern-js/runtime/context";
-import { createRequestContext, storage } from "@modern-js/runtime-utils/node";
+import { createRequestContext } from "@modern-js/runtime-utils/node";
 import { time } from "@modern-js/runtime-utils/time";
 import { LOADER_REPORTER_NAME } from "@modern-js/utils/universal/constants";
 import { RouterProvider, createMemoryHistory, createRouter } from "@tanstack/react-router";
@@ -10,138 +10,43 @@ import { createModernBasepathRewrite } from "./basepathRewrite.mjs";
 import { routerProviderRegistryHooks } from "./hooks.mjs";
 import { wrapTanstackSsrHydrationBoundary } from "./hydrationBoundary.mjs";
 import { applyRouterServerPrepareResult, createRouterServerSnapshot, getRouterRuntimeState } from "./lifecycle.mjs";
-import { getFinalRouteConfig, getMergedRouterConfig } from "./pluginCore.mjs";
+import { createTanstackRouteObjects, getTanstackRouteConfig, joinBasename } from "./pluginShared.mjs";
 import { createRouteTreeFromRouteObjects, getModernRouteIdsFromMatches } from "./routeTree.mjs";
 import { createTanstackRscServerPayload, handleTanstackRscRedirect } from "./rsc/payloadRouter.mjs";
+import { getTanstackRscRouter, setTanstackRscRouter, setTanstackRscServerPayload } from "./rsc/payloadStorage.mjs";
+import { attachServerSsrUtils, collectRouterErrors, createGetSsrHref, routerManagedTagsToHtml, waitForRouterSerialization } from "./ssrManagedTags.mjs";
+import { preloadMatchedRouteComponents } from "./ssrPreload.mjs";
 import { getModernTanstackRouterFastDefaults } from "./types.mjs";
-import { createRouteObjectsFromConfig, urlJoin } from "./utils.mjs";
-const setTanstackRscServerPayload = (payload)=>{
-    const storageContext = storage.useContext?.();
-    if (storageContext) storageContext.serverPayload = payload;
-};
-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) {
-    if (isReactLazyRouteComponent(component)) return void await preloadReactLazyRouteComponent(component);
-    if (!isPreloadableRouteComponent(component)) return;
-    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 || {};
-    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),
-            preloadRouteComponent(options.pendingComponent),
-            preloadRouteComponent(options.errorComponent),
-            preloadRouteComponent(options.notFoundComponent)
-        ]);
-    }));
-}
-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
-    });
-}
 const tanstackRouterPlugin = (userConfig = {})=>{
     const plugin = {
         name: '@modern-js/plugin-router-tanstack',
         registryHooks: routerProviderRegistryHooks,
         setup: (api)=>{
             api.onBeforeRender(async (context, interrupt)=>{
-                const mergedConfig = getMergedRouterConfig(api, userConfig);
+                const routeConfig = getTanstackRouteConfig(api, userConfig);
+                const { mergedConfig } = routeConfig;
                 const serializationAdapters = getGlobalEnableRsc() ? (await import("./rsc/server.mjs")).getTanstackRscSerializationAdapters() : void 0;
                 const enableRsc = getGlobalEnableRsc();
-                const { basename = '', createRoutes } = mergedConfig;
-                const finalRouteConfig = getFinalRouteConfig(mergedConfig);
-                if (!finalRouteConfig.routes && !createRoutes) return;
+                const { basename = '' } = mergedConfig;
+                if (!routeConfig.hasConfiguredRoutes) return;
                 const hooks = api.getHooks();
                 await hooks.onBeforeCreateRoutes.call(context);
-                const routeObjects = createRoutes ? createRoutes() : createRouteObjectsFromConfig({
-                    routesConfig: finalRouteConfig,
+                const modifiedRouteObjects = createTanstackRouteObjects({
+                    hooks,
+                    routeConfig,
                     ssrMode: context.ssrContext?.mode
-                }) || [];
-                const modifiedRouteObjects = hooks.modifyRoutes.call(routeObjects);
+                });
                 if (!modifiedRouteObjects.length) return;
                 const { request, nonce, baseUrl, loaderFailureMode = 'errorBoundary' } = context.ssrContext;
-                const _basename = '/' === baseUrl ? urlJoin(baseUrl, basename || '') : baseUrl;
-                const initialHref = createGetSsrHref(request.raw);
-                const isRSCNavigation = enableRsc && 'true' === request.raw.headers.get('x-rsc-tree');
+                const _basename = '/' === baseUrl ? joinBasename(baseUrl, basename || '') : baseUrl;
+                const rawRequest = request.raw;
+                const initialHref = createGetSsrHref(rawRequest);
+                const isRSCNavigation = enableRsc && 'true' === rawRequest.headers.get('x-rsc-tree');
                 const requestContext = createRequestContext(context.ssrContext?.loaderContext);
                 const controller = new AbortController();
-                const ssrRequest = new Request(request.raw.url, {
+                const ssrRequest = new Request(rawRequest.url, {
                     method: 'GET',
-                    headers: request.raw.headers,
+                    headers: rawRequest.headers,
                     signal: controller.signal
                 });
                 const routerContext = {
@@ -169,7 +74,7 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                     history,
                     basepath: '/',
                     rewrite,
-                    origin: new URL(request.raw.url).origin,
+                    origin: new URL(rawRequest.url).origin,
                     ssr: {
                         nonce
                     },
@@ -179,6 +84,7 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                     } : {}
                 });
                 const serverRouter = tanstackRouter;
+                if (enableRsc) setTanstackRscRouter(serverRouter);
                 await attachServerSsrUtils(serverRouter);
                 const end = time();
                 try {
@@ -198,19 +104,19 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                 }
                 const routerErrors = collectRouterErrors(tanstackRouter);
                 if (routerErrors && 'clientRender' === loaderFailureMode) {
-                    context.ssrContext?.response.status(200);
+                    context.ssrContext?.response?.status(200);
                     try {
                         serverRouter.serverSsr?.cleanup?.();
                     } catch  {}
                     throw Object.values(routerErrors)[0];
                 }
                 await preloadMatchedRouteComponents(serverRouter);
-                context.ssrContext?.response.status(tanstackRouter.state.statusCode);
+                context.ssrContext?.response?.status(tanstackRouter.state.statusCode);
                 await serverRouter.serverSsr?.dehydrate?.();
-                if (isRSCNavigation) {
-                    await waitForRouterSerialization(serverRouter);
+                if (enableRsc) {
+                    if (isRSCNavigation) await waitForRouterSerialization(serverRouter);
                     setTanstackRscServerPayload(createTanstackRscServerPayload(serverRouter, {
-                        omitClientLoaderData: true
+                        omitClientLoaderData: isRSCNavigation
                     }));
                 }
                 const ssrScriptTags = serverRouter.serverSsr?.takeBufferedScripts?.();
@@ -244,7 +150,20 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                 });
             });
             api.wrapRoot((App)=>{
-                const getRouteApp = ()=>(props)=>{
+                const getRouteApp = ()=>{
+                    if (getGlobalEnableRsc()) return (props)=>{
+                        const router = getTanstackRscRouter();
+                        if (!router) return App ? /*#__PURE__*/ jsx(App, {
+                            ...props
+                        }) : null;
+                        const routerWrapper = wrapTanstackSsrHydrationBoundary(/*#__PURE__*/ jsx(RouterProvider, {
+                            router: router
+                        }), true);
+                        return App ? /*#__PURE__*/ jsx(App, {
+                            children: routerWrapper
+                        }) : routerWrapper;
+                    };
+                    return (props)=>{
                         const context = useContext(InternalRuntimeContext);
                         const router = getRouterRuntimeState(context)?.instance;
                         if (!router) return App ? /*#__PURE__*/ jsx(App, {
@@ -257,6 +176,7 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                             children: routerWrapper
                         }) : routerWrapper;
                     };
+                };
                 return getRouteApp();
             });
         }