@bleedingdev/modern-js-plugin-tanstack 3.2.0-ultramodern.99 → 3.4.0-ultramodern.0

package/src/runtime/plugin.tsx

@@ -1,16 +1,11 @@
 // @effect-diagnostics globalConsole:off strictBooleanExpressions: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 TInternalRuntimeContext,
 } from '@modern-js/runtime/context';
-import { merge } from '@modern-js/runtime-utils/merge';
 import type { RouteObject } from '@modern-js/runtime-utils/router';
 import { normalizePathname } from '@modern-js/runtime-utils/url';
 import {
@@ -24,23 +19,21 @@ import {
   useNavigate,
   useRouter,
 } from '@tanstack/react-router';
-import { RouterClient } from '@tanstack/react-router/ssr/client';
 import { useContext, useMemo } 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 {
   applyRouterRuntimeState,
   type RouterLifecycleContext,
 } from './lifecycle';
+import { withModernRouteMatchContext } from './outlet';
+import {
+  getFinalRouteConfig,
+  getMergedRouterConfig,
+  type TanstackRouterPluginAPI,
+  type TanstackRouterRuntimePlugin,
+} from './pluginCore';
 import { Link } from './prefetchLink';
 import { createRouteTreeFromRouteObjects } from './routeTree';
 import { getTanstackRscSerializationAdapters } from './rsc/client';
@@ -56,7 +49,6 @@ const BLOCKING_SUBSCRIBE_SYMBOL = Symbol.for(
 const BLOCKING_STATE_SYMBOL = Symbol.for(
   '@modern-js/plugin-tanstack:blocking-state',
 );
-
 type TanstackRouterWithSubscribe = {
   [BLOCKING_STATE_SYMBOL]?: () => boolean;
   [BLOCKING_SUBSCRIBE_SYMBOL]?: boolean;
@@ -70,24 +62,29 @@ type WindowWithTanstackSsr = Window & {
   $_TSR?: unknown;
 };
 
-type TanstackRouterRuntimeConfig = {
-  plugins?: TanstackRouterRuntimePlugin[];
-  router?: Partial<RouterConfig>;
-  [key: string]: unknown;
+type RouteComponentPreloadable = {
+  load?: () => Promise<unknown>;
+  preload?: () => Promise<unknown>;
 };
 
-type TanstackRouterRuntimeExtends = Required<
-  RuntimePluginExtends<TanstackRouterRuntimeConfig, TInternalRuntimeContext>
-> & {
-  extendHooks: RouterExtendsHooks;
+type ModernRouteModule = {
+  Component?: unknown;
+  default?: unknown;
 };
 
-type TanstackRouterPluginAPI = RuntimePluginAPI<TanstackRouterRuntimeExtends>;
-
-type TanstackRouterRuntimePlugin = Plugin<
-  TanstackRouterPluginAPI,
-  TInternalRuntimeContext
->;
+type RouterWithPreloadableRoutes = AnyRouter & {
+  routesById?: Record<
+    string,
+    {
+      options?: {
+        component?: unknown;
+        staticData?: {
+          modernRouteId?: string;
+        };
+      };
+    }
+  >;
+};
 
 function normalizeBase(b: string) {
   if (b.length > 1 && b.endsWith('/')) {
@@ -133,18 +130,155 @@ function wrapRouterSubscribeWithBlockState(
   target[BLOCKING_SUBSCRIBE_SYMBOL] = true;
 }
 
-function stripSyntheticNotFoundRoute(routes: RouteObject[]): RouteObject[] {
-  return routes
-    .filter(route => !(route.path === '*' && !route.id && !route.loader))
-    .map(route => {
-      if (!route.children?.length) {
-        return route;
+type RouterHydrationRecord = {
+  error?: unknown;
+  promise: Promise<unknown>;
+  status: 'pending' | 'fulfilled' | 'rejected';
+};
+
+const routerHydrationRecords = new WeakMap<AnyRouter, RouterHydrationRecord>();
+const routeModulesKey = '_routeModules';
+
+function pickRouteModuleComponent(
+  routeModule: unknown,
+  seen: Set<unknown> = new Set(),
+): unknown {
+  if (
+    typeof routeModule === 'function' ||
+    (routeModule &&
+      typeof routeModule === 'object' &&
+      '$$typeof' in routeModule)
+  ) {
+    return routeModule;
+  }
+
+  if (!routeModule || typeof routeModule !== 'object') {
+    return undefined;
+  }
+  if (seen.has(routeModule)) {
+    return undefined;
+  }
+  seen.add(routeModule);
+
+  const module = routeModule as ModernRouteModule;
+  for (const candidate of [module.default, module.Component]) {
+    const component = pickRouteModuleComponent(candidate, seen);
+    if (component) {
+      return component;
+    }
+  }
+
+  return undefined;
+}
+
+function getCachedRouteModule(routeId: string) {
+  if (typeof window === 'undefined') {
+    return undefined;
+  }
+
+  return (window as unknown as Record<string, Record<string, unknown>>)[
+    routeModulesKey
+  ]?.[routeId];
+}
+
+function preloadHydratedRouteComponents(router: AnyRouter): Promise<void> {
+  const preloadableRouter = router as RouterWithPreloadableRoutes;
+  const routesById = preloadableRouter.routesById || {};
+  const matches = preloadableRouter.stores.matches.get() as Array<{
+    routeId?: string;
+  }>;
+
+  return Promise.all(
+    matches.map(match => {
+      if (match.routeId === undefined || match.routeId === '') {
+        return undefined;
       }
-      return {
-        ...route,
-        children: stripSyntheticNotFoundRoute(route.children),
-      };
-    });
+
+      const route = routesById[match.routeId];
+      const component = route?.options?.component as RouteComponentPreloadable;
+      const preload = component?.load || component?.preload;
+      if (typeof preload !== 'function') {
+        return undefined;
+      }
+
+      return Promise.resolve(preload.call(component)).then(routeModule => {
+        const modernRouteId = route?.options?.staticData?.modernRouteId;
+        const cachedRouteModule =
+          typeof modernRouteId === 'string' && modernRouteId !== ''
+            ? getCachedRouteModule(modernRouteId)
+            : undefined;
+        const resolvedComponent = pickRouteModuleComponent(
+          cachedRouteModule ?? routeModule,
+        );
+        if (
+          resolvedComponent !== undefined &&
+          typeof modernRouteId === 'string' &&
+          modernRouteId !== ''
+        ) {
+          route.options.component = withModernRouteMatchContext(
+            resolvedComponent,
+            modernRouteId,
+          );
+        }
+      });
+    }),
+  ).then(() => undefined);
+}
+
+function hydrateTanstackRouter(router: AnyRouter) {
+  return import('@tanstack/react-router/ssr/client').then(({ hydrate }) =>
+    hydrate(router),
+  );
+}
+
+function getTanstackSsrHydrationRecord(router: AnyRouter) {
+  const existingHydrationRecord = routerHydrationRecords.get(router);
+  if (existingHydrationRecord !== undefined) {
+    return existingHydrationRecord;
+  }
+
+  const hydrationRecord: RouterHydrationRecord = {
+    promise: Promise.resolve(),
+    status: 'pending',
+  };
+  routerHydrationRecords.set(router, hydrationRecord);
+  try {
+    hydrationRecord.promise = hydrateTanstackRouter(router)
+      .then(value => preloadHydratedRouteComponents(router).then(() => value))
+      .then(
+        value => {
+          hydrationRecord.status = 'fulfilled';
+          return value;
+        },
+        error => {
+          hydrationRecord.status = 'rejected';
+          hydrationRecord.error = error;
+          throw error;
+        },
+      );
+  } catch (error) {
+    hydrationRecord.status = 'rejected';
+    hydrationRecord.error = error;
+    hydrationRecord.promise = Promise.reject(error);
+    hydrationRecord.promise.catch(() => {});
+  }
+  return hydrationRecord;
+}
+
+function getTanstackSsrHydrationPromise(router: AnyRouter) {
+  return getTanstackSsrHydrationRecord(router).promise;
+}
+
+function hasTanstackSsrHydrationRecord(router: AnyRouter) {
+  return routerHydrationRecords.has(router);
+}
+
+function ModernRouterClient({ router }: { router: AnyRouter }) {
+  const hydrationRecord = getTanstackSsrHydrationRecord(router);
+  if (hydrationRecord.status === 'rejected') {
+    throw hydrationRecord.error;
+  }
+  return <RouterProvider router={router} />;
 }
 
 export const tanstackRouterPlugin = (
@@ -152,35 +286,157 @@ 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(context => {
-        const pluginConfig = api.getRuntimeConfig() as {
-          router?: Partial<RouterConfig>;
+      const hooks = api.getHooks();
+      let cachedRouteObjects: RouteObject[] | undefined;
+      let cachedRouteTree: ReturnType<
+        typeof createRouteTreeFromRouteObjects
+      > | null = null;
+      let cachedRouter: AnyRouter | null = null;
+      let cachedRouterBasepath: string | null = null;
+
+      const getMergedConfig = () => getMergedRouterConfig(api, userConfig);
+
+      const getRouteObjects = () => {
+        if (typeof cachedRouteObjects !== 'undefined') {
+          return cachedRouteObjects;
+        }
+
+        const mergedConfig = getMergedConfig();
+        const { createRoutes } = mergedConfig;
+        const finalRouteConfig = getFinalRouteConfig(mergedConfig);
+
+        const routeObjects = createRoutes
+          ? createRoutes()
+          : createRouteObjectsFromConfig({
+              routesConfig: finalRouteConfig,
+            }) || [];
+
+        cachedRouteObjects = hooks.modifyRoutes.call(
+          routeObjects,
+        ) as RouteObject[];
+        return cachedRouteObjects;
+      };
+
+      const getRouteTree = () => {
+        if (cachedRouteTree) {
+          return cachedRouteTree;
+        }
+
+        const routeObjects = getRouteObjects();
+        if (!routeObjects.length) {
+          return null;
+        }
+
+        cachedRouteTree = createRouteTreeFromRouteObjects(routeObjects, {
+          rscPayloadRouter: getGlobalEnableRsc(),
+        });
+        return cachedRouteTree;
+      };
+
+      const selectBasePath = (pathname: string) => {
+        const { serverBase = [] } = getMergedConfig();
+        const match = serverBase.find(baseUrl =>
+          isSegmentPrefix(pathname, baseUrl),
+        );
+        return match || '/';
+      };
+
+      const getClientBasename = (runtimeContext: TInternalRuntimeContext) => {
+        const { basename = '' } = getMergedConfig();
+        const baseUrl = selectBasePath(location.pathname).replace(/^\/*/, '/');
+        return baseUrl === '/'
+          ? urlJoin(
+              baseUrl,
+              runtimeContext._internalRouterBaseName || basename || '',
+            )
+          : baseUrl;
+      };
+
+      const getRouter = (
+        runtimeContext: TInternalRuntimeContext,
+        _basename: string,
+      ) => {
+        const routeTree = getRouteTree();
+        if (!routeTree) {
+          return null;
+        }
+
+        const lifecycleContext: RouterLifecycleContext = {
+          framework: 'tanstack',
+          phase: 'client-create',
+          routes: getRouteObjects(),
+          runtimeContext,
+          basename: _basename,
         };
-        const mergedConfig = merge(
-          pluginConfig.router || {},
-          userConfig,
-        ) as RouterConfig;
+        hooks.onBeforeCreateRouter.call(lifecycleContext);
+
+        if (cachedRouter && cachedRouterBasepath === _basename) {
+          wrapRouterSubscribeWithBlockState(
+            cachedRouter,
+            runtimeContext.unstable_getBlockNavState,
+          );
+          hooks.onAfterCreateRouter.call({
+            ...lifecycleContext,
+            router: cachedRouter,
+            runtimeContext,
+          });
+          return cachedRouter;
+        }
+
+        const mergedConfig = getMergedConfig();
+        const { supportHtml5History = true } = mergedConfig;
+        const history = supportHtml5History
+          ? createBrowserHistory()
+          : createHashHistory();
+        const rewrite = createModernBasepathRewrite(_basename);
+        const serializationAdapters = getGlobalEnableRsc()
+          ? getTanstackRscSerializationAdapters()
+          : undefined;
+
+        cachedRouter = createRouter({
+          ...getModernTanstackRouterFastDefaults(mergedConfig),
+          routeTree,
+          basepath: '/',
+          rewrite,
+          history,
+          context: {},
+          ...(serializationAdapters ? { serializationAdapters } : {}),
+        });
+        cachedRouterBasepath = _basename;
+        wrapRouterSubscribeWithBlockState(
+          cachedRouter,
+          runtimeContext.unstable_getBlockNavState,
+        );
+        hooks.onAfterCreateRouter.call({
+          ...lifecycleContext,
+          router: cachedRouter,
+          runtimeContext,
+        });
+
+        return cachedRouter;
+      };
+
+      api.onBeforeRender(context => {
+        const mergedConfig = getMergedConfig();
         if (
           typeof window !== 'undefined' &&
-          (window as { _SSR_DATA?: unknown })._SSR_DATA &&
+          (window as { _SSR_DATA?: unknown })._SSR_DATA !== undefined &&
           mergedConfig.unstable_reloadOnURLMismatch
         ) {
           const { ssrContext } = context;
           const currentPathname = normalizePathname(window.location.pathname);
           const initialPathname =
-            ssrContext?.request?.pathname &&
-            normalizePathname(ssrContext.request.pathname);
+            typeof ssrContext?.request?.pathname === 'string'
+              ? normalizePathname(ssrContext.request.pathname)
+              : undefined;
 
-          if (initialPathname && initialPathname !== currentPathname) {
+          if (
+            initialPathname !== undefined &&
+            initialPathname !== '' &&
+            initialPathname !== currentPathname
+          ) {
             const errorMsg = `The initial URL ${initialPathname} and the URL ${currentPathname} to be hydrated do not match, reload.`;
             console.error(errorMsg);
             window.location.reload();
@@ -194,159 +450,49 @@ export const tanstackRouterPlugin = (
           useNavigate,
           useRouter,
         };
+
+        const hasSSRBootstrap =
+          typeof window !== 'undefined' &&
+          Boolean((window as WindowWithTanstackSsr).$_TSR);
+        if (hasSSRBootstrap && getRouteObjects().length > 0) {
+          const runtimeContext = context as TInternalRuntimeContext;
+          const router = getRouter(
+            runtimeContext,
+            getClientBasename(runtimeContext),
+          );
+          if (router !== undefined && router !== null) {
+            return getTanstackSsrHydrationPromise(router).then(() => undefined);
+          }
+        }
+
+        return;
       });
 
       api.wrapRoot(App => {
-        const mergedConfig = merge(
-          api.getRuntimeConfig().router || {},
-          userConfig,
-        ) as RouterConfig;
-
-        const {
-          serverBase = [],
-          supportHtml5History = true,
-          basename = '',
-          routesConfig,
-          createRoutes,
-        } = mergedConfig;
-
-        const finalRouteConfig = {
-          routes: getGlobalRoutes(),
-          globalApp: getGlobalLayoutApp(),
-          ...routesConfig,
-        };
-
-        if (!finalRouteConfig.routes && !createRoutes) {
+        if (getRouteObjects().length === 0) {
           return App;
         }
 
-        const hooks = api.getHooks();
-
-        let cachedRouteObjects: RouteObject[] | undefined;
-
-        const getRouteObjects = () => {
-          if (typeof cachedRouteObjects !== 'undefined') {
-            return cachedRouteObjects;
-          }
-
-          const routeObjects = createRoutes
-            ? createRoutes()
-            : createRouteObjectsFromConfig({
-                routesConfig: finalRouteConfig,
-              }) || [];
-
-          const normalizedRouteObjects = createRoutes
-            ? routeObjects
-            : stripSyntheticNotFoundRoute(routeObjects);
-
-          cachedRouteObjects = hooks.modifyRoutes.call(
-            normalizedRouteObjects,
-          ) as RouteObject[];
-          return cachedRouteObjects;
-        };
-
-        const selectBasePath = (pathname: string) => {
-          const match = serverBase.find(baseUrl =>
-            isSegmentPrefix(pathname, baseUrl),
-          );
-          return match || '/';
-        };
-
-        let cachedRouteTree: ReturnType<
-          typeof createRouteTreeFromRouteObjects
-        > | null = null;
-        let cachedRouter: AnyRouter | null = null;
-        let cachedRouterBasepath: string | null = null;
-
         const RouterWrapper = () => {
           const runtimeContext = useContext(
             InternalRuntimeContext,
           ) as TInternalRuntimeContext;
 
-          const baseUrl = selectBasePath(location.pathname).replace(
-            /^\/*/,
-            '/',
-          );
-          const _basename =
-            baseUrl === '/'
-              ? urlJoin(
-                  baseUrl,
-                  runtimeContext._internalRouterBaseName || basename || '',
-                )
-              : baseUrl;
-
-          const routeTree = useMemo(() => {
-            if (cachedRouteTree) {
-              return cachedRouteTree;
-            }
-            const routeObjects = getRouteObjects();
-            if (!routeObjects.length) {
-              return null;
-            }
-            cachedRouteTree = createRouteTreeFromRouteObjects(routeObjects, {
-              rscPayloadRouter: getGlobalEnableRsc(),
-            });
-            return cachedRouteTree;
-          }, []);
+          const _basename = getClientBasename(runtimeContext);
+
+          const routeTree = useMemo(() => getRouteTree(), []);
 
           if (!routeTree) {
             return App ? <App /> : null;
           }
 
-          const router = useMemo(() => {
-            const lifecycleContext: RouterLifecycleContext = {
-              framework: 'tanstack',
-              phase: 'client-create',
-              routes: getRouteObjects(),
-              runtimeContext,
-              basename: _basename,
-            };
-            hooks.onBeforeCreateRouter.call(lifecycleContext);
-
-            if (cachedRouter && cachedRouterBasepath === _basename) {
-              wrapRouterSubscribeWithBlockState(
-                cachedRouter,
-                runtimeContext.unstable_getBlockNavState,
-              );
-              hooks.onAfterCreateRouter.call({
-                ...lifecycleContext,
-                router: cachedRouter,
-                runtimeContext,
-              });
-              return cachedRouter;
-            }
-
-            const history = supportHtml5History
-              ? createBrowserHistory()
-              : createHashHistory();
-
-            const rewrite = createModernBasepathRewrite(_basename);
-            const serializationAdapters = getGlobalEnableRsc()
-              ? getTanstackRscSerializationAdapters()
-              : undefined;
-
-            cachedRouter = createRouter({
-              ...getModernTanstackRouterFastDefaults(mergedConfig),
-              routeTree,
-              basepath: '/',
-              rewrite,
-              history,
-              context: {},
-              ...(serializationAdapters ? { serializationAdapters } : {}),
-            });
-            cachedRouterBasepath = _basename;
-            wrapRouterSubscribeWithBlockState(
-              cachedRouter,
-              runtimeContext.unstable_getBlockNavState,
-            );
-            hooks.onAfterCreateRouter.call({
-              ...lifecycleContext,
-              router: cachedRouter,
-              runtimeContext,
-            });
-
-            return cachedRouter;
-          }, [_basename, routeTree, supportHtml5History, runtimeContext]);
+          const router = useMemo(
+            () => getRouter(runtimeContext, _basename),
+            [_basename, routeTree, runtimeContext],
+          );
+          if (!router) {
+            return App ? <App /> : null;
+          }
           const runtimeState = applyRouterRuntimeState(runtimeContext, {
             framework: 'tanstack',
             basename: _basename,
@@ -363,8 +509,10 @@ export const tanstackRouterPlugin = (
 
           const hasSSRBootstrap =
             typeof window !== 'undefined' &&
-            Boolean((window as WindowWithTanstackSsr).$_TSR);
-          if (hasSSRBootstrap) {
+            (Boolean((window as WindowWithTanstackSsr).$_TSR) ||
+              hasTanstackSsrHydrationRecord(router));
+          const needsRouterClient = hasSSRBootstrap;
+          if (needsRouterClient) {
             hooks.onBeforeHydrateRouter.call({
               ...lifecycleContext,
               phase: 'hydrate',
@@ -373,8 +521,8 @@ export const tanstackRouterPlugin = (
             });
           }
 
-          const RouterContent = hasSSRBootstrap ? (
-            <RouterClient router={router} />
+          const RouterContent = needsRouterClient ? (
+            <ModernRouterClient router={router} />
           ) : (
             <RouterProvider router={router} />
           );
@@ -382,7 +530,7 @@ export const tanstackRouterPlugin = (
             RouterContent,
             hasSSRBootstrap,
           );
-          if (hasSSRBootstrap) {
+          if (needsRouterClient) {
             hooks.onAfterHydrateRouter.call({
               ...lifecycleContext,
               phase: 'hydrate',