@bleedingdev/modern-js-plugin-tanstack 3.9.0-ultramodern.2 → 3.9.0-ultramodern.21

package/dist/cjs/runtime/navigation.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__, {
+    createTanstackNavigation: ()=>createTanstackNavigation
+});
+const external_prefetchLink_js_namespaceObject = require("./prefetchLink.js");
+function createTanstackNavigation(router) {
+    let location;
+    let matches;
+    let snapshot;
+    return {
+        Link: external_prefetchLink_js_namespaceObject.Link,
+        getSnapshot () {
+            const state = router.state;
+            if (location !== state.location || void 0 === matches || matches.length !== state.matches.length || matches.some((match, index)=>match.params !== state.matches[index]?.params)) {
+                location = state.location;
+                matches = state.matches;
+                snapshot = {
+                    location: {
+                        pathname: location.pathname,
+                        search: location.searchStr,
+                        hash: '' !== location.hash ? `#${location.hash.replace(/^#/, '')}` : ''
+                    },
+                    params: Object.assign({}, ...matches.map((match)=>match.params))
+                };
+            }
+            return snapshot;
+        },
+        subscribe (listener) {
+            const stops = [
+                'onBeforeNavigate',
+                'onBeforeLoad',
+                'onLoad',
+                'onResolved'
+            ].map((event)=>router.subscribe(event, listener));
+            return ()=>{
+                for (const stop of stops)stop();
+            };
+        },
+        navigate (href, options) {
+            return router.navigate({
+                to: href,
+                replace: options?.replace,
+                ...options?.state === void 0 ? {} : {
+                    state: options.state
+                }
+            });
+        },
+        createLinkProps (target) {
+            const preload = void 0 !== target.preload ? target.preload : 'none' === target.prefetch ? false : target.prefetch;
+            return {
+                to: target.pathname,
+                ...void 0 !== target.search ? {
+                    search: target.search
+                } : {},
+                ...void 0 !== target.hash && '' !== target.hash ? {
+                    hash: target.hash
+                } : {},
+                ...void 0 === target.hashScrollIntoView ? {} : {
+                    hashScrollIntoView: target.hashScrollIntoView
+                },
+                ...void 0 === preload ? {} : {
+                    preload
+                }
+            };
+        }
+    };
+}
+exports.createTanstackNavigation = __webpack_exports__.createTanstackNavigation;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createTanstackNavigation"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/plugin.js

@@ -43,6 +43,7 @@ const external_clientHydration_js_namespaceObject = require("./clientHydration.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_navigation_js_namespaceObject = require("./navigation.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");
@@ -110,7 +111,7 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                 const mergedConfig = getMergedConfig();
                 const { supportHtml5History = true } = mergedConfig;
                 const history = supportHtml5History ? (0, react_router_namespaceObject.createBrowserHistory)() : (0, react_router_namespaceObject.createHashHistory)();
-                const rewrite = (0, external_basepathRewrite_js_namespaceObject.createModernBasepathRewrite)(_basename);
+                const rewrite = (0, external_basepathRewrite_js_namespaceObject.createModernBasepathRewrite)(_basename, false, getRouteObjects());
                 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)({
@@ -175,10 +176,14 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                         runtimeContext
                     ]);
                     if (!router) return App ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(App, {}) : null;
+                    const navigation = (0, external_react_namespaceObject.useMemo)(()=>(0, external_navigation_js_namespaceObject.createTanstackNavigation)(router), [
+                        router
+                    ]);
                     const runtimeState = (0, external_lifecycle_js_namespaceObject.applyRouterRuntimeState)(runtimeContext, {
                         framework: 'tanstack',
                         basename: _basename,
-                        instance: router
+                        instance: router,
+                        navigation
                     });
                     const lifecycleContext = {
                         framework: 'tanstack',

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

@@ -42,7 +42,9 @@ 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_navigation_js_namespaceObject = require("./navigation.js");
 const external_pluginShared_js_namespaceObject = require("./pluginShared.js");
+const external_prefetchLink_js_namespaceObject = require("./prefetchLink.js");
 const index_js_namespaceObject = require("./routeTree/index.js");
 const payloadRouter_js_namespaceObject = require("./rsc/payloadRouter.js");
 const payloadStorage_js_namespaceObject = require("./rsc/payloadStorage.js");
@@ -68,6 +70,9 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                     routeConfig
                 });
                 if (!modifiedRouteObjects.length) return;
