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

package/dist/cjs/runtime/plugin.js

@@ -37,123 +37,18 @@ const url_namespaceObject = require("@modern-js/runtime-utils/url");
 const react_router_namespaceObject = require("@tanstack/react-router");
 const external_react_namespaceObject = require("react");
 const external_basepathRewrite_js_namespaceObject = require("./basepathRewrite.js");
+const external_blockingSubscribe_js_namespaceObject = require("./blockingSubscribe.js");
+const external_clientBasepath_js_namespaceObject = require("./clientBasepath.js");
+const external_clientHydration_js_namespaceObject = require("./clientHydration.js");
 const external_hooks_js_namespaceObject = require("./hooks.js");
 const external_hydrationBoundary_js_namespaceObject = require("./hydrationBoundary.js");
 const external_lifecycle_js_namespaceObject = require("./lifecycle.js");
-const external_outlet_js_namespaceObject = require("./outlet.js");
-const external_pluginCore_js_namespaceObject = require("./pluginCore.js");
+const external_pluginShared_js_namespaceObject = require("./pluginShared.js");
 const external_prefetchLink_js_namespaceObject = require("./prefetchLink.js");
 const external_routeHooks_js_namespaceObject = require("./routeHooks.js");
 const external_routeTree_js_namespaceObject = require("./routeTree.js");
 const client_js_namespaceObject = require("./rsc/client.js");
 const external_types_js_namespaceObject = require("./types.js");
