rsbuild-plugin-react-router 0.4.1 → 0.6.0

package/src/react-router-config.ts

@@ -6,13 +6,15 @@ import type { NormalizedConfig } from '@rsbuild/core';
 import type { RouteConfigEntry } from '@react-router/dev/routes';
 import * as Effect from 'effect/Effect';
 import { getCappedPluginConcurrency } from './concurrency.js';
-import { runPluginEffect, tryPluginPromise } from './effect-runtime.js';
+import { normalizeEffectError, tryPluginPromise } from './effect-runtime.js';
+import { getPackageVersion, parseVersionMajorMinor } from './plugin-utils.js';
+import type { PrerenderConfigObject, PrerenderPathsConfig } from './types.js';
 
 export type BuildEndHook = {
   bivarianceHack(args: {
     buildManifest: ReactRouterBuildManifest | undefined;
     reactRouterConfig: ResolvedReactRouterConfig;
-    viteConfig: NormalizedConfig;
+    rsbuildConfig: NormalizedConfig;
   }): void | Promise<void>;
 }['bivarianceHack'];
 
@@ -20,10 +22,15 @@ type SplitRouteModulesConfig = boolean | 'enforce';
 
 export type Config = Omit<
   ReactRouterConfig,
-  'buildEnd' | 'future' | 'splitRouteModules' | 'subResourceIntegrity'
+  | 'buildEnd'
+  | 'future'
+  | 'prerender'
+  | 'splitRouteModules'
+  | 'subResourceIntegrity'
 > & {
   buildEnd?: BuildEndHook;
   future?: Partial<FutureConfig>;
+  prerender?: PrerenderConfig;
   splitRouteModules?: SplitRouteModulesConfig;
   subResourceIntegrity?: boolean;
 };
@@ -37,6 +44,8 @@ type FutureConfig = {
   v8_viteEnvironmentApi: boolean;
 };
 
