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

package/dist/esm/runtime/loaderBridge.mjs

@@ -95,7 +95,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/runtime/plugin.mjs

@@ -4,123 +4,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',
@@ -134,13 +29,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 = ()=>{
@@ -160,7 +52,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();
@@ -187,8 +79,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/runtime/plugin.node.mjs

@@ -1,6 +1,6 @@
 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";
@@ -9,138 +9,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 = {
@@ -168,7 +73,7 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                     history,
                     basepath: '/',
                     rewrite,
-                    origin: new URL(request.raw.url).origin,
+                    origin: new URL(rawRequest.url).origin,
                     ssr: {
                         nonce
                     },
@@ -178,6 +83,7 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                     } : {}
                 });
                 const serverRouter = tanstackRouter;
+                if (enableRsc) setTanstackRscRouter(serverRouter);
                 await attachServerSsrUtils(serverRouter);
                 const end = time();
                 try {
@@ -197,19 +103,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?.();
@@ -243,7 +149,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, {
@@ -256,6 +175,7 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                             children: routerWrapper
                         }) : routerWrapper;
                     };
+                };
                 return getRouteApp();
             });
         }

package/dist/esm/runtime/pluginShared.mjs

@@ -0,0 +1,40 @@
+import { getGlobalLayoutApp, getGlobalRoutes } from "@modern-js/runtime/context";
+import { merge } from "@modern-js/runtime-utils/merge";
+import { createTanstackRouteObjectsFromConfig } from "./utils.mjs";
+function getMergedRouterConfig(api, userConfig) {
+    const pluginConfig = api.getRuntimeConfig();
+    return merge(pluginConfig.router || {}, userConfig);
+}
+function getFinalRouteConfig(mergedConfig) {
+    return {
+        routes: getGlobalRoutes(),
+        globalApp: 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() : 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, '/');
+}
+export { createTanstackRouteObjects, getFinalRouteConfig, getMergedRouterConfig, getTanstackRouteConfig, joinBasename };

package/dist/esm/runtime/prefetchLink.mjs

@@ -1,5 +1,5 @@
 import { jsx } from "react/jsx-runtime";