-const external_utils_js_namespaceObject = require("./utils.js");
-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 = (0, external_outlet_js_namespaceObject.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__*/ (0, jsx_runtime_namespaceObject.jsx)(react_router_namespaceObject.RouterProvider, {
-        router: router
-    });
-}
 const tanstackRouterPlugin = (userConfig = {})=>{
     const plugin = {
         name: '@modern-js/plugin-router-tanstack',
@@ -164,16 +59,13 @@ const tanstackRouterPlugin = (userConfig = {})=>{
             let cachedRouteTree = null;
             let cachedRouter = null;
             let cachedRouterBasepath = null;
-            const getMergedConfig = ()=>(0, external_pluginCore_js_namespaceObject.getMergedRouterConfig)(api, userConfig);
+            const getMergedConfig = ()=>(0, external_pluginShared_js_namespaceObject.getMergedRouterConfig)(api, userConfig);
             const getRouteObjects = ()=>{
                 if (void 0 !== cachedRouteObjects) return cachedRouteObjects;
-                const mergedConfig = getMergedConfig();
-                const { createRoutes } = mergedConfig;
-                const finalRouteConfig = (0, external_pluginCore_js_namespaceObject.getFinalRouteConfig)(mergedConfig);
-                const routeObjects = createRoutes ? createRoutes() : (0, external_utils_js_namespaceObject.createRouteObjectsFromConfig)({
-                    routesConfig: finalRouteConfig
-                }) || [];
-                cachedRouteObjects = hooks.modifyRoutes.call(routeObjects);
+                cachedRouteObjects = (0, external_pluginShared_js_namespaceObject.createTanstackRouteObjects)({
+                    hooks,
+                    routeConfig: (0, external_pluginShared_js_namespaceObject.getTanstackRouteConfig)(api, userConfig)
+                });
                 return cachedRouteObjects;
             };
             const getRouteTree = ()=>{
@@ -187,13 +79,13 @@ const tanstackRouterPlugin = (userConfig = {})=>{
             };
             const selectBasePath = (pathname)=>{
                 const { serverBase = [] } = getMergedConfig();
-                const match = serverBase.find((baseUrl)=>isSegmentPrefix(pathname, baseUrl));
+                const match = serverBase.find((baseUrl)=>(0, external_clientBasepath_js_namespaceObject.isSegmentPrefix)(pathname, baseUrl));
                 return match || '/';
             };
             const getClientBasename = (runtimeContext)=>{
                 const { basename = '' } = getMergedConfig();
                 const baseUrl = selectBasePath(location.pathname).replace(/^\/*/, '/');
-                return '/' === baseUrl ? (0, external_utils_js_namespaceObject.urlJoin)(baseUrl, runtimeContext._internalRouterBaseName || basename || '') : baseUrl;
+                return '/' === baseUrl ? (0, external_pluginShared_js_namespaceObject.joinBasename)(baseUrl, runtimeContext._internalRouterBaseName || basename || '') : baseUrl;
             };
             const getRouter = (runtimeContext, _basename)=>{
                 const routeTree = getRouteTree();
@@ -207,7 +99,7 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                 };
                 hooks.onBeforeCreateRouter.call(lifecycleContext);
                 if (cachedRouter && cachedRouterBasepath === _basename) {
-                    wrapRouterSubscribeWithBlockState(cachedRouter, runtimeContext.unstable_getBlockNavState);
+                    (0, external_blockingSubscribe_js_namespaceObject.wrapRouterSubscribeWithBlockState)(cachedRouter, runtimeContext.unstable_getBlockNavState);
                     hooks.onAfterCreateRouter.call({
                         ...lifecycleContext,
                         router: cachedRouter,
@@ -220,8 +112,12 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                 const history = supportHtml5History ? (0, react_router_namespaceObject.createBrowserHistory)() : (0, react_router_namespaceObject.createHashHistory)();
                 const rewrite = (0, external_basepathRewrite_js_namespaceObject.createModernBasepathRewrite)(_basename);
                 const serializationAdapters = (0, context_namespaceObject.getGlobalEnableRsc)() ? (0, client_js_namespaceObject.getTanstackRscSerializationAdapters)() : void 0;
+                const routerFastDefaults = (0, external_types_js_namespaceObject.getModernTanstackRouterFastDefaults)(mergedConfig);
                 cachedRouter = (0, react_router_namespaceObject.createRouter)({
-                    ...(0, external_types_js_namespaceObject.getModernTanstackRouterFastDefaults)(mergedConfig),
+                    ...routerFastDefaults,
+                    ...serializationAdapters ? {
+                        defaultStructuralSharing: false
+                    } : {},
                     routeTree,
                     basepath: '/',
                     rewrite,
@@ -232,7 +128,7 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                     } : {}
                 });
                 cachedRouterBasepath = _basename;
-                wrapRouterSubscribeWithBlockState(cachedRouter, runtimeContext.unstable_getBlockNavState);
+                (0, external_blockingSubscribe_js_namespaceObject.wrapRouterSubscribeWithBlockState)(cachedRouter, runtimeContext.unstable_getBlockNavState);
                 hooks.onAfterCreateRouter.call({
                     ...lifecycleContext,
                     router: cachedRouter,
@@ -263,7 +159,7 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                 if (hasSSRBootstrap && getRouteObjects().length > 0) {
                     const runtimeContext = context;
                     const router = getRouter(runtimeContext, getClientBasename(runtimeContext));
-                    if (null != router) return getTanstackSsrHydrationPromise(router).then(()=>void 0);
+                    if (null != router) return (0, external_clientHydration_js_namespaceObject.getTanstackSsrHydrationPromise)(router).then(()=>void 0);
                 }
             });
             api.wrapRoot((App)=>{
@@ -292,7 +188,7 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                         basename: _basename,
                         router
                     };
-                    const hasSSRBootstrap = "u" > typeof window && (Boolean(window.$_TSR) || hasTanstackSsrHydrationRecord(router));
+                    const hasSSRBootstrap = "u" > typeof window && (Boolean(window.$_TSR) || (0, external_clientHydration_js_namespaceObject.hasTanstackSsrHydrationRecord)(router));
                     const needsRouterClient = hasSSRBootstrap;
                     if (needsRouterClient) hooks.onBeforeHydrateRouter.call({
                         ...lifecycleContext,
@@ -300,7 +196,7 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                         router,
                         runtimeContext: runtimeState
                     });
-                    const RouterContent = needsRouterClient ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(ModernRouterClient, {
+                    const RouterContent = needsRouterClient ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_clientHydration_js_namespaceObject.ModernRouterClient, {
                         router: router
                     }) : /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(react_router_namespaceObject.RouterProvider, {
                         router: router

package/dist/cjs/runtime/plugin.node.js

@@ -42,133 +42,37 @@ const external_basepathRewrite_js_namespaceObject = require("./basepathRewrite.j
 const external_hooks_js_namespaceObject = require("./hooks.js");
 const external_hydrationBoundary_js_namespaceObject = require("./hydrationBoundary.js");
 const external_lifecycle_js_namespaceObject = require("./lifecycle.js");
-const external_pluginCore_js_namespaceObject = require("./pluginCore.js");
+const external_pluginShared_js_namespaceObject = require("./pluginShared.js");
 const external_routeTree_js_namespaceObject = require("./routeTree.js");
 const payloadRouter_js_namespaceObject = require("./rsc/payloadRouter.js");
+const payloadStorage_js_namespaceObject = require("./rsc/payloadStorage.js");
+const external_ssrManagedTags_js_namespaceObject = require("./ssrManagedTags.js");
+const external_ssrPreload_js_namespaceObject = require("./ssrPreload.js");
 const external_types_js_namespaceObject = require("./types.js");
-const external_utils_js_namespaceObject = require("./utils.js");
-const setTanstackRscServerPayload = (payload)=>{
-    const storageContext = node_namespaceObject.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: external_hooks_js_namespaceObject.routerProviderRegistryHooks,
         setup: (api)=>{
             api.onBeforeRender(async (context, interrupt)=>{
-                const mergedConfig = (0, external_pluginCore_js_namespaceObject.getMergedRouterConfig)(api, userConfig);
+                const routeConfig = (0, external_pluginShared_js_namespaceObject.getTanstackRouteConfig)(api, userConfig);
+                const { mergedConfig } = routeConfig;
                 const serializationAdapters = (0, context_namespaceObject.getGlobalEnableRsc)() ? (await import("./rsc/server.js")).getTanstackRscSerializationAdapters() : void 0;
                 const enableRsc = (0, context_namespaceObject.getGlobalEnableRsc)();
-                const { basename = '', createRoutes } = mergedConfig;
-                const finalRouteConfig = (0, external_pluginCore_js_namespaceObject.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() : (0, external_utils_js_namespaceObject.createRouteObjectsFromConfig)({
-                    routesConfig: finalRouteConfig,
+                const modifiedRouteObjects = (0, external_pluginShared_js_namespaceObject.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 ? (0, external_utils_js_namespaceObject.urlJoin)(baseUrl, basename || '') : baseUrl;
+                const _basename = '/' === baseUrl ? (0, external_pluginShared_js_namespaceObject.joinBasename)(baseUrl, basename || '') : baseUrl;
                 const rawRequest = request.raw;
-                const initialHref = createGetSsrHref(rawRequest);
+                const initialHref = (0, external_ssrManagedTags_js_namespaceObject.createGetSsrHref)(rawRequest);
                 const isRSCNavigation = enableRsc && 'true' === rawRequest.headers.get('x-rsc-tree');
                 const requestContext = (0, node_namespaceObject.createRequestContext)(context.ssrContext?.loaderContext);
                 const controller = new AbortController();
@@ -212,7 +116,8 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                     } : {}
                 });
                 const serverRouter = tanstackRouter;
-                await attachServerSsrUtils(serverRouter);
+                if (enableRsc) (0, payloadStorage_js_namespaceObject.setTanstackRscRouter)(serverRouter);
+                await (0, external_ssrManagedTags_js_namespaceObject.attachServerSsrUtils)(serverRouter);
                 const end = (0, time_namespaceObject.time)();
                 try {
                     await tanstackRouter.load({
@@ -229,7 +134,7 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                     } catch  {}
                     return interrupt(isRSCNavigation ? (0, payloadRouter_js_namespaceObject.handleTanstackRscRedirect)(resolved.headers, _basename, resolved.status) : resolved);
                 }
-                const routerErrors = collectRouterErrors(tanstackRouter);
+                const routerErrors = (0, external_ssrManagedTags_js_namespaceObject.collectRouterErrors)(tanstackRouter);
                 if (routerErrors && 'clientRender' === loaderFailureMode) {
                     context.ssrContext?.response?.status(200);
                     try {
@@ -237,17 +142,17 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                     } catch  {}
                     throw Object.values(routerErrors)[0];
                 }
-                await preloadMatchedRouteComponents(serverRouter);
+                await (0, external_ssrPreload_js_namespaceObject.preloadMatchedRouteComponents)(serverRouter);
                 context.ssrContext?.response?.status(tanstackRouter.state.statusCode);
                 await serverRouter.serverSsr?.dehydrate?.();
-                if (isRSCNavigation) {
-                    await waitForRouterSerialization(serverRouter);
-                    setTanstackRscServerPayload((0, payloadRouter_js_namespaceObject.createTanstackRscServerPayload)(serverRouter, {
-                        omitClientLoaderData: true
+                if (enableRsc) {
+                    if (isRSCNavigation) await (0, external_ssrManagedTags_js_namespaceObject.waitForRouterSerialization)(serverRouter);
+                    (0, payloadStorage_js_namespaceObject.setTanstackRscServerPayload)((0, payloadRouter_js_namespaceObject.createTanstackRscServerPayload)(serverRouter, {
+                        omitClientLoaderData: isRSCNavigation
                     }));
                 }
                 const ssrScriptTags = serverRouter.serverSsr?.takeBufferedScripts?.();
-                const hydrationScripts = routerManagedTagsToHtml(ssrScriptTags);
+                const hydrationScripts = (0, external_ssrManagedTags_js_namespaceObject.routerManagedTagsToHtml)(ssrScriptTags);
                 const matchedRouteIds = (0, external_routeTree_js_namespaceObject.getModernRouteIdsFromMatches)(serverRouter);
                 const routerServerSnapshot = (0, external_lifecycle_js_namespaceObject.createRouterServerSnapshot)({
                     framework: 'tanstack',
@@ -277,7 +182,20 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                 });
             });
             api.wrapRoot((App)=>{
-                const getRouteApp = ()=>(props)=>{
+                const getRouteApp = ()=>{
+                    if ((0, context_namespaceObject.getGlobalEnableRsc)()) return (props)=>{
+                        const router = (0, payloadStorage_js_namespaceObject.getTanstackRscRouter)();
+                        if (!router) return App ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(App, {
+                            ...props
+                        }) : null;
+                        const routerWrapper = (0, external_hydrationBoundary_js_namespaceObject.wrapTanstackSsrHydrationBoundary)(/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(react_router_namespaceObject.RouterProvider, {
+                            router: router
+                        }), true);
+                        return App ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(App, {
+                            children: routerWrapper
+                        }) : routerWrapper;
+                    };
+                    return (props)=>{
                         const context = (0, external_react_namespaceObject.useContext)(context_namespaceObject.InternalRuntimeContext);
                         const router = (0, external_lifecycle_js_namespaceObject.getRouterRuntimeState)(context)?.instance;
                         if (!router) return App ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(App, {
@@ -290,6 +208,7 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                             children: routerWrapper
                         }) : routerWrapper;
                     };
+                };
                 return getRouteApp();
             });
         }

package/dist/cjs/runtime/pluginShared.js

@@ -0,0 +1,90 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createTanstackRouteObjects: ()=>createTanstackRouteObjects,
+    getFinalRouteConfig: ()=>getFinalRouteConfig,
+    getMergedRouterConfig: ()=>getMergedRouterConfig,
+    getTanstackRouteConfig: ()=>getTanstackRouteConfig,
+    joinBasename: ()=>joinBasename
+});
+const context_namespaceObject = require("@modern-js/runtime/context");
+const merge_namespaceObject = require("@modern-js/runtime-utils/merge");
+const external_utils_js_namespaceObject = require("./utils.js");
+function getMergedRouterConfig(api, userConfig) {
+    const pluginConfig = api.getRuntimeConfig();
+    return (0, merge_namespaceObject.merge)(pluginConfig.router || {}, userConfig);
+}
+function getFinalRouteConfig(mergedConfig) {
+    return {
+        routes: (0, context_namespaceObject.getGlobalRoutes)(),
+        globalApp: (0, context_namespaceObject.getGlobalLayoutApp)(),
+        ...mergedConfig.routesConfig
+    };
+}
+function getTanstackRouteConfig(api, userConfig) {
+    const mergedConfig = getMergedRouterConfig(api, userConfig);
+    const finalRouteConfig = getFinalRouteConfig(mergedConfig);
+    return {
+        mergedConfig,
+        finalRouteConfig,
+        hasConfiguredRoutes: Boolean(finalRouteConfig.routes) || Boolean(mergedConfig.createRoutes)
+    };
+}
+function createTanstackRouteObjects({ hooks, routeConfig, ssrMode }) {
+    const { mergedConfig, finalRouteConfig } = routeConfig;
+    const routeObjects = mergedConfig.createRoutes ? mergedConfig.createRoutes() : (0, external_utils_js_namespaceObject.createTanstackRouteObjectsFromConfig)({
+        routesConfig: finalRouteConfig,
+        ssrMode
+    }) || [];
+    return hooks.modifyRoutes.call(routeObjects);
+}
+function joinBasename(baseUrl, basename) {
+    const base = baseUrl || '/';
+    const normalizedBase = base.startsWith('/') ? base : `/${base}`;
+    const trimmedBase = normalizedBase.length > 1 ? normalizedBase.replace(/\/+$/g, '') : normalizedBase;
+    const trimmedBasename = basename.replace(/^\/+|\/+$/g, '');
+    if (!trimmedBasename) return trimmedBase || '/';
+    return `${trimmedBase}/${trimmedBasename}`.replace(/\/{2,}/g, '/');
+}
+exports.createTanstackRouteObjects = __webpack_exports__.createTanstackRouteObjects;
+exports.getFinalRouteConfig = __webpack_exports__.getFinalRouteConfig;
+exports.getMergedRouterConfig = __webpack_exports__.getMergedRouterConfig;
+exports.getTanstackRouteConfig = __webpack_exports__.getTanstackRouteConfig;
+exports.joinBasename = __webpack_exports__.joinBasename;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createTanstackRouteObjects",
+    "getFinalRouteConfig",
+    "getMergedRouterConfig",
+    "getTanstackRouteConfig",
+    "joinBasename"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/routeTree/components.js

@@ -0,0 +1,102 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    pickRouteModuleComponent: ()=>pickRouteModuleComponent,
+    toErrorComponent: ()=>toErrorComponent,
+    toPendingComponent: ()=>toPendingComponent,
+    toRouteComponent: ()=>toRouteComponent
+});
+const external_react_namespaceObject = require("react");
+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 createServerLazyImportComponent(lazyImport, fallbackComponent) {
+    if ("u" > typeof document) return fallbackComponent;
+    let resolvedComponent;
+    let pendingLoad;
+    const load = async ()=>{
+        if (resolvedComponent) return resolvedComponent;
+        const routeModule = await lazyImport();
+        const component = pickRouteModuleComponent(routeModule);
+        if (component) resolvedComponent = component;
+        return resolvedComponent;
+    };
+    const Component = (props)=>{
+        if (resolvedComponent) return (0, external_react_namespaceObject.createElement)(resolvedComponent, props);
+        pendingLoad ||= load();
+        throw pendingLoad;
+    };
+    Component.load = load;
+    Component.preload = load;
+    return Component;
+}
+function toRouteComponent(routeObject, options = {}) {
+    const route = routeObject;
+    const lazyImport = 'function' == typeof route.lazyImport ? route.lazyImport : void 0;
+    const routeComponent = route.Component || route.component;
+    const fallbackComponent = routeComponent ? routeComponent : route.element ? ()=>route.element : void 0;
+    if (lazyImport && fallbackComponent) return createServerLazyImportComponent(lazyImport, fallbackComponent);
+    if (routeComponent) return routeComponent;
+    const element = route.element;
+    if (element) return ()=>element;
+}
+function toErrorComponent(routeObject) {
+    const route = routeObject;
+    if (route.ErrorBoundary) return route.ErrorBoundary;
+    if (route.errorElement) return ()=>route.errorElement;
+}
+function toPendingComponent(routeObject) {
+    const route = routeObject;
+    return route.HydrateFallback || route.pendingComponent || void 0;
+}
+exports.pickRouteModuleComponent = __webpack_exports__.pickRouteModuleComponent;
+exports.toErrorComponent = __webpack_exports__.toErrorComponent;
+exports.toPendingComponent = __webpack_exports__.toPendingComponent;
+exports.toRouteComponent = __webpack_exports__.toRouteComponent;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "pickRouteModuleComponent",
+    "toErrorComponent",
+    "toPendingComponent",
+    "toRouteComponent"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});