@bleedingdev/modern-js-plugin-tanstack 3.5.0-ultramodern.9 → 3.5.0-ultramodern.90

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,138 +42,43 @@ 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 initialHref = createGetSsrHref(request.raw);
-                const isRSCNavigation = enableRsc && 'true' === request.raw.headers.get('x-rsc-tree');
+                const _basename = '/' === baseUrl ? (0, external_pluginShared_js_namespaceObject.joinBasename)(baseUrl, basename || '') : baseUrl;
+                const rawRequest = request.raw;
+                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();
-                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 = {
@@ -201,7 +106,7 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                     history,
                     basepath: '/',
                     rewrite,
-                    origin: new URL(request.raw.url).origin,
+                    origin: new URL(rawRequest.url).origin,
                     ssr: {
                         nonce
                     },
@@ -211,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({
@@ -228,25 +134,25 @@ 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);
+                    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);
+                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',
@@ -276,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, {
@@ -289,6 +208,7 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                             children: routerWrapper
                         }) : routerWrapper;
                     };
+                };
                 return getRouteApp();
             });
         }

package/dist/cjs/runtime/pluginShared.js

@@ -0,0 +1,87 @@
+"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,
+    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.getMergedRouterConfig = __webpack_exports__.getMergedRouterConfig;
+exports.getTanstackRouteConfig = __webpack_exports__.getTanstackRouteConfig;
+exports.joinBasename = __webpack_exports__.joinBasename;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createTanstackRouteObjects",
+    "getMergedRouterConfig",
+    "getTanstackRouteConfig",
+    "joinBasename"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/prefetchLink.js

@@ -40,10 +40,23 @@ function resolvePreloadFromPrefetch(prefetch, preload) {
     return 'viewport';
 }
 const LinkComponentImpl = (props)=>{
-    const { prefetch, preload, ...rest } = props;
-    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(react_router_namespaceObject.Link, {
+    const { prefetch, preload, 'aria-current': ariaCurrentProp, ref, children, ...rest } = props;
+    const hasAriaCurrentOverride = 'aria-current' in props;
+    const linkOptions = {
         ...rest,
         preload: resolvePreloadFromPrefetch(prefetch, preload)
+    };
+    const linkProps = (0, react_router_namespaceObject.useLinkProps)(linkOptions, ref);
+    const { disabled: _disabled, type: _type, ...anchorProps } = linkProps;
+    if (hasAriaCurrentOverride) if (false === ariaCurrentProp || void 0 === ariaCurrentProp) delete anchorProps['aria-current'];
+    else anchorProps['aria-current'] = ariaCurrentProp;
+    const resolvedChildren = 'function' == typeof children ? children({
+        isActive: 'active' === anchorProps['data-status'],
+        isTransitioning: 'transitioning' === anchorProps['data-transitioning']
+    }) : children;
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("a", {
+        ...anchorProps,
+        children: resolvedChildren
     });
 };
 const Link = LinkComponentImpl;

package/dist/cjs/runtime/register.js

@@ -28,28 +28,15 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    tanstackRouterCompatBindings: ()=>tanstackRouterCompatBindings
+    tanstackRouterProviderFactory: ()=>tanstackRouterProviderFactory
 });
 const context_namespaceObject = require("@modern-js/runtime/context");
-const external_dataMutation_js_namespaceObject = require("./dataMutation.js");
-const external_outlet_js_namespaceObject = require("./outlet.js");
 const external_plugin_js_namespaceObject = require("./plugin.js");
-const external_prefetchLink_js_namespaceObject = require("./prefetchLink.js");
 const tanstackRouterProviderFactory = (userConfig)=>(0, external_plugin_js_namespaceObject.tanstackRouterPlugin)(userConfig);
 (0, context_namespaceObject.registerRouterProvider)('tanstack', tanstackRouterProviderFactory);
-const COMPAT_BINDINGS_SLOT = Symbol.for('@modern-js/plugin-tanstack:runtime-compat-bindings');
-const tanstackRouterCompatBindings = {
-    Form: external_dataMutation_js_namespaceObject.Form,
-    Link: external_prefetchLink_js_namespaceObject.Link,
-    NavLink: external_prefetchLink_js_namespaceObject.NavLink,
-    Outlet: external_outlet_js_namespaceObject.Outlet,
-    RouteActionResponseError: external_dataMutation_js_namespaceObject.RouteActionResponseError,
-    useFetcher: external_dataMutation_js_namespaceObject.useFetcher
-};
-globalThis[COMPAT_BINDINGS_SLOT] ??= tanstackRouterCompatBindings;
-exports.tanstackRouterCompatBindings = __webpack_exports__.tanstackRouterCompatBindings;
+exports.tanstackRouterProviderFactory = __webpack_exports__.tanstackRouterProviderFactory;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "tanstackRouterCompatBindings"
+    "tanstackRouterProviderFactory"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true