-import { Link } from "@tanstack/react-router";
+import { useLinkProps } from "@tanstack/react-router";
 function resolvePreloadFromPrefetch(prefetch, preload) {
     if (void 0 !== preload) return preload;
     if ('none' === prefetch) return false;
@@ -7,12 +7,25 @@ function resolvePreloadFromPrefetch(prefetch, preload) {
     return 'viewport';
 }
 const LinkComponentImpl = (props)=>{
-    const { prefetch, preload, ...rest } = props;
-    return /*#__PURE__*/ jsx(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 = 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__*/ jsx("a", {
+        ...anchorProps,
+        children: resolvedChildren
     });
 };
-const prefetchLink_Link = LinkComponentImpl;
+const Link = LinkComponentImpl;
 const NavLink = LinkComponentImpl;
-export { NavLink, prefetchLink_Link as Link };
+export { Link, NavLink };

package/dist/esm/runtime/routeTree/components.mjs

@@ -0,0 +1,55 @@
+import { createElement } from "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 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;
+}
+export { pickRouteModuleComponent, toErrorComponent, toPendingComponent, toRouteComponent };

package/dist/esm/runtime/routeTree/construction.mjs

@@ -0,0 +1,111 @@
+import { DefaultNotFound } from "@modern-js/runtime/context";
+import { rootRouteId } from "@tanstack/react-router";
+import { withModernRouteMatchContext } from "../outlet.mjs";
+import { toErrorComponent, toPendingComponent, toRouteComponent } from "./components.mjs";
+import { createModernShouldReload, wrapRouteObjectLoader } from "./loaders.mjs";
+import { isRouteObjectPathlessLayout, toTanstackPath } from "./paths.mjs";
+import { createRouteStaticData, mergeModernRouteHandle } from "./staticData.mjs";
+import { createTanstackRootRoute, createTanstackRoute, wrapRouteComponentWithModernContext } from "./tanstackRoutes.mjs";
+function createRouteFromRouteObject(opts) {
+    const { options = {}, parent, pathlessFallbackId = 'pathless', routeObject } = opts;
+    const modernRouteObject = routeObject;
+    const revalidationState = {};
+    const shouldRevalidate = modernRouteObject.shouldRevalidate;
+    const shouldReload = createModernShouldReload(shouldRevalidate, revalidationState);
+    const stableFallbackId = routeObject.id || modernRouteObject.file || pathlessFallbackId;
+    const component = toRouteComponent(routeObject, options);
+    const base = {
+        getParentRoute: ()=>parent,
+        component,
+        pendingComponent: toPendingComponent(routeObject),
+        errorComponent: toErrorComponent(routeObject),
+        validateSearch: modernRouteObject.validateSearch,
+        loaderDeps: modernRouteObject.loaderDeps,
+        staticData: createRouteStaticData({
+            modernRouteId: routeObject.id,
+            modernRouteAction: modernRouteObject.action,
+            modernRouteHandle: mergeModernRouteHandle(modernRouteObject),
+            modernRouteHasAction: modernRouteObject.hasAction || Boolean(modernRouteObject.action),
+            modernRouteHasClientLoader: modernRouteObject.hasClientLoader || void 0 !== modernRouteObject.clientData,
+            modernRouteHasLoader: modernRouteObject.hasLoader || 'function' == typeof modernRouteObject.loader,
+            modernRouteIsClientComponent: modernRouteObject.isClientComponent,
+            modernRouteLoader: modernRouteObject.loader,
+            modernRouteShouldRevalidate: shouldRevalidate
+        }),
+        loader: wrapRouteObjectLoader(routeObject, revalidationState, options)
+    };
+    if (modernRouteObject.inValidSSRRoute) base.ssr = false;
+    if (shouldReload) base.shouldReload = shouldReload;
+    if (isRouteObjectPathlessLayout(routeObject)) base.id = stableFallbackId;
+    else base.path = routeObject.index ? '/' : toTanstackPath(routeObject.path || '');
+    const route = createTanstackRoute(base);
+    wrapRouteComponentWithModernContext(route, component, routeObject.id);
+    const children = routeObject.children;
+    if (children && children.length > 0) {
+        const childRoutes = children.map((child, index)=>createRouteFromRouteObject({
+                options,
+                parent: route,
+                pathlessFallbackId: `pathless-${index}`,
+                routeObject: child
+            }));
+        route.addChildren(childRoutes);
+    }
+    return route;
+}
+function getRootLikeRouteObject(routes) {
+    return routes.find((route)=>'/' === route.path && !route.index);
+}
+function createRouteTreeFromRouteObjects(routes, options = {}) {
+    const rootLikeRoute = getRootLikeRouteObject(routes);
+    const rootRevalidationState = {};
+    const rootShouldRevalidate = rootLikeRoute?.shouldRevalidate;
+    const rootShouldReload = createModernShouldReload(rootShouldRevalidate, rootRevalidationState);
+    const rootComponent = rootLikeRoute ? toRouteComponent(rootLikeRoute) : void 0;
+    const rootRouteOptions = {
+        component: rootComponent,
+        pendingComponent: rootLikeRoute ? toPendingComponent(rootLikeRoute) : void 0,
+        errorComponent: rootLikeRoute ? toErrorComponent(rootLikeRoute) : void 0,
+        validateSearch: rootLikeRoute?.validateSearch,
+        loaderDeps: rootLikeRoute?.loaderDeps,
+        notFoundComponent: DefaultNotFound,
+        staticData: createRouteStaticData({
+            modernRouteId: rootLikeRoute?.id,
+            modernRouteAction: rootLikeRoute?.action,
+            modernRouteHandle: rootLikeRoute ? mergeModernRouteHandle(rootLikeRoute) : void 0,
+            modernRouteHasAction: rootLikeRoute?.hasAction || Boolean(rootLikeRoute?.action),
+            modernRouteHasClientLoader: rootLikeRoute?.hasClientLoader || void 0 !== rootLikeRoute?.clientData,
+            modernRouteHasLoader: rootLikeRoute?.hasLoader || 'function' == typeof rootLikeRoute?.loader,
+            modernRouteIsClientComponent: rootLikeRoute?.isClientComponent,
+            modernRouteLoader: rootLikeRoute?.loader,
+            modernRouteShouldRevalidate: rootShouldRevalidate
+        }),
+        loader: rootLikeRoute ? wrapRouteObjectLoader(rootLikeRoute, rootRevalidationState, options) : void 0
+    };
+    if (rootShouldReload) rootRouteOptions.shouldReload = rootShouldReload;
+    if (rootLikeRoute?.inValidSSRRoute) rootRouteOptions.ssr = false;
+    const rootRoute = createTanstackRootRoute(rootRouteOptions);
+    if (rootComponent) rootRoute.options.component = withModernRouteMatchContext(rootComponent, rootRouteId);
+    const topLevel = rootLikeRoute ? [
+        ...rootLikeRoute.children || [],
+        ...routes.filter((route)=>route !== rootLikeRoute)
+    ] : routes;
+    const childRoutes = topLevel.map((routeObject, index)=>createRouteFromRouteObject({
+            options,
+            parent: rootRoute,
+            pathlessFallbackId: `pathless-${index}`,
+            routeObject
+        }));
+    rootRoute.addChildren(childRoutes);
+    return rootRoute;
+}
+function getModernRouteIdsFromMatches(router) {
+    const matches = router.state.matches || [];
+    const routesById = router.routesById;
+    const ids = matches.map((match)=>{
+        const normalizedMatch = match;
+        const routeId = 'string' == typeof normalizedMatch.routeId ? normalizedMatch.routeId : void 0;
+        return normalizedMatch.route?.options?.staticData?.modernRouteId ?? (routeId ? routesById?.[routeId]?.options?.staticData?.modernRouteId : void 0);
+    }).filter((id)=>'string' == typeof id);
+    return Array.from(new Set(ids));
+}
+export { createRouteTreeFromRouteObjects, getModernRouteIdsFromMatches };