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

package/dist/esm/core/server/string/index.mjs

@@ -1,12 +1,11 @@
 import { time } from "@modern-js/runtime-utils/time";
 import { SSR_HYDRATION_ID_PREFIX } from "@modern-js/utils/universal/constants";
 import server from "react-dom/server";
-import react_helmet from "react-helmet";
 import { RenderLevel } from "../../constants.mjs";
 import { getGlobalInternalRuntimeContext } from "../../context/index.mjs";
 import { wrapRuntimeContextProvider } from "../../react/wrapper.mjs";
 import { CHUNK_CSS_PLACEHOLDER, CHUNK_JS_PLACEHOLDER, HTML_PLACEHOLDER, SSR_DATA_PLACEHOLDER } from "../constants.mjs";
-import { createReplaceHelemt } from "../helmet.mjs";
+import { createReplaceHelemt, getHelmetData } from "../helmet.mjs";
 import { buildHtml } from "../shared.mjs";
 import { SSRErrors, SSRTimings } from "../tracer.mjs";
 import { getSSRConfigByEntry, safeReplace } from "../utils.mjs";
@@ -19,7 +18,7 @@ const renderString = async (request, serverRoot, options)=>{
         onTiming
     };
     const routerContext = runtimeContext.routerContext;
-    const { htmlTemplate, entryName, loadableStats, routeManifest } = resource;
+    const { htmlTemplate, entryName, loadableStats, routeManifest, moduleFederationCssAssets } = resource;
     const ssrConfig = getSSRConfigByEntry(entryName, config.ssr, config.ssrByEntries);
     const chunkSet = {
         renderLevel: RenderLevel.CLIENT_RENDER,
@@ -32,8 +31,10 @@ const renderString = async (request, serverRoot, options)=>{
             stats: loadableStats,
             nonce: config.nonce,
             routeManifest,
+            runtimeContext,
             template: htmlTemplate,
             entryName,
+            moduleFederationCssAssets,
             chunkSet,
             config
         }),
@@ -57,10 +58,10 @@ const renderString = async (request, serverRoot, options)=>{
     const rootElement = wrapRuntimeContextProvider(serverRoot, Object.assign(runtimeContext, {
         ssr: true
     }));
-    const html = await generateHtml(rootElement, htmlTemplate, chunkSet, collectors, runtimeContext.ssrContext?.htmlModifiers || [], tracer);
+    const html = await generateHtml(rootElement, htmlTemplate, chunkSet, collectors, runtimeContext.ssrContext?.htmlModifiers || [], runtimeContext, tracer);
     return html;
 };