+type PrerenderConfig = PrerenderPathsConfig | PrerenderConfigObject | undefined;
+
 type RouteManifestEntry = {
   id: string;
   parentId?: string;
@@ -50,10 +59,45 @@ type RouteManifest = Record<string, RouteManifestEntry>;
 
 type ResolveReactRouterConfigResult = {
   resolved: ResolvedReactRouterConfig;
+  userAndPresetConfig: Config;
   presets: NonNullable<Config['presets']>;
   hasConfiguredServerModuleFormat: boolean;
 };
 
+export const getDefaultTrailingSlashAwareDataRequests = (
+  reactRouterVersion: string | undefined = getPackageVersion('react-router')
+): boolean => (parseVersionMajorMinor(reactRouterVersion)?.major ?? 0) >= 8;
+
+export const resolveRouteDiscoveryConfig = ({
+  ssr,
+  userRouteDiscovery,
+}: {
+  ssr: boolean;
+  userRouteDiscovery: Config['routeDiscovery'];
+}): Config['routeDiscovery'] => {
+  if (!userRouteDiscovery) {
+    return ssr
+      ? ({ mode: 'lazy', manifestPath: '/__manifest' } as const)
+      : ({ mode: 'initial' } as const);
+  }
+  if (userRouteDiscovery.mode === 'initial') {
+    return userRouteDiscovery;
+  }
+
+  if (!ssr) {
+    throw new Error(
+      'The `routeDiscovery.mode` config cannot be set to "lazy" when setting `ssr:false`'
+    );
+  }
+  const manifestPath = userRouteDiscovery.manifestPath;
+  if (manifestPath && !manifestPath.startsWith('/')) {
+    throw new Error(
+      'The `routeDiscovery.manifestPath` config must be a root-relative pathname beginning with a slash (i.e., "/__manifest")'
+    );
+  }
+  return userRouteDiscovery;
+};
+
 export type ResolvedReactRouterConfig = Readonly<{
   appDirectory: string;
   basename: string;
@@ -73,6 +117,16 @@ export type ResolvedReactRouterConfig = Readonly<{
   unstable_routeConfig: RouteConfigEntry[];
 }>;
 
+const createDefaultFutureConfig = (): FutureConfig => ({
+  unstable_optimizeDeps: false,
+  unstable_subResourceIntegrity: false,
+  unstable_trailingSlashAwareDataRequests:
+    getDefaultTrailingSlashAwareDataRequests(),
+  v8_middleware: false,
+  v8_splitRouteModules: false,
+  v8_viteEnvironmentApi: false,
+});
+
 const DEFAULT_CONFIG = {
   appDirectory: 'app',
   basename: '/',
@@ -82,14 +136,7 @@ const DEFAULT_CONFIG = {
   splitRouteModules: true,
   subResourceIntegrity: false,
   ssr: true,
-  future: {
-    unstable_optimizeDeps: false,
-    unstable_subResourceIntegrity: false,
-    unstable_trailingSlashAwareDataRequests: false,
-    v8_middleware: false,
-    v8_splitRouteModules: false,
-    v8_viteEnvironmentApi: false,
-  } satisfies FutureConfig,
+  future: createDefaultFutureConfig(),
   routeDiscovery: undefined,
   prerender: undefined,
   serverBundles: undefined,
@@ -111,15 +158,17 @@ const mergeReactRouterConfig = (...configs: Config[]): Config => {
             buildEnd: async (
               ...args: Parameters<NonNullable<Config['buildEnd']>>
             ) => {
-              await runPluginEffect(
-                Effect.all(
-                  [
-                    tryPluginPromise(() => configA.buildEnd?.(...args)),
-                    tryPluginPromise(() => configB.buildEnd?.(...args)),
-                  ],
-                  { discard: true }
-                )
-              );
+              let failure: Error | undefined;
+              for (const buildEnd of [configA.buildEnd, configB.buildEnd]) {
+                try {
+                  await buildEnd?.(...args);
+                } catch (cause) {
+                  failure ??= normalizeEffectError(cause);
+                }
+              }
+              if (failure) {
+                throw failure;
+              }
             },
           }
         : {}),
@@ -181,7 +230,8 @@ export const resolveReactRouterConfigEffect = (
             reactRouterUserConfig;
           const presetConfig = yield* tryPluginPromise(() =>
             preset.reactRouterConfig?.({
-              reactRouterUserConfig: reactRouterUserConfigForPreset,
+              reactRouterUserConfig:
+                reactRouterUserConfigForPreset as ReactRouterConfig,
             })
           );
           if (!presetConfig) return null;
@@ -233,13 +283,9 @@ export const resolveReactRouterConfigEffect = (
 
     return {
       resolved,
+      userAndPresetConfig: userAndPresetConfigs,
       presets: reactRouterUserConfig.presets ?? [],
       hasConfiguredServerModuleFormat:
         userAndPresetConfigs.serverModuleFormat !== undefined,
     };
   });
-
-export const resolveReactRouterConfig = (
-  reactRouterUserConfig: Config
-): Promise<ResolveReactRouterConfigResult> =>
-  runPluginEffect(resolveReactRouterConfigEffect(reactRouterUserConfig));

package/src/route-artifacts.ts

@@ -1,5 +1,4 @@
 import { basename } from 'pathe';
-
 import {
   CLIENT_EXPORTS,
   CLIENT_ROUTE_EXPORTS_SET,
@@ -12,6 +11,7 @@ import {
   detectRouteChunksIfEnabled,
   emptyRouteChunkSnippet,
   getRouteChunkIfEnabled,
+  getRouteChunkModuleId,
   getRouteChunkNameFromModuleId,
   shouldAnalyzeRouteChunks,
   validateRouteChunks,
@@ -50,9 +50,8 @@ type RouteChunkArtifact = {
   map: null;
 };
 
-// Exactly the route-manifest flags the client HMR runtime can patch in place
-// without a full reload. Array order defines the bit layout shared by the
-// encoder below and the decoder emitted in `generateDevHmrRuntimeModule`.
+// Shared with the dev manifest differ: exactly the route flags the client HMR
+// runtime can patch in place without a full reload.
 export const HMR_PATCHABLE_ROUTE_FLAGS = [
   'hasAction',
   'hasClientAction',
@@ -62,88 +61,104 @@ export const HMR_PATCHABLE_ROUTE_FLAGS = [
   'hasLoader',
 ] as const;
 
-const HMR_FLAG_EXPORT_NAME: Record<
+type RouteHmrMetadata = Record<
   (typeof HMR_PATCHABLE_ROUTE_FLAGS)[number],
-  string
-> = {
-  hasAction: SERVER_EXPORTS.action,
-  hasClientAction: CLIENT_EXPORTS.clientAction,
-  hasClientLoader: CLIENT_EXPORTS.clientLoader,
-  hasClientMiddleware: CLIENT_EXPORTS.clientMiddleware,
-  hasErrorBoundary: CLIENT_EXPORTS.ErrorBoundary,
-  hasLoader: SERVER_EXPORTS.loader,
-};
+  boolean
+>;
 
-export const buildRouteHmrFlags = (exportNames: readonly string[]): number => {
+export const buildRouteHmrMetadata = (
+  exportNames: readonly string[]
+): RouteHmrMetadata => {
   const exports = new Set(exportNames);
-  let flags = 0;
-  HMR_PATCHABLE_ROUTE_FLAGS.forEach((flag, index) => {
-    if (exports.has(HMR_FLAG_EXPORT_NAME[flag])) flags |= 1 << index;
-  });
-  return flags;
+  return {
+    hasAction: exports.has(SERVER_EXPORTS.action),
+    hasClientAction: exports.has(CLIENT_EXPORTS.clientAction),
+    hasClientLoader: exports.has(CLIENT_EXPORTS.clientLoader),
+    hasClientMiddleware: exports.has(CLIENT_EXPORTS.clientMiddleware),
+    hasErrorBoundary: exports.has(CLIENT_EXPORTS.ErrorBoundary),
+    hasLoader: exports.has(SERVER_EXPORTS.loader),
+  };
 };
 
 /**
  * Development-only HMR glue for a web route client entry.
  *
  * The route client entry is the webpack entry for a route, so it must
- * self-accept hot updates to stop them from bubbling into a full reload. It
- * also accepts updates of the underlying route module and forwards fresh
- * exports plus route metadata (loader/action flags derived from the current
- * export names) to the shared HMR runtime, which applies the React Router
- * route-module update contract and revalidates loader data.
+ * self-accept hot updates to stop them from bubbling into a full reload. The
+ * route entry itself must re-run on updates so route metadata (loader/action
+ * flags derived from current export names) does not get stuck in an old accept
+ * callback while the underlying route module changes.
  */
 const buildRouteClientEntryHmrCode = ({
   routeId,
   target,
-  acceptTarget,
-  flags,
+  metadata,
 }: {
   routeId: string;
   target: string;
-  acceptTarget: string;
-  flags: number;
+  metadata: RouteHmrMetadata;
 }): string => {
   const targetJson = JSON.stringify(target);
-  const acceptTargetJson = JSON.stringify(acceptTarget);
   return `
-import * as __rrm from ${targetJson};
+import * as __reactRouterRouteModule from ${targetJson};
 import {
-  registerReactRouterRouteExports as __rrr,
-  scheduleReactRouterRouteUpdate as __rru,
+  registerReactRouterRouteExports as __reactRouterRegisterRouteExports,
+  scheduleReactRouterRouteUpdate as __reactRouterScheduleRouteUpdate,
 } from "virtual/react-router/hmr-runtime";
 
-const __rrid = ${JSON.stringify(routeId)};
-const __rrf = ${flags};
-const __rrg = () => __rrm;
-const __rru0 = () => {
-  __rrr(__rrid, __rrm);
-  __rru(__rrid, __rrf, __rrg);
-};
+const __reactRouterRouteId = ${JSON.stringify(routeId)};
+const __reactRouterRouteMetadata = ${JSON.stringify(metadata)};
+const __reactRouterGetRouteModule = () => __reactRouterRouteModule;
 
-__rrr(__rrid, __rrm);
+__reactRouterRegisterRouteExports(
+  __reactRouterRouteId,
+  __reactRouterRouteModule
+);
 
 if (import.meta.webpackHot) {
-  const __rrh = import.meta.webpackHot;
-  __rrh.accept(${acceptTargetJson}, __rru0);
-  __rrh.accept();
-  __rrh.dispose(data => { data.__rr = true; });
-  if (__rrh.data && __rrh.data.__rr) __rru0();
+  import.meta.webpackHot.accept();
+  import.meta.webpackHot.dispose(data => {
+    data.__reactRouterRouteShim = true;
+  });
+  if (
+    import.meta.webpackHot.data &&
+    import.meta.webpackHot.data.__reactRouterRouteShim
+  ) {
+    __reactRouterScheduleRouteUpdate(
+      __reactRouterRouteId,
+      __reactRouterRouteMetadata,
+      __reactRouterGetRouteModule
+    );
+  }
 }
 `;
 };
 
-// The accept target is spelled relative (`./name?react-router-route`) while
-// the import above uses the absolute resource path; both resolve to the same
-// module because the client entry replaces the route file in place, so its
-// resolution context is the route's own directory.
-const createRouteHmrAcceptTarget = (resourcePath: string): string => {
-  return `./${basename(resourcePath)}?react-router-route`;
+const shouldReexportFromRouteEntry = ({
+  chunkedExportSet,
+  exportName,
+  isServer,
+}: {
+  chunkedExportSet?: ReadonlySet<string>;
+  exportName: string;
+  isServer: boolean;
+}): boolean => {
+  if (chunkedExportSet?.has(exportName)) {
+    return false;
+  }
+  if (isServer) {
+    return (
+      CLIENT_ROUTE_EXPORTS_SET.has(exportName) ||
+      SERVER_ONLY_ROUTE_EXPORTS_SET.has(exportName)
+    );
+  }
+  return CLIENT_ROUTE_EXPORTS_SET.has(exportName);
 };
 
 export const buildRouteClientEntryCode = ({
   exportNames,
   chunkedExports,
+  sharedChunkedExports = [],
   isServer,
   resourcePath,
   routeId,
@@ -151,26 +166,40 @@ export const buildRouteClientEntryCode = ({
 }: {
   exportNames: readonly string[];
   chunkedExports: readonly string[];
+  sharedChunkedExports?: readonly string[];
   isServer: boolean;
   resourcePath: string;
   routeId?: string;
   devHmr?: boolean;
 }): string => {
   const chunkedExportSet =
-    chunkedExports.length > 0 ? new Set<string>(chunkedExports) : undefined;
+    chunkedExports.length > 0 || sharedChunkedExports.length > 0
+      ? new Set<string>([...chunkedExports, ...sharedChunkedExports])
+      : undefined;
+  const routeRequestPath = `./${basename(resourcePath)}`;
+  const target = isServer
+    ? routeRequestPath
+    : chunkedExports.length > 0
+      ? getRouteChunkModuleId(routeRequestPath, 'main')
+      : `${routeRequestPath}?react-router-route`;
   const reexports = exportNames
-    .filter(exp => {
-      if (chunkedExportSet?.has(exp)) {
-        return false;
-      }
-      return (
-        CLIENT_ROUTE_EXPORTS_SET.has(exp) ||
-        (isServer && SERVER_ONLY_ROUTE_EXPORTS_SET.has(exp))
-      );
-    })
+    .filter(exportName =>
+      shouldReexportFromRouteEntry({ chunkedExportSet, exportName, isServer })
+    )
     .sort();
-  const target = `${resourcePath}?react-router-route`;
-  const reexportCode = `export { ${reexports.join(', ')} } from ${JSON.stringify(target)};`;
+  const reexportCode = [
+    reexports.length > 0
+      ? `export { ${reexports.join(', ')} } from ${JSON.stringify(target)};`
+      : null,
+    ...sharedChunkedExports.map(
+      exportName =>
+        `export { ${exportName} } from ${JSON.stringify(
+          getRouteChunkModuleId(routeRequestPath, exportName)
+        )};`
+    ),
+  ]
+    .filter(Boolean)
+    .join('\n');
   if (!devHmr || isServer || routeId === undefined) {
     return reexportCode;
   }
@@ -179,8 +208,7 @@ export const buildRouteClientEntryCode = ({
     buildRouteClientEntryHmrCode({
       routeId,
       target,
-      acceptTarget: createRouteHmrAcceptTarget(resourcePath),
-      flags: buildRouteHmrFlags(exportNames),
+      metadata: buildRouteHmrMetadata(exportNames),
     })
   );
 };
@@ -211,10 +239,12 @@ export const createRouteClientEntryArtifact = async ({
   const exportNames =
     routeChunkInfo?.exportNames ?? (await getExportNames(code, resourcePath));
   const chunkedExports = routeChunkInfo?.chunkedExports ?? [];
+  const sharedChunkedExports = routeChunkInfo?.sharedChunkedExports ?? [];
   return {
     code: buildRouteClientEntryCode({
       exportNames,
       chunkedExports,
+      sharedChunkedExports,
       isServer,
       resourcePath,
       routeId,