@bleedingdev/modern-js-plugin-tanstack 3.2.0-ultramodern.12 → 3.2.0-ultramodern.121

package/src/runtime/plugin.node.tsx

@@ -1,23 +1,17 @@
 // @effect-diagnostics asyncFunction:off newPromise:off strictBooleanExpressions:off unnecessaryArrowBlock:off
 /// <reference path="./ssr-shim.d.ts" />
 
-import type { Plugin, RuntimePluginExtends } from '@modern-js/plugin';
-import type { RuntimePluginAPI } from '@modern-js/plugin/runtime';
 import {
   getGlobalEnableRsc,
-  getGlobalLayoutApp,
-  getGlobalRoutes,
   InternalRuntimeContext,
   type ServerPayload,
   type TInternalRuntimeContext,
 } from '@modern-js/runtime/context';
-import { merge } from '@modern-js/runtime-utils/merge';
 import {
   createRequestContext,
   type RequestContext,
   storage,
 } from '@modern-js/runtime-utils/node';
-import type { RouteObject } from '@modern-js/runtime-utils/router';
 import { time } from '@modern-js/runtime-utils/time';
 import { LOADER_REPORTER_NAME } from '@modern-js/utils/universal/constants';
 import {
@@ -26,24 +20,24 @@ import {
   createRouter,
   RouterProvider,
 } from '@tanstack/react-router';
-import { attachRouterServerSsrUtils } from '@tanstack/react-router/ssr/server';
+import { attachRouterServerSsrUtils } from '@tanstack/router-core/ssr/server';
 import type React from 'react';
-import { Suspense, useContext } from 'react';
+import { useContext } from 'react';
 import { createModernBasepathRewrite } from './basepathRewrite';
-import {
-  modifyRoutes as modifyRoutesHook,
-  onAfterCreateRouter as onAfterCreateRouterHook,
-  onAfterHydrateRouter as onAfterHydrateRouterHook,
-  onBeforeCreateRouter as onBeforeCreateRouterHook,
-  onBeforeCreateRoutes as onBeforeCreateRoutesHook,
-  onBeforeHydrateRouter as onBeforeHydrateRouterHook,
-  type RouterExtendsHooks,
-} from './hooks';
+import { routerProviderRegistryHooks } from './hooks';
+import { wrapTanstackSsrHydrationBoundary } from './hydrationBoundary';
 import {
   applyRouterServerPrepareResult,
   createRouterServerSnapshot,
+  getRouterRuntimeState,
   type RouterLifecycleContext,
 } from './lifecycle';
+import {
+  getFinalRouteConfig,
+  getMergedRouterConfig,
+  type TanstackRouterPluginAPI,
+  type TanstackRouterRuntimePlugin,
+} from './pluginCore';
 import {
   createRouteTreeFromRouteObjects,
   getModernRouteIdsFromMatches,
@@ -52,7 +46,11 @@ import {
   createTanstackRscServerPayload,
   handleTanstackRscRedirect,
 } from './rsc/payloadRouter';
-import type { InternalRouterServerSnapshot, RouterConfig } from './types';
+import {
+  getModernTanstackRouterFastDefaults,
+  type InternalRouterServerSnapshot,
+  type RouterConfig,
+} from './types';
 import { createRouteObjectsFromConfig, urlJoin } from './utils';
 
 type ModernTanstackRouterContext = {
@@ -60,25 +58,6 @@ type ModernTanstackRouterContext = {
   requestContext: RequestContext<Record<string, unknown>>;
 };
 
-type TanstackRouterRuntimeConfig = {
-  plugins?: TanstackRouterRuntimePlugin[];
-  router?: Partial<RouterConfig>;
-  [key: string]: unknown;
-};
-
-type TanstackRouterRuntimeExtends = Required<
-  RuntimePluginExtends<TanstackRouterRuntimeConfig, TInternalRuntimeContext>
-> & {
-  extendHooks: RouterExtendsHooks;
-};
-
-type TanstackRouterPluginAPI = RuntimePluginAPI<TanstackRouterRuntimeExtends>;
-
-type TanstackRouterRuntimePlugin = Plugin<
-  TanstackRouterPluginAPI,
-  TInternalRuntimeContext
->;
-
 const setTanstackRscServerPayload = (payload: ServerPayload) => {
   const storageContext = storage.useContext?.() as
     | { serverPayload?: ServerPayload }
@@ -119,6 +98,17 @@ type PreloadableRouteComponent = {
   preload?: (props?: Record<string, unknown>) => Promise<unknown> | unknown;
 };
 
+type ReactLazyRouteComponent = {
+  _init?: (payload: unknown) => unknown;
+  _payload?: unknown;
+};
+
+function isPromiseLike(value: unknown): value is PromiseLike<unknown> {
+  return Boolean(
+    value && typeof (value as PromiseLike<unknown>).then === 'function',
+  );
+}
+
 type TanstackRouterWithServerSsr = AnyRouter & {
   resolveRedirect?: (redirect: Response) => Response;
   routesById?: Record<string, RouterRouteWithOptions>;
@@ -149,7 +139,38 @@ function isPreloadableRouteComponent(
   );
 }
 
+function isReactLazyRouteComponent(
+  component: unknown,
+): component is ReactLazyRouteComponent {
+  return (
+    component !== null &&
+    component !== undefined &&
+    typeof component === 'object' &&
+    typeof (component as ReactLazyRouteComponent)._init === 'function' &&
+    '_payload' in component
+  );
+}
+
+async function preloadReactLazyRouteComponent(
+  component: ReactLazyRouteComponent,
+) {
+  try {
+    component._init?.(component._payload);
+  } catch (thrown) {
+    if (!isPromiseLike(thrown)) {
+      throw thrown;
+    }
+    await thrown;
+    component._init?.(component._payload);
+  }
+}
+
 async function preloadRouteComponent(component: unknown) {
+  if (isReactLazyRouteComponent(component)) {
+    await preloadReactLazyRouteComponent(component);
+    return;
+  }
+
   if (!isPreloadableRouteComponent(component)) {
     return;
   }
@@ -253,20 +274,6 @@ function createGetSsrHref(request: Request): string {
   return `${url.pathname}${url.search}${url.hash}`;
 }
 
-function stripSyntheticNotFoundRoute(routes: RouteObject[]): RouteObject[] {
-  return routes
-    .filter(route => !(route.path === '*' && !route.id && !route.loader))
-    .map(route => {
-      if (!route.children?.length) {
-        return route;
-      }
-      return {
-        ...route,
-        children: stripSyntheticNotFoundRoute(route.children),
-      };
-    });
-}
-
 function collectRouterErrors(
   tanstackRouter: AnyRouter,
 ): Record<string, unknown> | undefined {
@@ -298,35 +305,18 @@ export const tanstackRouterPlugin = (
 ): TanstackRouterRuntimePlugin => {
   const plugin: TanstackRouterRuntimePlugin = {
     name: '@modern-js/plugin-router-tanstack',
-    registryHooks: {
-      modifyRoutes: modifyRoutesHook,
-      onAfterCreateRouter: onAfterCreateRouterHook,
-      onAfterHydrateRouter: onAfterHydrateRouterHook,
-      onBeforeCreateRouter: onBeforeCreateRouterHook,
-      onBeforeCreateRoutes: onBeforeCreateRoutesHook,
-      onBeforeHydrateRouter: onBeforeHydrateRouterHook,
-    },
+    registryHooks: routerProviderRegistryHooks,
     setup: (api: TanstackRouterPluginAPI) => {
       api.onBeforeRender(async (context, interrupt) => {
-        const pluginConfig = api.getRuntimeConfig() as {
-          router?: Partial<RouterConfig>;
-        };
-        const mergedConfig = merge(
-          pluginConfig.router || {},
-          userConfig,
-        ) as RouterConfig;
+        const mergedConfig = getMergedRouterConfig(api, userConfig);
         const serializationAdapters = getGlobalEnableRsc()
           ? (await import('./rsc/server')).getTanstackRscSerializationAdapters()
           : undefined;
         const enableRsc = getGlobalEnableRsc();
 
-        const { basename = '', routesConfig, createRoutes } = mergedConfig;
+        const { basename = '', createRoutes } = mergedConfig;
 
-        const finalRouteConfig = {
-          routes: getGlobalRoutes(),
-          globalApp: getGlobalLayoutApp(),
-          ...routesConfig,
-        };
+        const finalRouteConfig = getFinalRouteConfig(mergedConfig);
 
         if (!finalRouteConfig.routes && !createRoutes) {
           return;
@@ -341,12 +331,7 @@ export const tanstackRouterPlugin = (
               routesConfig: finalRouteConfig,
               ssrMode: context.ssrContext?.mode,
             }) || [];
-        const normalizedRouteObjects = createRoutes
-          ? routeObjects
-          : stripSyntheticNotFoundRoute(routeObjects);
-        const modifiedRouteObjects = hooks.modifyRoutes.call(
-          normalizedRouteObjects,
-        );
+        const modifiedRouteObjects = hooks.modifyRoutes.call(routeObjects);
 
         if (!modifiedRouteObjects.length) {
           return;
@@ -398,6 +383,7 @@ export const tanstackRouterPlugin = (
         hooks.onBeforeCreateRouter.call(routerLifecycleContext);
 
         const tanstackRouter = createRouter({
+          ...getModernTanstackRouterFastDefaults(mergedConfig),
           routeTree,
           history,
           basepath: '/',
@@ -458,9 +444,12 @@ export const tanstackRouterPlugin = (
         context.ssrContext?.response.status(tanstackRouter.state.statusCode);
 
         await serverRouter.serverSsr?.dehydrate?.();
-        await waitForRouterSerialization(serverRouter);
 
         if (isRSCNavigation) {
+          // RSC navigations consume the server payload directly. Normal HTML SSR
+          // emits the buffered bootstrap script below and must not wait here
+          // because Modern's non-streaming hook has not rendered the app yet.
+          await waitForRouterSerialization(serverRouter);
           setTanstackRscServerPayload(
             createTanstackRscServerPayload(serverRouter, {
               omitClientLoaderData: true,
@@ -509,16 +498,14 @@ export const tanstackRouterPlugin = (
             const context = useContext(
               InternalRuntimeContext,
             ) as unknown as TInternalRuntimeContext;
-            const router =
-              context.routerInstance ?? context.routerRuntime?.instance;
+            const router = getRouterRuntimeState(context)?.instance;
             if (!router) {
               return App ? <App {...props} /> : null;
             }
 
-            const routerWrapper = (
-              <Suspense fallback={null}>
-                <RouterProvider router={router as AnyRouter} />
-              </Suspense>
+            const routerWrapper = wrapTanstackSsrHydrationBoundary(
+              <RouterProvider router={router as AnyRouter} />,
+              true,
             );
 
             return App ? <App>{routerWrapper}</App> : routerWrapper;