-async function generateHtml(App, htmlTemplate, chunkSet, collectors, htmlModifiers, { onError, onTiming }) {
+async function generateHtml(App, htmlTemplate, chunkSet, collectors, htmlModifiers, runtimeContext, { onError, onTiming }) {
     let html = '';
     let helmetData;
     const finalApp = collectors.reduce((pre, creator)=>creator.collect?.(pre) || pre, App);
@@ -70,7 +71,7 @@ async function generateHtml(App, htmlTemplate, chunkSet, collectors, htmlModifie
             identifierPrefix: SSR_HYDRATION_ID_PREFIX
         });
         chunkSet.renderLevel = RenderLevel.SERVER_RENDER;
-        helmetData = react_helmet.renderStatic();
+        helmetData = getHelmetData(runtimeContext);
         const cost = end();
         onTiming(SSRTimings.RENDER_HTML, cost);
     } catch (e) {

package/dist/esm/core/server/string/loadable.mjs

@@ -1,4 +1,6 @@
 import { ChunkExtractor } from "@loadable/server";
+import { getRouterMatchedRouteIds } from "../../../router/runtime/lifecycle.mjs";
+import { createFederatedCssLinks } from "../federatedCss.mjs";
 import { attributesToString, checkIsNode } from "../utils.mjs";
 const extname = (uri)=>{
     if ('string' != typeof uri || !uri.includes('.')) return '';
@@ -21,6 +23,20 @@ class LoadableCollector {
         const { routeManifest, entryName } = this.options;
         return routeManifest?.routeAssets?.[entryName]?.assets;
     }
+    getMatchedRouteChunks() {
+        const { routeManifest, runtimeContext } = this.options;
+        const routeAssets = routeManifest?.routeAssets;
+        if (!routeAssets) return [];
+        const matchedRouteIds = getRouterMatchedRouteIds(runtimeContext) ?? [];
+        return matchedRouteIds.flatMap((routeId)=>{
+            const routeAsset = routeAssets[routeId];
+            return (routeAsset?.assets ?? []).map((asset)=>({
+                    filename: asset.replace(/^\//, ''),
+                    path: asset,
+                    url: asset
+                }));
+        });
+    }
     collect(comopnent) {
         const { stats, entryName } = this.options;
         if (!stats) return comopnent;
@@ -33,20 +49,21 @@ class LoadableCollector {
         return this.extractor.collectChunks(comopnent);
     }
     async effect() {
-        if (!this.extractor) return;
         const { extractor, options } = this;
         const { entryName, config } = options;
         const asyncChunks = [];
-        if (config.enableAsyncEntry) try {
+        if (extractor && config.enableAsyncEntry) try {
             asyncChunks.push(...extractor.getChunkAssets([
                 `async-${entryName}`
             ]));
         } catch (e) {}
-        const chunks = [].concat(asyncChunks).concat(extractor.getChunkAssets(extractor.chunks));
+        const chunks = [].concat(asyncChunks).concat(extractor ? extractor.getChunkAssets(extractor.chunks) : []).concat(this.getMatchedRouteChunks());
         const scriptChunks = generateChunks(chunks, 'js');
         const styleChunks = generateChunks(chunks, 'css');
-        this.emitLoadableScripts(extractor);
-        await this.emitScriptAssets(scriptChunks);
+        if (extractor) {
+            this.emitLoadableScripts(extractor);
+            await this.emitScriptAssets(scriptChunks);
+        }
         await this.emitStyleAssets(styleChunks);
     }
     emitLoadableScripts(extractor) {
@@ -81,19 +98,28 @@ class LoadableCollector {
         chunkSet.jsChunk += scripts.filter((script)=>Boolean(script)).join('');
     }
     async emitStyleAssets(chunks) {
-        const { template, chunkSet, config, entryName } = this.options;
+        const { template, chunkSet, config, moduleFederationCssAssets } = this.options;
         const { inlineStyles } = config;
         const atrributes = attributesToString(this.generateAttributes());
         const linkRegExp = /<link .*?href="([^"]+)".*?>/g;
         const matchs = template.matchAll(linkRegExp);
         const existedLinks = [];
         for (const match of matchs)existedLinks.push(match[1]);
-        const css = await Promise.all(chunks.filter((chunk)=>!existedLinks.includes(chunk.url) && !this.existsAssets?.includes(chunk.path)).map(async (chunk)=>{
+        const emittedChunks = chunks.filter((chunk)=>!existedLinks.includes(chunk.url) && !this.existsAssets?.includes(chunk.path));
+        const css = await Promise.all(emittedChunks.map(async (chunk)=>{
             const link = `<link${atrributes} href="${chunk.url}" rel="stylesheet" />`;
             if (checkIsNode() && checkIsInline(chunk, inlineStyles)) return readAsset(chunk).then((content)=>`<style>${content}</style>`).catch((_)=>link);
             return link;
         }));
         chunkSet.cssChunk += css.filter((css)=>Boolean(css)).join('');
+        chunkSet.cssChunk += createFederatedCssLinks(moduleFederationCssAssets, {
+            template,
+            attributes: this.generateAttributes(),
+            existingAssets: [
+                ...existedLinks,
+                ...emittedChunks.map((chunk)=>chunk.url)
+            ]
+        });
     }
     generateAttributes(extraAtr = {}) {
         const { config } = this.options;

package/dist/esm/exports/head.mjs

@@ -1,5 +1,190 @@
 "use client";
-import react_helmet, { Helmet } from "react-helmet";
-const head = react_helmet;
-export default head;
-export { Helmet };
+import react from "react";
+import { Helmet, HelmetData, HelmetProvider } from "react-helmet-async";
+import { InternalRuntimeContext } from "../core/context/index.mjs";
+const ATTRIBUTE_NAME_MAP = {
+    charSet: 'charset',
+    className: 'class',
+    contentEditable: 'contenteditable',
+    httpEquiv: 'http-equiv',
+    itemProp: 'itemprop',
+    tabIndex: 'tabindex'
+};
+const escapeHtml = (value)=>String(value).replaceAll('&', '&amp;').replaceAll('"', '&quot;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
+const toHtmlAttributeName = (name)=>ATTRIBUTE_NAME_MAP[name] ?? name;
+const attributesToString = (attributes, includeHelmetAttribute = false)=>{
+    const pairs = [];
+    if (includeHelmetAttribute) pairs.push('data-rh="true"');
+    for (const [name, value] of Object.entries(attributes ?? {})){
+        if (false === value || null == value) continue;
+        const htmlName = toHtmlAttributeName(name);
+        if (true === value) pairs.push(htmlName);
+        else pairs.push(`${htmlName}="${escapeHtml(value)}"`);
+    }
+    return pairs.join(' ');
+};
+const createDatum = (tagName, tags)=>({
+        toComponent: ()=>[],
+        toString: ()=>tags.map((tag)=>{
+                const attrs = attributesToString(tag, true);
+                if ("script" === tagName && 'string' == typeof tag.innerHTML) return `<script ${attrs}>${tag.innerHTML}</script>`;
+                if ('style' === tagName && 'string' == typeof tag.cssText) return `<style ${attrs}>${tag.cssText}</style>`;
+                if ("noscript" === tagName && 'string' == typeof tag.innerHTML) return `<noscript ${attrs}>${tag.innerHTML}</noscript>`;
+                return `<${tagName} ${attrs}>`;
+            }).join('')
+    });
+const createAttributeDatum = (attributes)=>({
+        toComponent: ()=>attributes,
+        toString: ()=>attributesToString(attributes)
+    });
+const createTitleDatum = (title, attributes)=>({
+        toComponent: ()=>[],
+        toString: ()=>{
+            if (!title) return '';
+            const attrs = attributesToString(attributes, true);
+            return `<title ${attrs}>${escapeHtml(title)}</title>`;
+        }
+    });
+const createEmptyHelmetState = ()=>({
+        base: createDatum('base', []),
+        bodyAttributes: createAttributeDatum({}),
+        htmlAttributes: createAttributeDatum({}),
+        link: createDatum('link', []),
+        meta: createDatum('meta', []),
+        noscript: createDatum("noscript", []),
+        priority: createDatum('meta', []),
+        script: createDatum("script", []),
+        style: createDatum('style', []),
+        title: createTitleDatum(void 0, {})
+    });
+const mergeAttributes = (current, next)=>({
+        ...current,
+        ...next ?? {}
+    });
+const collectChildren = (children, draft)=>{
+    react.Children.forEach(children, (child)=>{
+        if (!react.isValidElement(child)) return;
+        if (child.type === react.Fragment) return void collectChildren(child.props.children, draft);
+        if ('string' != typeof child.type) return;
+        const { children: nestedChildren, ...props } = child.props;
+        if ('title' === child.type) {
+            draft.title = react.Children.toArray(nestedChildren).join('');
+            draft.titleAttributes = mergeAttributes(draft.titleAttributes, props);
+            return;
+        }
+        if ('html' === child.type || 'body' === child.type) return;
+        if ('base' === child.type || 'link' === child.type || 'meta' === child.type || "noscript" === child.type || "script" === child.type || 'style' === child.type) {
+            const tag = {
+                ...props
+            };
+            if (("script" === child.type || 'style' === child.type || "noscript" === child.type) && 'string' == typeof nestedChildren) tag['style' === child.type ? 'cssText' : 'innerHTML'] = nestedChildren;
+            draft[child.type].push(tag);
+        }
+    });
+};
+const collectHelmetProps = (current, props)=>{
+    const baseState = current ?? createEmptyHelmetState();
+    const draft = {
+        base: [
+            ...props.base ? [
+                props.base
+            ] : []
+        ],
+        bodyAttributes: props.bodyAttributes,
+        htmlAttributes: props.htmlAttributes,
+        link: [
+            ...props.link ?? []
+        ],
+        meta: [
+            ...props.meta ?? []
+        ],
+        noscript: [
+            ...props.noscript ?? []
+        ],
+        script: [
+            ...props.script ?? []
+        ],
+        style: [
+            ...props.style ?? []
+        ],
+        title: 'string' == typeof props.title ? props.title : Array.isArray(props.title) ? props.title.join('') : void 0,
+        titleAttributes: props.titleAttributes ?? {}
+    };
+    collectChildren(props.children, draft);
+    const title = draft.title && props.titleTemplate ? props.titleTemplate.replaceAll('%s', draft.title) : draft.title ?? props.defaultTitle;
+    return {
+        base: createDatum('base', [
+            ...baseState.__baseTags ?? [],
+            ...draft.base
+        ]),
+        bodyAttributes: createAttributeDatum(mergeAttributes(baseState.__bodyAttributes ?? {}, draft.bodyAttributes)),
+        htmlAttributes: createAttributeDatum(mergeAttributes(baseState.__htmlAttributes ?? {}, draft.htmlAttributes)),
+        link: createDatum('link', [
+            ...baseState.__linkTags ?? [],
+            ...draft.link
+        ]),
+        meta: createDatum('meta', [
+            ...baseState.__metaTags ?? [],
+            ...draft.meta
+        ]),
+        noscript: createDatum("noscript", [
+            ...baseState.__noscriptTags ?? [],
+            ...draft.noscript
+        ]),
+        priority: createDatum('meta', []),
+        script: createDatum("script", [
+            ...baseState.__scriptTags ?? [],
+            ...draft.script
+        ]),
+        style: createDatum('style', [
+            ...baseState.__styleTags ?? [],
+            ...draft.style
+        ]),
+        title: createTitleDatum(title ?? baseState.__title, mergeAttributes(baseState.__titleAttributes ?? {}, draft.titleAttributes)),
+        __baseTags: [
+            ...baseState.__baseTags ?? [],
+            ...draft.base
+        ],
+        __bodyAttributes: mergeAttributes(baseState.__bodyAttributes ?? {}, draft.bodyAttributes),
+        __htmlAttributes: mergeAttributes(baseState.__htmlAttributes ?? {}, draft.htmlAttributes),
+        __linkTags: [
+            ...baseState.__linkTags ?? [],
+            ...draft.link
+        ],
+        __metaTags: [
+            ...baseState.__metaTags ?? [],
+            ...draft.meta
+        ],
+        __noscriptTags: [
+            ...baseState.__noscriptTags ?? [],
+            ...draft.noscript
+        ],
+        __scriptTags: [
+            ...baseState.__scriptTags ?? [],
+            ...draft.script
+        ],
+        __styleTags: [
+            ...baseState.__styleTags ?? [],
+            ...draft.style
+        ],
+        __title: title ?? baseState.__title,
+        __titleAttributes: mergeAttributes(baseState.__titleAttributes ?? {}, draft.titleAttributes)
+    };
+};
+const head_Helmet = (props)=>{
+    const runtimeContext = react.useContext(InternalRuntimeContext);
+    if (runtimeContext && !runtimeContext.isBrowser) {
+        runtimeContext._helmetContext ??= {};
+        runtimeContext._helmetContext.helmet = collectHelmetProps(runtimeContext._helmetContext.helmet ?? void 0, props);
+        return null;
+    }
+    return react.createElement(Helmet, props);
+};
+const head = {
+    Helmet: head_Helmet,
+    HelmetData: HelmetData,
+    HelmetProvider: HelmetProvider
+};
+const exports_head = head;
+export default exports_head;
+export { HelmetData, HelmetProvider, head_Helmet as Helmet };

package/dist/esm/router/cli/code/tanstackTypes.mjs

@@ -77,9 +77,21 @@ async function generateTanstackRouterTypesSourceForEntry(opts) {
     const topLevel = rootModern ? rootModern.children || [] : routes;
     const imports = [];
     const statements = [];
+    const componentImportMap = new Map();
     const loaderImportMap = new Map();
+    const usedRouteVarNames = new Set();
+    let componentIndex = 0;
     let loaderIndex = 0;
     let routeIndex = 0;
+    const getImportNameForComponent = (componentPath)=>{
+        if ('string' != typeof componentPath || 0 === componentPath.length) return null;
+        const existing = componentImportMap.get(componentPath);
+        if (existing) return existing;
+        const componentName = `component_${componentIndex++}`;
+        imports.push(`import ${componentName} from ${quote(componentPath)};`);
+        componentImportMap.set(componentPath, componentName);
+        return componentName;
+    };
     const getImportNamesForLoader = async (aliasedNoExtPath, inline, hasAction)=>{
         const key = `${inline ? 'inline' : 'default'}:${hasAction ? 'action' : 'loader'}:${aliasedNoExtPath}`;
         const existing = loaderImportMap.get(key);
@@ -111,10 +123,17 @@ async function generateTanstackRouterTypesSourceForEntry(opts) {
             actionName
         };
     };
+    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;
@@ -129,6 +148,8 @@ async function generateTanstackRouterTypesSourceForEntry(opts) {
         const routeOpts = [
             `getParentRoute: () => ${parentVar},`
         ];
+        const componentName = getImportNameForComponent(route._component);
+        if (componentName) routeOpts.push(`component: ${componentName},`);
         if (isPathlessLayout(route)) {
             const id = route.id;
             routeOpts.push(`id: ${quote(id || 'pathless')},`);
@@ -143,14 +164,16 @@ async function generateTanstackRouterTypesSourceForEntry(opts) {
             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;
     };
@@ -164,6 +187,8 @@ async function generateTanstackRouterTypesSourceForEntry(opts) {
             route
         })));
     const rootOpts = [];
+    const rootComponentName = getImportNameForComponent(rootModern?._component);
+    if (rootComponentName) rootOpts.push(`component: ${rootComponentName},`);
     if (rootLoaderName) rootOpts.push(`loader: modernLoaderToTanstack({ hasSplat: false }, ${rootLoaderName}),`);
     const routerGenTs = `/* eslint-disable */
 // This file is auto-generated by Modern.js. Do not edit manually.
@@ -197,7 +222,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 });
@@ -223,21 +248,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>(
@@ -246,57 +337,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 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();
-        }
-      }
+      const params = mapParamsForModernLoader(getLoaderParams(ctx), opts.hasSplat);
 
-      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);
     }
   };
 }

package/dist/esm/router/cli/code/templates.mjs

@@ -170,16 +170,9 @@ const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry,
                     webpackChunkName: true
                 });
                 component = 'string' === ssrMode ? `loadable(${lazyImport})` : `lazy(${lazyImport})`;
-            } else if ('string' === ssrMode) {
+            } else {
                 components.push(route._component);
                 component = `component_${components.length - 1}`;
-            } else {
-                lazyImport = createLazyImport({
-                    componentPath: route._component,
-                    routeId: route.id,
-                    eager: true
-                });
-                component = `lazy(${lazyImport})`;
             }
         } else if (route._component) if (splitRouteChunks) {
             lazyImport = `() => import('${route._component}')`;

package/dist/esm/router/runtime/tanstack/plugin.mjs

@@ -3,14 +3,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 { InternalRuntimeContext, getGlobalEnableRsc, getGlobalLayoutApp, getGlobalRoutes } from "../../../core/context/index.mjs";
 import { onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeHydrateRouter } from "../hooks.mjs";
 import { applyRouterRuntimeState } from "../lifecycle.mjs";
 import { createRouteObjectsFromConfig, urlJoin } from "../utils.mjs";
 import { createModernBasepathRewrite } from "./basepathRewrite.mjs";
+import { Link } from "./prefetchLink.mjs";
 import { createRouteTreeFromRouteObjects } from "./routeTree.mjs";
 import { getTanstackRscSerializationAdapters } from "./rsc/client.mjs";
-import * as __rspack_external_react from "react";
 const BLOCKING_SUBSCRIBE_SYMBOL = Symbol.for('@modern-js/plugin-runtime:tanstack-blocking-subscribe');
 const BLOCKING_STATE_SYMBOL = Symbol.for('@modern-js/plugin-runtime:tanstack-blocking-state');
 function normalizeBase(b) {
@@ -70,6 +71,7 @@ const tanstackRouterPlugin = (userConfig = {})=>({
                     }
                 }
                 context.router = {
+                    Link: Link,
                     useMatches: useMatches,
                     useLocation: useLocation,
                     useNavigate: useNavigate,
@@ -104,10 +106,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;
@@ -115,7 +117,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',
@@ -180,11 +182,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
                     });