+                context.router = {
+                    Link: external_prefetchLink_js_namespaceObject.Link
+                };
                 const { request, nonce, baseUrl, loaderFailureMode = 'errorBoundary' } = context.ssrContext;
                 const _basename = '/' === baseUrl ? (0, external_pluginShared_js_namespaceObject.joinBasename)(baseUrl, basename || '') : baseUrl;
                 const rawRequest = request.raw;
@@ -90,7 +95,7 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                         initialHref
                     ]
                 });
-                const rewrite = (0, external_basepathRewrite_js_namespaceObject.createModernBasepathRewrite)(_basename);
+                const rewrite = (0, external_basepathRewrite_js_namespaceObject.createModernBasepathRewrite)(_basename, false, modifiedRouteObjects);
                 const routerLifecycleContext = {
                     framework: 'tanstack',
                     phase: 'ssr-prepare',
@@ -116,76 +121,93 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                 });
                 const serverRouter = tanstackRouter;
                 if (enableRsc) (0, payloadStorage_js_namespaceObject.setTanstackRscRouter)(serverRouter);
-                await (0, external_ssrManagedTags_js_namespaceObject.attachServerSsrUtils)(serverRouter);
-                const end = (0, time_namespaceObject.time)();
+                let disposed = false;
+                let prepared = false;
+                const onAbort = ()=>controller.abort(rawRequest.signal.reason);
+                const cleanup = ()=>{
+                    if (disposed) return;
+                    disposed = true;
+                    rawRequest.signal.removeEventListener('abort', onAbort);
+                    controller.abort();
+                    serverRouter.serverSsr?.cleanup();
+                };
+                (0, external_lifecycle_js_namespaceObject.applyRouterRuntimeState)(context, {
+                    framework: 'tanstack',
+                    basename: _basename,
+                    instance: serverRouter,
+                    cleanup
+                });
+                rawRequest.signal.addEventListener('abort', onAbort, {
+                    once: true
+                });
                 try {
-                    await tanstackRouter.load({
-                        sync: true
-                    });
-                } finally{
-                    const cost = end();
-                    context.ssrContext?.onTiming?.(constants_namespaceObject.LOADER_REPORTER_NAME, cost);
-                }
-                const serverLoadResult = serverRouter._serverResult;
-                if (!serverLoadResult) {
+                    rawRequest.signal.throwIfAborted();
+                    await (0, external_ssrManagedTags_js_namespaceObject.attachServerSsrUtils)(serverRouter);
+                    rawRequest.signal.throwIfAborted();
+                    const end = (0, time_namespaceObject.time)();
                     try {
-                        serverRouter.serverSsr?.cleanup?.();
-                    } catch  {}
-                    throw new Error('TanStack Router completed an SSR load without a server result.');
-                }
-                if ('redirect' === serverLoadResult.type) {
-                    const { redirect } = serverLoadResult;
-                    try {
-                        serverRouter.serverSsr?.cleanup?.();
-                    } catch  {}
-                    return interrupt(isRSCNavigation ? (0, payloadRouter_js_namespaceObject.handleTanstackRscRedirect)(redirect.headers, _basename, redirect.status) : redirect);
-                }
-                const routerErrors = (0, external_ssrManagedTags_js_namespaceObject.collectRouterErrors)(tanstackRouter);
-                if (routerErrors && 'clientRender' === loaderFailureMode) {
-                    context.ssrContext?.response?.status(200);
-                    try {
-                        serverRouter.serverSsr?.cleanup?.();
-                    } catch  {}
-                    throw Object.values(routerErrors)[0];
-                }
-                await (0, external_ssrPreload_js_namespaceObject.preloadMatchedRouteComponents)(serverRouter);
-                context.ssrContext?.response?.status(serverLoadResult.status);
-                await serverRouter.serverSsr?.dehydrate?.();
-                if (enableRsc) {
-                    if (isRSCNavigation) await (0, external_ssrManagedTags_js_namespaceObject.waitForRouterSerialization)(serverRouter);
-                    (0, payloadStorage_js_namespaceObject.setTanstackRscServerPayload)((0, payloadRouter_js_namespaceObject.createTanstackRscServerPayload)(serverRouter, {
+                        await tanstackRouter.load({
+                            sync: true
+                        });
+                    } finally{
+                        const cost = end();
+                        context.ssrContext?.onTiming?.(constants_namespaceObject.LOADER_REPORTER_NAME, cost);
+                    }
+                    rawRequest.signal.throwIfAborted();
+                    const serverLoadResult = serverRouter._serverResult;
+                    if (!serverLoadResult) throw new Error('TanStack Router completed an SSR load without a server result.');
+                    if ('redirect' === serverLoadResult.type) {
+                        const { redirect } = serverLoadResult;
+                        return interrupt(isRSCNavigation ? (0, payloadRouter_js_namespaceObject.handleTanstackRscRedirect)(redirect.headers, _basename, redirect.status) : redirect);
+                    }
+                    const routerErrors = (0, external_ssrManagedTags_js_namespaceObject.collectRouterErrors)(tanstackRouter);
+                    if (routerErrors && 'clientRender' === loaderFailureMode) {
+                        context.ssrContext?.response?.status(200);
+                        throw Object.values(routerErrors)[0];
+                    }
+                    await (0, external_ssrPreload_js_namespaceObject.preloadMatchedRouteComponents)(serverRouter);
+                    context.ssrContext?.response?.status(serverLoadResult.status);
+                    await serverRouter.serverSsr?.dehydrate();
+                    if (enableRsc) (0, payloadStorage_js_namespaceObject.setTanstackRscServerPayload)((0, payloadRouter_js_namespaceObject.createTanstackRscServerPayload)(serverRouter, {
                         omitClientLoaderData: isRSCNavigation
                     }));
-                }
-                const ssrScriptTags = serverRouter.serverSsr?.takeBufferedScripts?.();
-                const hydrationScripts = (0, external_ssrManagedTags_js_namespaceObject.routerManagedTagsToHtml)(ssrScriptTags);
-                const matchedRouteIds = (0, index_js_namespaceObject.getModernRouteIdsFromMatches)(serverRouter);
-                const routerServerSnapshot = (0, external_lifecycle_js_namespaceObject.createRouterServerSnapshot)({
-                    framework: 'tanstack',
-                    basename: _basename,
-                    statusCode: serverLoadResult.status,
-                    errors: routerErrors,
-                    matchedRouteIds,
-                    hydrationScripts
-                });
-                const runtimeContext = (0, external_lifecycle_js_namespaceObject.applyRouterServerPrepareResult)(context, {
-                    snapshot: routerServerSnapshot,
-                    cleanup: ()=>serverRouter.serverSsr?.cleanup?.(),
-                    state: {
+                    const initialScriptTags = serverRouter.serverSsr?.takeInitialHydrationScriptTags();
+                    const hydrationScripts = initialScriptTags ? (0, external_ssrManagedTags_js_namespaceObject.routerManagedTagsToHtml)([
+                        ...initialScriptTags.before,
+                        initialScriptTags.boundary
+                    ]) : [];
+                    const matchedRouteIds = (0, index_js_namespaceObject.getModernRouteIdsFromMatches)(serverRouter);
+                    const routerServerSnapshot = {
                         framework: 'tanstack',
                         basename: _basename,
-                        instance: serverRouter,
-                        hydrationScripts,
+                        statusCode: serverLoadResult.status,
+                        errors: routerErrors,
                         matchedRouteIds,
-                        serverSnapshot: routerServerSnapshot
-                    }
-                });
-                hooks.onAfterCreateRouter.call({
-                    ...routerLifecycleContext,
-                    router: serverRouter,
-                    serverSnapshot: routerServerSnapshot,
-                    runtimeContext
-                });
+                        hydrationScripts
+                    };
+                    const runtimeContext = (0, external_lifecycle_js_namespaceObject.applyRouterServerPrepareResult)(context, {
+                        snapshot: routerServerSnapshot,
+                        cleanup,
+                        state: {
+                            framework: 'tanstack',
+                            basename: _basename,
+                            instance: serverRouter,
+                            navigation: (0, external_navigation_js_namespaceObject.createTanstackNavigation)(tanstackRouter)
+                        }
+                    });
+                    rawRequest.signal.throwIfAborted();
+                    hooks.onAfterCreateRouter.call({
+                        ...routerLifecycleContext,
+                        router: serverRouter,
+                        serverSnapshot: (0, external_lifecycle_js_namespaceObject.getRouterServerSnapshot)(runtimeContext),
+                        runtimeContext
+                    });
+                    prepared = true;
+                } finally{
+                    if (!prepared) try {
+                        cleanup();
+                    } catch  {}
+                }
             });
             api.wrapRoot((App)=>{
                 const getRouteApp = ()=>{

package/dist/cjs/runtime/prefetchLink.js

@@ -32,19 +32,14 @@ __webpack_require__.d(__webpack_exports__, {
     NavLink: ()=>NavLink
 });
 const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const runtime_extensions_namespaceObject = require("@modern-js/runtime-extensions");
 const react_router_namespaceObject = require("@tanstack/react-router");
-function resolvePreloadFromPrefetch(prefetch, preload) {
-    if (void 0 !== preload) return preload;
-    if ('none' === prefetch) return false;
-    if ('intent' === prefetch || 'render' === prefetch || 'viewport' === prefetch) return prefetch;
-    return 'viewport';
-}
 const LinkComponentImpl = (props)=>{
     const { prefetch, preload, 'aria-current': ariaCurrentProp, ref, children, ...rest } = props;
     const hasAriaCurrentOverride = 'aria-current' in props;
     const linkOptions = {
         ...rest,
-        preload: resolvePreloadFromPrefetch(prefetch, preload)
+        preload: (0, runtime_extensions_namespaceObject.resolvePreloadFromPrefetch)(prefetch, preload)
     };
     const linkProps = (0, react_router_namespaceObject.useLinkProps)(linkOptions, ref);
     const { disabled: _disabled, type: _type, ...anchorProps } = linkProps;

package/dist/cjs/runtime/register.js

@@ -30,10 +30,8 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     tanstackRouterProviderFactory: ()=>tanstackRouterProviderFactory
 });
-const context_namespaceObject = require("@modern-js/runtime/context");
 const external_plugin_js_namespaceObject = require("./plugin.js");
 const tanstackRouterProviderFactory = (userConfig)=>(0, external_plugin_js_namespaceObject.tanstackRouterPlugin)(userConfig);
-(0, context_namespaceObject.registerRouterProvider)('tanstack', tanstackRouterProviderFactory);
 exports.tanstackRouterProviderFactory = __webpack_exports__.tanstackRouterProviderFactory;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "tanstackRouterProviderFactory"

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

@@ -33,23 +33,20 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const context_namespaceObject = require("@modern-js/runtime/context");
 const react_router_namespaceObject = require("@tanstack/react-router");
+const routeDescriptor_js_namespaceObject = require("../../shared/routeDescriptor.js");
 const routeStaticData_js_namespaceObject = require("../../shared/routeStaticData.js");
 const external_outlet_js_namespaceObject = require("../outlet.js");
 const external_components_js_namespaceObject = require("./components.js");
 const external_loaders_js_namespaceObject = require("./loaders.js");
-const external_paths_js_namespaceObject = require("./paths.js");
 const external_staticData_js_namespaceObject = require("./staticData.js");
 const external_tanstackRoutes_js_namespaceObject = require("./tanstackRoutes.js");
-function createRouteFromRouteObject(opts) {
-    const { options = {}, parent, pathlessFallbackId = 'pathless', routeObject } = opts;
+function createRouteOptions(routeObject, options) {
     const modernRouteObject = routeObject;
     const revalidationState = {};
     const shouldRevalidate = modernRouteObject.shouldRevalidate;
     const shouldReload = (0, external_loaders_js_namespaceObject.createModernShouldReload)(shouldRevalidate, revalidationState);
-    const stableFallbackId = routeObject.id || modernRouteObject.file || pathlessFallbackId;
     const component = (0, external_components_js_namespaceObject.toRouteComponent)(routeObject);
     const base = {
-        getParentRoute: ()=>parent,
         component,
         pendingComponent: (0, external_components_js_namespaceObject.toPendingComponent)(routeObject),
         errorComponent: (0, external_components_js_namespaceObject.toErrorComponent)(routeObject),
@@ -70,66 +67,29 @@ function createRouteFromRouteObject(opts) {
     };
     if (modernRouteObject.inValidSSRRoute) base.ssr = false;
     if (shouldReload) base.shouldReload = shouldReload;
-    if ((0, external_paths_js_namespaceObject.isRouteObjectPathlessLayout)(routeObject)) base.id = stableFallbackId;
-    else base.path = routeObject.index ? '/' : (0, external_paths_js_namespaceObject.toTanstackPath)(routeObject.path || '');
-    const route = (0, external_tanstackRoutes_js_namespaceObject.createTanstackRoute)(base);
-    (0, external_tanstackRoutes_js_namespaceObject.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;
+    return base;
 }
-function getRootLikeRouteObject(routes) {
-    return routes.find((route)=>'/' === route.path && !route.index);
+function createRouteFromDescriptor(descriptor, parent, options) {
+    const { source, location, children } = descriptor;
+    const routeOptions = createRouteOptions(source, options);
+    const route = (0, external_tanstackRoutes_js_namespaceObject.createTanstackRoute)({
+        ...routeOptions,
+        ...location,
+        getParentRoute: ()=>parent
+    });
+    (0, external_tanstackRoutes_js_namespaceObject.wrapRouteComponentWithModernContext)(route, routeOptions.component, source.id);
+    if (children.length) route.addChildren(children.map((child)=>createRouteFromDescriptor(child, route, options)));
+    return route;
 }
 function createRouteTreeFromRouteObjects(routes, options = {}) {
-    const rootLikeRoute = getRootLikeRouteObject(routes);
-    const rootRevalidationState = {};
-    const rootShouldRevalidate = rootLikeRoute?.shouldRevalidate;
-    const rootShouldReload = (0, external_loaders_js_namespaceObject.createModernShouldReload)(rootShouldRevalidate, rootRevalidationState);
-    const rootComponent = rootLikeRoute ? (0, external_components_js_namespaceObject.toRouteComponent)(rootLikeRoute) : void 0;
+    const { root, children } = (0, routeDescriptor_js_namespaceObject.describeRouteTree)(routes);
     const rootRouteOptions = {
-        component: rootComponent,
-        pendingComponent: rootLikeRoute ? (0, external_components_js_namespaceObject.toPendingComponent)(rootLikeRoute) : void 0,
-        errorComponent: rootLikeRoute ? (0, external_components_js_namespaceObject.toErrorComponent)(rootLikeRoute) : void 0,
-        validateSearch: rootLikeRoute?.validateSearch,
-        loaderDeps: rootLikeRoute?.loaderDeps,
-        notFoundComponent: context_namespaceObject.DefaultNotFound,
-        staticData: (0, routeStaticData_js_namespaceObject.createRouteStaticData)({
-            modernRouteId: rootLikeRoute?.id,
-            modernRouteAction: rootLikeRoute?.action,
-            modernRouteHandle: rootLikeRoute ? (0, external_staticData_js_namespaceObject.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 ? (0, external_loaders_js_namespaceObject.wrapRouteObjectLoader)(rootLikeRoute, rootRevalidationState, options) : void 0
+        ...root ? createRouteOptions(root, options) : {},
+        notFoundComponent: context_namespaceObject.DefaultNotFound
     };
-    if (rootShouldReload) rootRouteOptions.shouldReload = rootShouldReload;
-    if (rootLikeRoute?.inValidSSRRoute) rootRouteOptions.ssr = false;
     const rootRoute = (0, external_tanstackRoutes_js_namespaceObject.createTanstackRootRoute)(rootRouteOptions);
-    if (rootComponent) rootRoute.options.component = (0, external_outlet_js_namespaceObject.withModernRouteMatchContext)(rootComponent, react_router_namespaceObject.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);
+    if (rootRouteOptions.component) rootRoute.options.component = (0, external_outlet_js_namespaceObject.withModernRouteMatchContext)(rootRouteOptions.component, react_router_namespaceObject.rootRouteId);
+    rootRoute.addChildren(children.map((child)=>createRouteFromDescriptor(child, rootRoute, options)));
     return rootRoute;
 }
 function getModernRouteIdsFromMatches(router) {

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

@@ -82,7 +82,7 @@ function wrapRouteObjectLoader(route, revalidationState, options = {}) {
             if ('function' == typeof modernRoute.lazyImport) try {
                 await modernRoute.lazyImport();
             } catch  {}
-            const signal = ctx?.abortController?.signal || ctx?.signal || new AbortController().signal;
+            const signal = (0, external_loaderBridge_js_namespaceObject.getLoaderSignal)(ctx);
             const baseRequest = ctx?.context?.request instanceof Request ? ctx.context.request : void 0;
             const href = (0, external_loaderBridge_js_namespaceObject.getLoaderHref)(ctx);
             const request = void 0 !== baseRequest ? new Request(baseRequest, {

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

@@ -39,17 +39,11 @@ function toTanstackPath(pathname) {
         return segment;
     }).join('/');
 }
-function isRouteObjectPathlessLayout(route) {
-    return !route.path && !route.index;
-}
 __webpack_require__.d(__webpack_exports__, {
-    isRouteObjectPathlessLayout: ()=>isRouteObjectPathlessLayout,
     toTanstackPath: ()=>toTanstackPath
 });
-exports.isRouteObjectPathlessLayout = __webpack_exports__.isRouteObjectPathlessLayout;
 exports.toTanstackPath = __webpack_exports__.toTanstackPath;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "isRouteObjectPathlessLayout",
     "toTanstackPath"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/cjs/runtime/router.js

@@ -30,21 +30,37 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     routerPlugin: ()=>routerPlugin
 });
+const context_namespaceObject = require("@modern-js/runtime/context");
 const internal_namespaceObject = require("@modern-js/runtime/router/internal");
+const router_provider_namespaceObject = require("@modern-js/runtime-extensions/router-provider");
+const router_state_plugin_namespaceObject = require("@modern-js/runtime-extensions/router-state-plugin");
 const external_register_js_namespaceObject = require("./register.js");
-function getRouterPlugin() {
-    const createRouterPlugin = Reflect.get(internal_namespaceObject, 'createRouterPlugin');
-    if ('function' == typeof createRouterPlugin) return createRouterPlugin([
+const createProviderPlugin = (0, router_provider_namespaceObject.createRouterPlugin)({
+    defaultProvider: {
+        name: 'react-router',
+        factory: internal_namespaceObject.routerPlugin
+    },
+    registryHooks: context_namespaceObject.routerProviderRegistryHooks,
+    localProviders: [
         {
             name: 'tanstack',
             factory: external_register_js_namespaceObject.tanstackRouterProviderFactory
         }
-    ]);
-    const legacyRouterPlugin = Reflect.get(internal_namespaceObject, 'routerPlugin');
-    if ('function' == typeof legacyRouterPlugin) return external_register_js_namespaceObject.tanstackRouterProviderFactory;
-    throw new Error('[@modern-js/plugin-tanstack] The installed @modern-js/runtime/router/internal exports neither createRouterPlugin nor routerPlugin. Install a compatible @modern-js/runtime version.');
-}
-const routerPlugin = getRouterPlugin();
+    ]
+});
+const statePlugin = (0, router_state_plugin_namespaceObject.createRouterStatePlugin)({
+    registryHooks: context_namespaceObject.routerProviderRegistryHooks
+});
+const routerPlugin = (userConfig = {})=>{
+    const providerPlugin = createProviderPlugin(userConfig);
+    return {
+        ...providerPlugin,
+        setup (api) {
+            statePlugin.setup(api);
+            providerPlugin.setup(api);
+        }
+    };
+};
 exports.routerPlugin = __webpack_exports__.routerPlugin;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "routerPlugin"

package/dist/cjs/runtime/ssrManagedTags.js

@@ -27,13 +27,6 @@ var __webpack_require__ = {};
 })();
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
-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, '"');
 }
@@ -83,20 +76,17 @@ __webpack_require__.d(__webpack_exports__, {
     attachServerSsrUtils: ()=>attachServerSsrUtils,
     collectRouterErrors: ()=>collectRouterErrors,
     createGetSsrHref: ()=>createGetSsrHref,
-    routerManagedTagsToHtml: ()=>routerManagedTagsToHtml,
-    waitForRouterSerialization: ()=>waitForRouterSerialization
+    routerManagedTagsToHtml: ()=>routerManagedTagsToHtml
 });
 exports.attachServerSsrUtils = __webpack_exports__.attachServerSsrUtils;
 exports.collectRouterErrors = __webpack_exports__.collectRouterErrors;
 exports.createGetSsrHref = __webpack_exports__.createGetSsrHref;
 exports.routerManagedTagsToHtml = __webpack_exports__.routerManagedTagsToHtml;
-exports.waitForRouterSerialization = __webpack_exports__.waitForRouterSerialization;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "attachServerSsrUtils",
     "collectRouterErrors",
     "createGetSsrHref",
-    "routerManagedTagsToHtml",
-    "waitForRouterSerialization"
+    "routerManagedTagsToHtml"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/runtime/state.js

@@ -30,9 +30,9 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     getTanstackRouterState: ()=>getTanstackRouterState
 });
-const context_namespaceObject = require("@modern-js/runtime/context");
+const router_state_namespaceObject = require("@modern-js/runtime-extensions/router-state");
 function getTanstackRouterState(context) {
-    const state = (0, context_namespaceObject.getRouterRuntimeState)(context);
+    const state = (0, router_state_namespaceObject.getRouterRuntimeState)(context);
     if (void 0 === state || 'tanstack' !== state.framework || void 0 === state.instance) return;
     return state;
 }

package/dist/cjs/runtime/utils.js

@@ -55,6 +55,8 @@ function withGlobalLayout(Component, globalApp) {
 }
 function toTanstackRouteObject(route, globalApp) {
     if ('nested' === route.type) return {
+        modernLocalisedRoute: Reflect.get(route, 'modernLocalisedRoute'),
+        isRoot: Reflect.get(route, 'isRoot'),
         path: route.path,
         id: route.id,
         loader: route.loader,
@@ -79,6 +81,7 @@ function toTanstackRouteObject(route, globalApp) {
     if ('function' != typeof route.component && 'object' != typeof route.component) return null;
     const LayoutComponent = withGlobalLayout(route.component, globalApp);
     return {
+        modernLocalisedRoute: Reflect.get(route, 'modernLocalisedRoute'),
         path: route.path,
         element: /*#__PURE__*/ (external_react_default()).createElement(LayoutComponent)
     };