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

package/dist/esm/cli/tanstackTypes.mjs

@@ -55,6 +55,14 @@ function pickModernLoaderModule(route) {
         inline
     };
 }
+function pickRouteSearchContractModules(route) {
+    const validateSearchPath = route.validateSearch;
+    const loaderDepsPath = route.loaderDeps;
+    return {
+        validateSearchPath: 'string' == typeof validateSearchPath ? validateSearchPath : null,
+        loaderDepsPath: 'string' == typeof loaderDepsPath ? loaderDepsPath : null
+    };
+}
 function isPathlessLayout(route) {
     return 'nested' === route.type && 'boolean' != typeof route.index && void 0 === route.path;
 }
@@ -88,8 +96,21 @@ async function generateTanstackRouterTypesSourceForEntry(opts) {
     const imports = [];
     const statements = [];
     const loaderImportMap = new Map();
+    const searchContractImportMap = new Map();
+    const usedRouteVarNames = new Set();
     let loaderIndex = 0;
+    let validateSearchIndex = 0;
+    let loaderDepsIndex = 0;
     let routeIndex = 0;
+    const resolveRouteModuleNoExt = async (aliasedNoExtPath)=>{
+        const prefix = `${appContext.internalSrcAlias}/`;
+        let absNoExt;
+        if (aliasedNoExtPath.startsWith(prefix)) {
+            const rel = aliasedNoExtPath.slice(prefix.length);
+            absNoExt = path.join(appContext.srcDirectory, rel);
+        } else absNoExt = path.isAbsolute(aliasedNoExtPath) ? aliasedNoExtPath : path.join(appContext.srcDirectory, aliasedNoExtPath);
+        return resolveFileNoExt(absNoExt);
+    };
     const getImportNamesForLoader = async (aliasedNoExtPath, inline, hasAction)=>{
         const key = `${inline ? 'inline' : 'default'}:${hasAction ? 'action' : 'loader'}:${aliasedNoExtPath}`;
         const existing = loaderImportMap.get(key);
@@ -97,13 +118,7 @@ async function generateTanstackRouterTypesSourceForEntry(opts) {
             loaderName: existing,
             actionName: hasAction ? existing.replace(/^loader_/, 'action_') : null
         };
-        const prefix = `${appContext.internalSrcAlias}/`;
-        let absNoExt;
-        if (aliasedNoExtPath.startsWith(prefix)) {
-            const rel = aliasedNoExtPath.slice(prefix.length);
-            absNoExt = path.join(appContext.srcDirectory, rel);
-        } else absNoExt = path.isAbsolute(aliasedNoExtPath) ? aliasedNoExtPath : path.join(appContext.srcDirectory, aliasedNoExtPath);
-        const resolvedNoExt = await resolveFileNoExt(absNoExt);
+        const resolvedNoExt = await resolveRouteModuleNoExt(aliasedNoExtPath);
         if (!resolvedNoExt) return null;
         const relImport = normalizeRelativeImport(path.relative(outDir, resolvedNoExt));
         const importName = `loader_${loaderIndex++}`;
@@ -121,10 +136,29 @@ async function generateTanstackRouterTypesSourceForEntry(opts) {
             actionName
         };
     };
+    const getImportNameForSearchContract = async (aliasedNoExtPath, exportName)=>{
+        const key = `${exportName}:${aliasedNoExtPath}`;
+        const existing = searchContractImportMap.get(key);
+        if (existing) return existing;
+        const resolvedNoExt = await resolveRouteModuleNoExt(aliasedNoExtPath);
+        if (!resolvedNoExt) return null;
+        const relImport = normalizeRelativeImport(path.relative(outDir, resolvedNoExt));
+        const importName = 'validateSearch' === exportName ? `validateSearch_${validateSearchIndex++}` : `loaderDeps_${loaderDepsIndex++}`;
+        imports.push(`import { ${exportName} as ${importName} } from ${quote(relImport)};`);
+        searchContractImportMap.set(key, importName);
+        return importName;
+    };
+    const reserveRouteVarName = (preferred)=>{
+        let candidate = preferred;
+        let suffix = 1;
+        while(usedRouteVarNames.has(candidate))candidate = `${preferred}_${suffix++}`;
+        usedRouteVarNames.add(candidate);
+        return candidate;
+    };
     const createRouteVarName = (route)=>{
         const id = route.id;
         const base = id ? makeLegalIdentifier(id) : `r_${routeIndex++}`;
-        return `route_${base}`;
+        return reserveRouteVarName(`route_${base}`);
     };
     const buildRoute = async (opts)=>{
         const { parentVar, route } = opts;
@@ -134,6 +168,9 @@ async function generateTanstackRouterTypesSourceForEntry(opts) {
         const loaderImports = loaderInfo ? await getImportNamesForLoader(loaderInfo.loaderPath, loaderInfo.inline, Boolean(loaderInfo.inline && routeAction === loaderInfo.loaderPath)) : null;
         const loaderName = loaderImports?.loaderName || null;
         const actionName = loaderImports?.actionName || null;
+        const searchContractInfo = pickRouteSearchContractModules(route);
+        const validateSearchName = searchContractInfo.validateSearchPath ? await getImportNameForSearchContract(searchContractInfo.validateSearchPath, 'validateSearch') : null;
+        const loaderDepsName = searchContractInfo.loaderDepsPath ? await getImportNameForSearchContract(searchContractInfo.loaderDepsPath, 'loaderDeps') : null;
         const rawPath = route.path;
         const hasSplat = 'string' == typeof rawPath && rawPath.includes('*');
         const routeOpts = [
@@ -147,20 +184,24 @@ async function generateTanstackRouterTypesSourceForEntry(opts) {
             routeOpts.push(`path: ${quote(p)},`);
         }
         if (loaderName) routeOpts.push(`loader: modernLoaderToTanstack({ hasSplat: ${hasSplat} }, ${loaderName}),`);
+        if (validateSearchName) routeOpts.push(`validateSearch: ${validateSearchName},`);
+        if (loaderDepsName) routeOpts.push(`loaderDeps: ${loaderDepsName},`);
         const staticDataSnippet = createRouteStaticDataSnippet({
             modernRouteId: route.id,
             loaderName,
             actionName
         });
         if (staticDataSnippet) routeOpts.push(staticDataSnippet);
-        statements.push(`const ${varName} = createRoute({\n  ${routeOpts.join('\n  ')}\n});`);
         const children = route.children;
+        const hasChildren = Boolean(children && children.length > 0);
+        const routeCtorVarName = hasChildren ? reserveRouteVarName(`${varName}__base`) : varName;
+        statements.push(`const ${routeCtorVarName} = createRoute({\n  ${routeOpts.join('\n  ')}\n});`);
         if (children && children.length > 0) {
             const childVars = await Promise.all(children.map((child)=>buildRoute({
-                    parentVar: varName,
+                    parentVar: routeCtorVarName,
                     route: child
                 })));
-            statements.push(`${varName}.addChildren([${childVars.join(', ')}]);`);
+            statements.push(`const ${varName} = ${routeCtorVarName}.addChildren([${childVars.join(', ')}]);`);
         }
         return varName;
     };
@@ -169,17 +210,23 @@ async function generateTanstackRouterTypesSourceForEntry(opts) {
     const rootLoaderImports = rootLoaderInfo?.loaderPath ? await getImportNamesForLoader(rootLoaderInfo.loaderPath, rootLoaderInfo.inline, Boolean(rootLoaderInfo.inline && rootAction === rootLoaderInfo.loaderPath)) : null;
     const rootLoaderName = rootLoaderImports?.loaderName || null;
     const rootActionName = rootLoaderImports?.actionName || null;
+    const rootSearchContractInfo = rootModern ? pickRouteSearchContractModules(rootModern) : null;
+    const rootValidateSearchName = rootSearchContractInfo?.validateSearchPath ? await getImportNameForSearchContract(rootSearchContractInfo.validateSearchPath, 'validateSearch') : null;
+    const rootLoaderDepsName = rootSearchContractInfo?.loaderDepsPath ? await getImportNameForSearchContract(rootSearchContractInfo.loaderDepsPath, 'loaderDeps') : null;
     const topLevelVars = await Promise.all(topLevel.map((route)=>buildRoute({
             parentVar: 'rootRoute',
             route
         })));
     const rootOpts = [];
     if (rootLoaderName) rootOpts.push(`loader: modernLoaderToTanstack({ hasSplat: false }, ${rootLoaderName}),`);
+    if (rootValidateSearchName) rootOpts.push(`validateSearch: ${rootValidateSearchName},`);
+    if (rootLoaderDepsName) rootOpts.push(`loaderDeps: ${rootLoaderDepsName},`);
     const routerGenTs = `/* eslint-disable */
 // This file is auto-generated by Modern.js. Do not edit manually.
 
 import {
   createMemoryHistory,
+  modernTanstackRouterFastDefaults,
   createRootRouteWithContext,
   createRoute,
   createRouter,
@@ -207,7 +254,7 @@ function isRedirectResponse(res: Response) {
 }
 
 function throwTanstackRedirect(location: string) {
-  const target = location || '/';
+  const target = location.length > 0 ? location : '/';
   try {
     void new URL(target);
     throw redirect({ href: target });
@@ -233,21 +280,87 @@ function createRouteStaticData(opts: {
   modernRouteAction?: unknown;
   modernRouteLoader?: unknown;
 }) {
-  const staticData: Record<string, unknown> = {};
+  const staticData: {
+    modernRouteId?: string;
+    modernRouteAction?: unknown;
+    modernRouteLoader?: unknown;
+  } = {};
 
-  if (opts.modernRouteId) {
+  if (typeof opts.modernRouteId === 'string' && opts.modernRouteId.length > 0) {
     staticData.modernRouteId = opts.modernRouteId;
   }
 
-  if (opts.modernRouteLoader) {
+  if (typeof opts.modernRouteLoader !== 'undefined') {
     staticData.modernRouteLoader = opts.modernRouteLoader;
   }
 
-  if (opts.modernRouteAction) {
+  if (typeof opts.modernRouteAction !== 'undefined') {
     staticData.modernRouteAction = opts.modernRouteAction;
   }
 
-  return Object.keys(staticData).length > 0 ? staticData : undefined;
+  return staticData;
+}
+
+function getLoaderSignal(ctx: any): AbortSignal {
+  const abortSignal = ctx?.abortController?.signal;
+  if (abortSignal instanceof AbortSignal) {
+    return abortSignal;
+  }
+  if (ctx?.signal instanceof AbortSignal) {
+    return ctx.signal;
+  }
+  return new AbortController().signal;
+}
+
+function getLoaderHref(ctx: any): string {
+  if (typeof ctx?.location === 'string') {
+    return ctx.location;
+  }
+
+  const publicHref = ctx?.location?.publicHref;
+  if (typeof publicHref === 'string') {
+    return publicHref;
+  }
+
+  const href = ctx?.location?.href;
+  if (typeof href === 'string') {
+    return href;
+  }
+
+  const urlHref = ctx?.location?.url?.href;
+  return typeof urlHref === 'string' ? urlHref : '';
+}
+
+function getLoaderParams(ctx: any): Record<string, string> {
+  return typeof ctx?.params === 'object' && ctx.params !== null ? ctx.params : {};
+}
+
+function handleModernLoaderResult<LoaderResult>(result: LoaderResult): LoaderResult {
+  if (isResponse(result)) {
+    if (isRedirectResponse(result)) {
+      const location = result.headers.get('Location') ?? '/';
+      throwTanstackRedirect(location);
+    }
+    if (result.status === 404) {
+      throw notFound();
+    }
+  }
+
+  return result;
+}
+
+function handleModernLoaderError(err: unknown): never {
+  if (isResponse(err)) {
+    if (isRedirectResponse(err)) {
+      const location = err.headers.get('Location') ?? '/';
+      throwTanstackRedirect(location);
+    }
+    if (err.status === 404) {
+      throw notFound();
+    }
+  }
+
+  throw err;
 }
 
 function modernLoaderToTanstack<TLoader extends (args: any) => any>(
@@ -256,57 +369,31 @@ function modernLoaderToTanstack<TLoader extends (args: any) => any>(
 ) {
   type LoaderResult = Awaited<ReturnType<TLoader>>;
 
-  return async (ctx: any): Promise<LoaderResult> => {
+  return (ctx: any): Promise<LoaderResult> => {
     try {
-      const signal: AbortSignal =
-        ctx?.abortController?.signal ||
-        ctx?.signal ||
-        new AbortController().signal;
+      const signal = getLoaderSignal(ctx);
       const baseRequest: Request | undefined =
         ctx?.context?.request instanceof Request ? ctx.context.request : undefined;
 
-      const href =
-        typeof ctx?.location === 'string'
-          ? ctx.location
-          : ctx?.location?.publicHref ||
-            ctx?.location?.href ||
-            ctx?.location?.url?.href ||
-            '';
+      const href = getLoaderHref(ctx);
 
-      const request = baseRequest
+      const request = baseRequest !== undefined
         ? new Request(baseRequest, { signal })
         : new Request(href, { signal });
 
-      const params = mapParamsForModernLoader(ctx?.params || {}, opts.hasSplat);
+      const params = mapParamsForModernLoader(getLoaderParams(ctx), opts.hasSplat);
 
-      const result = await (modernLoader as any)({
-        request,
-        params,
-        context: ctx?.context?.requestContext,
-      });
-
-      if (isResponse(result)) {
-        if (isRedirectResponse(result)) {
-          const location = result.headers.get('Location') || '/';
-          throwTanstackRedirect(location);
-        }
-        if (result.status === 404) {
-          throw notFound();
-        }
-      }
-
-      return result as LoaderResult;
+      return Promise.resolve(
+        (modernLoader as any)({
+          request,
+          params,
+          context: ctx?.context?.requestContext,
+        }),
+      )
+        .then((result: LoaderResult) => handleModernLoaderResult(result))
+        .catch(handleModernLoaderError);
     } catch (err) {
-      if (isResponse(err)) {
-        if (isRedirectResponse(err)) {
-          const location = err.headers.get('Location') || '/';
-          throwTanstackRedirect(location);
-        }
-        if (err.status === 404) {
-          throw notFound();
-        }
-      }
-      throw err;
+      handleModernLoaderError(err);
     }
   };
 }
@@ -327,6 +414,7 @@ ${statements.join('\n\n')}
 export const routeTree = rootRoute.addChildren([${topLevelVars.join(', ')}]);
 
 export const router = createRouter({
+  ...modernTanstackRouterFastDefaults,
   routeTree,
   history: createMemoryHistory({
     initialEntries: ['/'],

package/dist/esm/runtime/index.mjs

@@ -1,6 +1,7 @@
 export * from "@tanstack/react-router";
-export { useMatch } from "@tanstack/react-router";
+export { Outlet, useLocation, useMatch, useMatches, useNavigate, useRouter } from "@tanstack/react-router";
 export { Form, RouteActionResponseError, useFetcher } from "./dataMutation.mjs";
 export { tanstackRouterPlugin as default, tanstackRouterPlugin } from "./plugin.mjs";
 export { Link, NavLink } from "./prefetchLink.mjs";
 export { CompositeComponent } from "./rsc/client.mjs";
+export { getModernTanstackRouterFastDefaults, modernTanstackRouterFastDefaults } from "./types.mjs";

package/dist/esm/runtime/plugin.mjs

@@ -4,13 +4,15 @@ import { merge } from "@modern-js/runtime-utils/merge";
 import { normalizePathname } from "@modern-js/runtime-utils/url";
 import { RouterProvider, createBrowserHistory, createHashHistory, createRouter, useLocation, useMatches, useNavigate, useRouter } from "@tanstack/react-router";
 import { RouterClient } from "@tanstack/react-router/ssr/client";
+import { useContext, useMemo } from "react";
 import { createModernBasepathRewrite } from "./basepathRewrite.mjs";
 import { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter } from "./hooks.mjs";
 import { applyRouterRuntimeState } from "./lifecycle.mjs";
+import { Link } from "./prefetchLink.mjs";
 import { createRouteTreeFromRouteObjects } from "./routeTree.mjs";
 import { getTanstackRscSerializationAdapters } from "./rsc/client.mjs";
+import { getModernTanstackRouterFastDefaults } from "./types.mjs";
 import { createRouteObjectsFromConfig, urlJoin } from "./utils.mjs";
-import * as __rspack_external_react from "react";
 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) {
@@ -73,6 +75,7 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                     }
                 }
                 context.router = {
+                    Link: Link,
                     useMatches: useMatches,
                     useLocation: useLocation,
                     useNavigate: useNavigate,
@@ -107,10 +110,10 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                 let cachedRouter = null;
                 let cachedRouterBasepath = null;
                 const RouterWrapper = ()=>{
-                    const runtimeContext = (0, __rspack_external_react.useContext)(InternalRuntimeContext);
+                    const runtimeContext = useContext(InternalRuntimeContext);
                     const baseUrl = selectBasePath(location.pathname).replace(/^\/*/, '/');
                     const _basename = '/' === baseUrl ? urlJoin(baseUrl, runtimeContext._internalRouterBaseName || basename || '') : baseUrl;
-                    const routeTree = (0, __rspack_external_react.useMemo)(()=>{
+                    const routeTree = useMemo(()=>{
                         if (cachedRouteTree) return cachedRouteTree;
                         const routeObjects = getRouteObjects();
                         if (!routeObjects.length) return null;
@@ -120,7 +123,7 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                         return cachedRouteTree;
                     }, []);
                     if (!routeTree) return App ? /*#__PURE__*/ jsx(App, {}) : null;
-                    const router = (0, __rspack_external_react.useMemo)(()=>{
+                    const router = useMemo(()=>{
                         const lifecycleContext = {
                             framework: 'tanstack',
                             phase: 'client-create',
@@ -142,6 +145,7 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                         const rewrite = createModernBasepathRewrite(_basename);
                         const serializationAdapters = getGlobalEnableRsc() ? getTanstackRscSerializationAdapters() : void 0;
                         cachedRouter = createRouter({
+                            ...getModernTanstackRouterFastDefaults(mergedConfig),
                             routeTree,
                             basepath: '/',
                             rewrite,
@@ -185,11 +189,8 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                         router,
                         runtimeContext: runtimeState
                     });
-                    const RouterContent = hasSSRBootstrap ? /*#__PURE__*/ jsx(__rspack_external_react.Suspense, {
-                        fallback: null,
-                        children: /*#__PURE__*/ jsx(RouterClient, {
-                            router: router
-                        })
+                    const RouterContent = hasSSRBootstrap ? /*#__PURE__*/ jsx(RouterClient, {
+                        router: router
                     }) : /*#__PURE__*/ jsx(RouterProvider, {
                         router: router
                     });

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

@@ -5,24 +5,41 @@ import { createRequestContext, storage } 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";
-import { attachRouterServerSsrUtils } from "@tanstack/react-router/ssr/server";
-import { Suspense, useContext } from "react";
+import { attachRouterServerSsrUtils } from "@tanstack/router-core/ssr/server";
+import { useContext } from "react";
 import { createModernBasepathRewrite } from "./basepathRewrite.mjs";
 import { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter } from "./hooks.mjs";
 import { applyRouterServerPrepareResult, createRouterServerSnapshot } from "./lifecycle.mjs";
 import { createRouteTreeFromRouteObjects, getModernRouteIdsFromMatches } from "./routeTree.mjs";
 import { createTanstackRscServerPayload, handleTanstackRscRedirect } from "./rsc/payloadRouter.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 Boolean(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?.({});
@@ -161,6 +178,7 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                 };
                 hooks.onBeforeCreateRouter.call(routerLifecycleContext);
                 const tanstackRouter = createRouter({
+                    ...getModernTanstackRouterFastDefaults(mergedConfig),
                     routeTree,
                     history,
                     basepath: '/',
@@ -206,10 +224,12 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                 await preloadMatchedRouteComponents(serverRouter);
                 context.ssrContext?.response.status(tanstackRouter.state.statusCode);
                 await serverRouter.serverSsr?.dehydrate?.();
-                await waitForRouterSerialization(serverRouter);
-                if (isRSCNavigation) setTanstackRscServerPayload(createTanstackRscServerPayload(serverRouter, {
-                    omitClientLoaderData: true
-                }));
+                if (isRSCNavigation) {
+                    await waitForRouterSerialization(serverRouter);
+                    setTanstackRscServerPayload(createTanstackRscServerPayload(serverRouter, {
+                        omitClientLoaderData: true
+                    }));
+                }
                 const ssrScriptTags = serverRouter.serverSsr?.takeBufferedScripts?.();
                 const hydrationScripts = routerManagedTagsToHtml(ssrScriptTags);
                 const matchedRouteIds = getModernRouteIdsFromMatches(serverRouter);
@@ -247,11 +267,8 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                         if (!router) return App ? /*#__PURE__*/ jsx(App, {
                             ...props
                         }) : null;
-                        const routerWrapper = /*#__PURE__*/ jsx(Suspense, {
-                            fallback: null,
-                            children: /*#__PURE__*/ jsx(RouterProvider, {
-                                router: router
-                            })
+                        const routerWrapper = /*#__PURE__*/ jsx(RouterProvider, {
+                            router: router
                         });
                         return App ? /*#__PURE__*/ jsx(App, {
                             children: routerWrapper

package/dist/esm/runtime/plugin.worker.mjs

@@ -0,0 +1 @@
+export { default, tanstackRouterPlugin } from "./plugin.node.mjs";

package/dist/esm/runtime/routeTree.mjs

@@ -1,4 +1,5 @@
 import { createRootRoute, createRoute, notFound, redirect } from "@tanstack/react-router";
+import { createElement } from "react";
 import { DefaultNotFound } from "./DefaultNotFound.mjs";
 import { isTanstackRscPayloadNavigationEnabled, loadTanstackRscRouteData } from "./rsc/payloadRouter.mjs";
 function createTanstackRoute(options) {
@@ -54,6 +55,40 @@ function normalizeModernLoaderResponse(result) {
     }
     return normalizeModernLoaderResult(result);
 }
+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 isAbsoluteUrl(value) {
     try {
         new URL(value);
@@ -126,7 +161,7 @@ function wrapModernLoader(modernRoute, modernLoader, revalidationState, options
             const signal = ctx?.abortController?.signal || ctx?.signal || new AbortController().signal;
             const baseRequest = ctx?.context?.request instanceof Request ? ctx.context.request : void 0;
             const href = 'string' == typeof ctx?.location ? ctx.location : ctx?.location?.publicHref || ctx?.location?.href || ctx?.location?.url?.href || '';
-            const request = baseRequest ? new Request(baseRequest, {
+            const request = void 0 !== baseRequest ? new Request(baseRequest, {
                 signal
             }) : createModernRequest(href, signal);
             const params = mapParamsForModernLoader({
@@ -191,7 +226,7 @@ function wrapRouteObjectLoader(route, revalidationState, options = {}) {
             const signal = ctx?.abortController?.signal || ctx?.signal || new AbortController().signal;
             const baseRequest = ctx?.context?.request instanceof Request ? ctx.context.request : void 0;
             const href = 'string' == typeof ctx?.location ? ctx.location : ctx?.location?.publicHref || ctx?.location?.href || ctx?.location?.url?.href || '';
-            const request = baseRequest ? new Request(baseRequest, {
+            const request = void 0 !== baseRequest ? new Request(baseRequest, {
                 signal
             }) : createModernRequest(href, signal);
             const params = mapParamsForRouteObjectLoader({
@@ -228,10 +263,18 @@ function wrapRouteObjectLoader(route, revalidationState, options = {}) {
 }
 function toRouteComponent(routeObject) {
     const route = routeObject;
+    const lazyImport = 'function' == typeof route.lazyImport ? route.lazyImport : void 0;
+    const fallbackComponent = route.Component ? route.Component : route.element ? ()=>route.element : void 0;
+    if (lazyImport && fallbackComponent) return createServerLazyImportComponent(lazyImport, fallbackComponent);
     if (route.Component) return route.Component;
     const element = route.element;
     if (element) return ()=>element;
 }
+function toModernRouteComponent(route) {
+    const component = route.component || void 0;
+    if ('function' == typeof route.lazyImport && component) return createServerLazyImportComponent(route.lazyImport, component);
+    return component;
+}
 function toErrorComponent(routeObject) {
     const route = routeObject;
     if (route.ErrorBoundary) return route.ErrorBoundary;
@@ -274,6 +317,8 @@ function createRouteFromRouteObject(opts) {
         component: toRouteComponent(routeObject),
         pendingComponent: toPendingComponent(routeObject),
         errorComponent: toErrorComponent(routeObject),
+        validateSearch: modernRouteObject.validateSearch,
+        loaderDeps: modernRouteObject.loaderDeps,
         wrapInSuspense: true,
         staticData: createRouteStaticData({
             modernRouteId: routeObject.id,
@@ -312,7 +357,7 @@ function createRouteFromModernRoute(opts) {
     const stableFallbackId = modernId || route._component || route.filename || route.data || ('function' == typeof route.loader ? route.id : void 0);
     const pendingComponent = route.loading || route.pendingComponent;
     const errorComponent = route.error || route.errorComponent;
-    const component = route.component;
+    const component = toModernRouteComponent(route);
     const modernLoader = route.loader;
     const modernAction = route.action;
     const modernShouldRevalidate = route.shouldRevalidate;
@@ -324,6 +369,8 @@ function createRouteFromModernRoute(opts) {
         component: component || void 0,
         pendingComponent: pendingComponent || void 0,
         errorComponent: errorComponent || void 0,
+        validateSearch: route.validateSearch,
+        loaderDeps: route.loaderDeps,
         wrapInSuspense: true,
         staticData: createRouteStaticData({
             modernRouteId: modernId,
@@ -359,7 +406,7 @@ function createRouteFromModernRoute(opts) {
 }
 function createRouteTreeFromModernRoutes(routes, options = {}) {
     const rootModern = routes.find((r)=>r && 'nested' === r.type && r.isRoot);
-    const rootComponent = rootModern?.component;
+    const rootComponent = rootModern ? toModernRouteComponent(rootModern) : void 0;
     const pendingComponent = rootModern?.loading;
     const errorComponent = rootModern?.error;
     const rootLoader = rootModern?.loader;
@@ -372,6 +419,8 @@ function createRouteTreeFromModernRoutes(routes, options = {}) {
         component: rootComponent || void 0,
         pendingComponent: pendingComponent || void 0,
         errorComponent: errorComponent || void 0,
+        validateSearch: rootModern?.validateSearch,
+        loaderDeps: rootModern?.loaderDeps,
         wrapInSuspense: true,
         notFoundComponent: DefaultNotFound,
         staticData: createRouteStaticData({
@@ -411,6 +460,8 @@ function createRouteTreeFromRouteObjects(routes, options = {}) {
         component: rootLikeRoute ? toRouteComponent(rootLikeRoute) : void 0,
         pendingComponent: rootLikeRoute ? toPendingComponent(rootLikeRoute) : void 0,
         errorComponent: rootLikeRoute ? toErrorComponent(rootLikeRoute) : void 0,
+        validateSearch: rootLikeRoute?.validateSearch,
+        loaderDeps: rootLikeRoute?.loaderDeps,
         wrapInSuspense: true,
         notFoundComponent: DefaultNotFound,
         staticData: createRouteStaticData({

package/dist/esm/runtime/types.mjs

@@ -0,0 +1,7 @@
+const modernTanstackRouterFastDefaults = {
+    defaultStructuralSharing: true
+};
+const getModernTanstackRouterFastDefaults = (config = {})=>({
+        defaultStructuralSharing: config.defaultStructuralSharing ?? modernTanstackRouterFastDefaults.defaultStructuralSharing
+    });
+export { getModernTanstackRouterFastDefaults, modernTanstackRouterFastDefaults };

package/dist/esm-node/cli/index.mjs

@@ -1,6 +1,7 @@
 import "node:module";
 import node_path from "node:path";
 import { NESTED_ROUTE_SPEC_FILE, filterRoutesForServer, fs } from "@modern-js/utils";
+import { createTanstackRsbuildRouteSplittingProfile, isTanstackStartRouteModuleSource, resolveTanstackRouteCodeSplittingEnabled } from "./routeSplitting.mjs";
 import { generateTanstackRouterTypesSourceForEntry, isTanstackRouterFrameworkEnabled } from "./tanstackTypes.mjs";
 import { __webpack_require__ } from "../rslib-runtime.mjs";
 import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
@@ -82,6 +83,7 @@ async function writeTanstackRouterTypesForEntries(opts) {
 function tanstackRouterPlugin(options = {}) {
     const routesDir = options.routesDir || DEFAULT_ROUTES_DIR;
     const generatedDirName = options.generatedDirName || DEFAULT_GENERATED_DIR_NAME;
+    const routeSplittingProfile = createTanstackRsbuildRouteSplittingProfile(options);
     return {
         name: '@modern-js/plugin-tanstack',
         required: [
@@ -117,6 +119,7 @@ function tanstackRouterPlugin(options = {}) {
                     entry: entry || getRuntimeRouterCli().isRouteEntry(entryPath, routesDir)
                 }));
             api.config(()=>({
+                    ...routeSplittingProfile.defaultConfig,
                     source: {
                         include: [
                             /[\\/]node_modules[\\/]@tanstack[\\/]react-router[\\/]/,
@@ -199,4 +202,4 @@ function tanstackRouterPlugin(options = {}) {
 }
 const src_cli = tanstackRouterPlugin;
 export default src_cli;
-export { generateTanstackRouterTypesSourceForEntry, isTanstackRouterFrameworkEnabled, tanstackRouterPlugin, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries };
+export { createTanstackRsbuildRouteSplittingProfile, generateTanstackRouterTypesSourceForEntry, isTanstackRouterFrameworkEnabled, isTanstackStartRouteModuleSource, resolveTanstackRouteCodeSplittingEnabled, tanstackRouterPlugin, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries };