rsbuild-plugin-react-router 0.2.0 → 0.3.1

package/dist/server-build-plan.d.ts

@@ -0,0 +1,22 @@
+import type { ReactRouterDevBuildPlan } from './dev-runtime-artifacts.js';
+import type { Route } from './types.js';
+export type ReactRouterServerBundleEntry = {
+    bundleId: string;
+    entryName: string;
+};
+export type ReactRouterServerBuildPlan = ReactRouterDevBuildPlan & {
+    serverBundleEntries: ReactRouterServerBundleEntry[];
+};
+export declare const createReactRouterServerBuildPlan: ({ routesByServerBundleId, serverBuildFile, defaultEntryName, }: {
+    routesByServerBundleId: Record<string, Record<string, Route>>;
+    serverBuildFile: string | undefined;
+    defaultEntryName: string;
+}) => ReactRouterServerBuildPlan;
+export declare const createReactRouterNodeEntries: ({ hasServerApp, isBuild, serverAppPath, entryServerPath, defaultEntryName, serverBundleEntries, }: {
+    hasServerApp: boolean;
+    isBuild: boolean;
+    serverAppPath: string;
+    entryServerPath: string;
+    defaultEntryName: string;
+    serverBundleEntries: readonly ReactRouterServerBundleEntry[];
+}) => Record<string, string>;

package/dist/server-build-resolution.d.ts

@@ -0,0 +1,3 @@
+import * as Effect from 'effect/Effect';
+import type { ServerBuild } from 'react-router';
+export declare function resolveServerBuildModuleEffect(buildModule: unknown, source: string): Effect.Effect<ServerBuild, Error, never>;

package/dist/server-utils.d.ts

@@ -1,3 +1,4 @@
+import type { ServerBuild } from 'react-router';
 import type { Route } from './types.js';
 /**
  * Generates the server build template string.
@@ -33,6 +34,6 @@ interface ServerBuildOptions {
 declare function generateServerBuild(routes: Record<string, Route>, options: ServerBuildOptions & {
     federation?: boolean;
 }): string;
-export declare const normalizeBuildModule: <T extends Record<string, any>>(build: T) => T;
-export declare const resolveBuildExports: <T extends Record<string, any>>(build: T) => Promise<T>;
+export declare function resolveServerBuildModule(buildModule: unknown, source: string): Promise<ServerBuild>;
+export declare function resolveReactRouterServerBuild(buildModule: unknown): Promise<ServerBuild>;
 export { generateServerBuild };

package/dist/ssr-externals.d.ts

@@ -1 +1,2 @@
+export declare function resolvePackageJson(name: string, rootDirectory: string): string | null;
 export declare function getSsrExternals(rootDirectory: string): string[];

package/dist/templates/entry.server.cjs

@@ -23,12 +23,12 @@ __webpack_require__.r(__webpack_exports__), __webpack_require__.d(__webpack_expo
 const external_node_stream_namespaceObject = require("node:stream"), node_namespaceObject = require("@react-router/node"), external_isbot_namespaceObject = require("isbot"), external_react_namespaceObject = require("react"), server_namespaceObject = require("react-dom/server"), external_react_router_namespaceObject = require("react-router"), ABORT_DELAY = 5000;
 function handleRequest(request, responseStatusCode, responseHeaders, routerContext) {
     return new Promise((resolve, reject)=>{
-        let shellRendered = !1, statusCode = responseStatusCode, userAgent = request.headers.get('user-agent'), readyOption = userAgent && (0, external_isbot_namespaceObject.isbot)(userAgent) || routerContext.isSpaMode ? 'onAllReady' : 'onShellReady', { pipe, abort } = (0, server_namespaceObject.renderToPipeableStream)(external_react_namespaceObject.createElement(external_react_router_namespaceObject.ServerRouter, {
+        let abortDelay, shellRendered = !1, statusCode = responseStatusCode, userAgent = request.headers.get('user-agent'), readyOption = userAgent && (0, external_isbot_namespaceObject.isbot)(userAgent) || routerContext.isSpaMode ? 'onAllReady' : 'onShellReady', ready = !1, { pipe, abort } = (0, server_namespaceObject.renderToPipeableStream)(external_react_namespaceObject.createElement(external_react_router_namespaceObject.ServerRouter, {
             context: routerContext,
             url: request.url
         }), {
             [readyOption] () {
-                shellRendered = !0;
+                ready = !0, 'onAllReady' === readyOption && abortDelay && clearTimeout(abortDelay), shellRendered = !0;
                 let body = new external_node_stream_namespaceObject.PassThrough(), stream = (0, node_namespaceObject.createReadableStreamFromReadable)(body);
                 responseHeaders.set('Content-Type', 'text/html'), resolve(new Response(stream, {
                     headers: responseHeaders,
@@ -42,7 +42,7 @@ function handleRequest(request, responseStatusCode, responseHeaders, routerConte
                 statusCode = 500, shellRendered && console.error(error);
             }
         });
-        setTimeout(abort, 5000);
+        abortDelay = setTimeout(abort, 5000), 'onAllReady' === readyOption && ready && clearTimeout(abortDelay);
     });
 }
 for(var __rspack_i in exports.default = __webpack_exports__.default, __webpack_exports__)-1 === [

package/dist/templates/entry.server.js

@@ -6,12 +6,12 @@ import { ServerRouter } from "react-router";
 import * as __rspack_external_react from "react";
 export default function(request, responseStatusCode, responseHeaders, routerContext) {
     return new Promise((resolve, reject)=>{
-        let shellRendered = !1, statusCode = responseStatusCode, userAgent = request.headers.get('user-agent'), readyOption = userAgent && isbot(userAgent) || routerContext.isSpaMode ? 'onAllReady' : 'onShellReady', { pipe, abort } = renderToPipeableStream(__rspack_external_react.createElement(ServerRouter, {
+        let abortDelay, shellRendered = !1, statusCode = responseStatusCode, userAgent = request.headers.get('user-agent'), readyOption = userAgent && isbot(userAgent) || routerContext.isSpaMode ? 'onAllReady' : 'onShellReady', ready = !1, { pipe, abort } = renderToPipeableStream(__rspack_external_react.createElement(ServerRouter, {
             context: routerContext,
             url: request.url
         }), {
             [readyOption] () {
-                shellRendered = !0;
+                ready = !0, 'onAllReady' === readyOption && abortDelay && clearTimeout(abortDelay), shellRendered = !0;
                 let body = new PassThrough(), stream = createReadableStreamFromReadable(body);
                 responseHeaders.set('Content-Type', 'text/html'), resolve(new Response(stream, {
                     headers: responseHeaders,
@@ -25,6 +25,6 @@ export default function(request, responseStatusCode, responseHeaders, routerCont
                 statusCode = 500, shellRendered && console.error(error);
             }
         });
-        setTimeout(abort, 5000);
+        abortDelay = setTimeout(abort, 5000), 'onAllReady' === readyOption && ready && clearTimeout(abortDelay);
     });
 };

package/dist/typegen.d.ts

@@ -0,0 +1,15 @@
+import type { RsbuildPluginAPI } from '@rsbuild/core';
+type Execa = typeof import('execa').execa;
+type LoadExeca = () => Promise<Execa>;
+export type ReactRouterTypegenRunner = {
+    startWatch(): Promise<void>;
+    closeWatch(): Promise<void>;
+    runBuild(): Promise<void>;
+};
+export declare const createReactRouterTypegenRunner: (loadExeca?: LoadExeca, appDirectory?: string) => ReactRouterTypegenRunner;
+export declare const registerReactRouterTypegen: (api: RsbuildPluginAPI, { runner, devWatchDelayMs, appDirectory, }?: {
+    runner?: ReactRouterTypegenRunner;
+    devWatchDelayMs?: number;
+    appDirectory?: string;
+}) => void;
+export {};

package/dist/types.d.ts

@@ -1,3 +1,4 @@
+import type { RsbuildConfig } from '@rsbuild/core';
 export type Route = {
     id: string;
     parentId?: string;
@@ -16,26 +17,52 @@ export type PluginOptions = {
     customServer?: boolean;
     /**
      * The output format for server builds.
-     * When set to "module", no package.json will be emitted.
-     * @default "module"
+     * When omitted, React Router's `serverModuleFormat` selects the emitted
+     * Rsbuild format (`"esm"` -> `"module"`, `"cjs"` -> `"commonjs"`).
      */
     serverOutput?: 'module' | 'commonjs';
     /**
      * Federation mode configuration
      */
     federation?: boolean;
-};
-/**
- * Arguments passed to transform functions
- */
-export type TransformArgs = {
-    code: string;
-    resource: string;
-    resourcePath: string;
-    context?: string | null;
-    environment?: {
-        name: string;
-    };
+    /**
+     * Rsbuild dev-only lazy compilation behavior.
+     *
+     * React Router's browser manifest remains eager so initial dev requests can
+     * discover browser assets without lazy proxy delays.
+     *
+     * Pass `false` to disable.
+     * @default true
+     */
+    lazyCompilation?: NonNullable<RsbuildConfig['dev']>['lazyCompilation'];
+    /**
+     * Prewarm Rspack lazy-compilation proxy modules after dev compiles.
+     * This depends on Rspack's generated lazy-compilation client shape and should
+     * be treated as experimental.
+     *
+     * @default false
+     */
+    unstableLazyCompilationPrewarm?: boolean;
+    /**
+     * Emit structured React Router plugin timing logs.
+     * @default false
+     */
+    logPerformance?: boolean;
+    /**
+     * Run route transforms in a worker-thread pool.
+     * Pass `true` to force the default worker count, a positive integer to set
+     * the worker count, or `false` to disable.
+     * @default Automatically enabled for 256+ resolved routes. The automatic
+     * pool uses available CPU cores minus 2.
+     */
+    parallelRouteTransform?: boolean | number;
+    /**
+     * Called when the route graph changes during development.
+     * Programmatic/custom servers can use this to recreate their Rsbuild server;
+     * the CLI uses its built-in reload-server watcher when this is omitted. This
+     * notification is not awaited, so it may safely close the current server.
+     */
+    onRouteTopologyChange?: () => void | Promise<void>;
 };
 export type RouteManifestItem = Omit<Route, 'file' | 'children'> & {
     module: string;

package/dist/virtual-modules.d.ts

@@ -0,0 +1,2 @@
+export declare const getVirtualModuleFilePath: (moduleId: string) => string;
+export declare const mapVirtualModules: (modules: Record<string, string>) => Record<string, string>;

package/dist/warnings/warn-on-client-source-maps.d.ts

@@ -1,5 +1,6 @@
 import type { NormalizedConfig } from '@rsbuild/core';
 type Warn = (message: string) => void;
+export declare function isSourceMapEnabled(value: unknown): boolean;
 export declare function getClientSourceMapSetting(normalized: NormalizedConfig, clientEnvName?: string): unknown;
 export declare function getClientDevtoolSetting(normalized: NormalizedConfig, clientEnvName?: string): unknown;
 export declare function warnOnClientSourceMaps(normalized: NormalizedConfig, warn: Warn, clientEnvName?: string): void;

package/dist/yuku.d.ts

@@ -0,0 +1,15 @@
+import { walk, type ParseOptions, type ParseResult } from 'yuku-parser';
+import type { Rspack } from '@rsbuild/core';
+export declare const parse: (code: string, options?: ParseOptions) => ParseResult;
+export declare const traverse: typeof walk;
+export declare const generate: (ast: ParseResult | {
+    type: "Program";
+}, options?: {
+    sourceMaps?: boolean;
+    filename?: string;
+    sourceFileName?: string;
+}) => {
+    code: string;
+    map: Rspack.RawSourceMap | null;
+};
+export type { ParseResult };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rsbuild-plugin-react-router",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "React Router plugin for Rsbuild",
   "repository": {
     "type": "git",
@@ -42,22 +42,16 @@
   "main": "./dist/index.cjs",
   "types": "./dist/index.d.ts",
   "files": [
-    "dist"
+    "dist",
+    "src"
   ],
   "publint": {
     "ignoreMissingDts": true
   },
   "dependencies": {
-    "@babel/core": "^7.28.6",
-    "@babel/generator": "^7.28.6",
-    "@babel/parser": "^7.28.6",
-    "@babel/traverse": "^7.28.6",
-    "@babel/types": "^7.28.6",
     "@react-router/node": "^7.13.0",
     "@remix-run/node-fetch-server": "^0.13.0",
     "@rspack/plugin-react-refresh": "^2.0.2",
-    "babel-dead-code-elimination": "^1.0.12",
-    "esbuild": "^0.27.2",
     "execa": "^9.6.1",
     "fs-extra": "11.3.3",
     "isbot": "5.1.34",
@@ -65,28 +59,30 @@
     "jsesc": "^3.1.0",
     "pathe": "^2.0.3",
     "react-refresh": "^0.18.0",
-    "rspack-plugin-virtual-module": "^1.0.1"
+    "yuku-analyzer": "0.5.39",
+    "yuku-codegen": "0.5.39",
+    "yuku-parser": "0.5.39"
   },
   "devDependencies": {
     "@changesets/cli": "^2.29.8",
-    "@react-router/dev": "^7.13.0",
-    "@rsbuild/core": "2.0.15",
+    "@react-router/dev": "^8.0.1",
+    "@rsbuild/core": "2.1.0",
+    "@rsbuild/plugin-react": "2.1.0",
     "@rslib/core": "^0.22.1",
-    "@rspack/core": "2.0.8",
-    "@swc/helpers": "^0.5.23",
+    "@rspack/core": "2.1.0",
     "@rstest/core": "^0.8.1",
     "@rstest/coverage-istanbul": "^0.2.0",
-    "@types/babel__core": "^7.20.5",
-    "@types/babel__generator": "^7.27.0",
-    "@types/babel__traverse": "^7.28.0",
+    "@swc/helpers": "^0.5.23",
     "@types/fs-extra": "11.0.4",
     "@types/jsesc": "^3.0.3",
     "@types/node": "^25.0.10",
     "@types/react": "^19.2.10",
     "@types/react-dom": "^19.2.3",
+    "effect": "^3.21.4",
     "es-module-lexer": "1.7.0",
     "kill-port": "^2.0.1",
-    "playwright": "^1.58.0",
+    "pkg-pr-new": "^0.0.75",
+    "playwright": "1.58.0",
     "prettier": "3.8.1",
     "react": "^19.2.4",
     "react-dom": "^19.2.4",
@@ -105,13 +101,22 @@
   },
   "scripts": {
     "build": "rslib build",
-    "e2e": "pnpm build && pnpm --filter './examples/{default-template,spa-mode,prerender,custom-node-server,cloudflare,client-only}' test:e2e",
+    "bench": "node scripts/bench-builds.mts",
+    "bench:ci-report": "node scripts/report-benchmark-ci.mts",
+    "bench:compare": "node scripts/compare-benchmarks.mts",
+    "bench:smoke": "node scripts/bench-builds.mts --profile smoke --iterations 1 --warmup 0 --format both --out .benchmark/results/smoke",
+    "bench:baseline": "node scripts/bench-builds.mts --profile default --iterations 5 --warmup 1 --clean build --format both --out .benchmark/results/baseline",
+    "bench:full": "node scripts/bench-builds.mts --profile full --iterations 5 --warmup 1 --clean build --format both --out .benchmark/results/full",
+    "bench:large": "node scripts/bench-builds.mts --profile large --iterations 1 --warmup 0 --clean cold --format both --out .benchmark/results/large",
+    "bench:synthetic-app": "node scripts/bench-synthetic-app.mjs",
+    "e2e": "pnpm build && pnpm test:package-interop && pnpm --filter './examples/{default-template,spa-mode,prerender,custom-node-server,cloudflare,client-only}' test:e2e",
     "dev": "rslib build --watch",
     "test": "rstest run",
     "test:watch": "rstest watch",
     "test:coverage": "rstest run --coverage",
     "test:core": "rstest run -c ./rstest.config.ts",
     "test:core:watch": "rstest watch -c ./rstest.config.ts",
+    "test:package-interop": "node scripts/test-package-interop.mts",
     "format": "prettier --write \"src/**/*.{js,jsx,ts,tsx}\"",
     "format:check": "prettier --check \"src/**/*.{js,jsx,ts,tsx}\"",
     "changeset": "changeset",

package/src/bounded-cache.ts

@@ -0,0 +1,18 @@
+export const setBoundedCacheEntry = <Key, Value>(
+  cache: Map<Key, Value>,
+  key: Key,
+  value: Value,
+  maxEntries: number
+): void => {
+  if (maxEntries <= 0) {
+    cache.clear();
+    return;
+  }
+  if (!cache.has(key) && cache.size >= maxEntries) {
+    const oldestEntry = cache.keys().next();
+    if (!oldestEntry.done) {
+      cache.delete(oldestEntry.value);
+    }
+  }
+  cache.set(key, value);
+};

package/src/build-manifest.ts

@@ -0,0 +1,205 @@
+import { relative, resolve } from 'pathe';
+import * as Effect from 'effect/Effect';
+import { getCappedPluginConcurrency } from './concurrency.js';
+import { runPluginEffect, tryPluginPromise } from './effect-runtime.js';
+import type { Config } from './react-router-config.js';
+import type { Route } from './types.js';
+
+type BuildManifest =
+  | {
+      routes: Record<string, Route>;
+    }
+  | {
+      routes: Record<string, Route>;
+      serverBundles: Record<string, { id: string; file: string }>;
+      routeIdToServerBundleId: Record<string, string>;
+    };
+
+const normalizePath = (value: string): string => value.replace(/\\/g, '/');
+
+const getAddressableRoutes = (routes: Record<string, Route>): Route[] => {
+  const nonAddressableIds = new Set<string>();
+  for (const id in routes) {
+    const route = routes[id];
+    if (route.index) {
+      if (!route.parentId) {
+        continue;
+      }
+      nonAddressableIds.add(route.parentId);
+    }
+    if (typeof route.path !== 'string' && !route.index) {
+      nonAddressableIds.add(id);
+    }
+  }
+  return Object.values(routes).filter(
+    route => !nonAddressableIds.has(route.id)
+  );
+};
+
+const getRouteBranch = (
+  routes: Record<string, Route>,
+  routeId: string
+): Route[] => {
+  const branch: Route[] = [];
+  let current = routeId;
+  while (current) {
+    const route = routes[current];
+    if (!route) {
+      throw new Error(`Missing route for ${current}`);
+    }
+    branch.push(route);
+    current = route.parentId || '';
+  }
+  return branch.reverse();
+};
+
+const configRouteToBranchRoute = (route: Route) => ({
+  id: route.id,
+  path: route.path,
+  file: route.file,
+  index: route.index,
+});
+
+const validateServerBundleId = (
+  serverBundleId: string,
+  future: Required<Config>['future']
+): Error | undefined => {
+  if (future?.v8_viteEnvironmentApi) {
+    return /^[a-zA-Z0-9_]+$/.test(serverBundleId)
+      ? undefined
+      : new Error(
+          'The "serverBundles" function must only return strings containing alphanumeric characters and underscores.'
+        );
+  }
+
+  return /^[a-zA-Z0-9-_]+$/.test(serverBundleId)
+    ? undefined
+    : new Error(
+        'The "serverBundles" function must only return strings containing alphanumeric characters, hyphens and underscores.'
+      );
+};
+
+type GetBuildManifestOptions = {
+  reactRouterConfig: Required<
+    Pick<
+      Config,
+      'appDirectory' | 'buildDirectory' | 'serverBuildFile' | 'future'
+    >
+  > &
+    Pick<Config, 'serverBundles'>;
+  routes: Record<string, Route>;
+  rootDirectory: string;
+};
+
+export const getBuildManifestEffect = ({
+  reactRouterConfig,
+  routes,
+  rootDirectory,
+}: GetBuildManifestOptions): Effect.Effect<
+  BuildManifest | undefined,
+  Error,
+  never
+> =>
+  Effect.gen(function* () {
+    const {
+      serverBundles,
+      appDirectory,
+      buildDirectory,
+      serverBuildFile,
+      future,
+    } = reactRouterConfig;
+
+    if (!serverBundles) {
+      return { routes };
+    }
+
+    const rootRelativeRoutes = Object.fromEntries(
+      Object.entries(routes).map(([id, route]) => {
+        const filePath = resolve(appDirectory, route.file);
+        return [
+          id,
+          { ...route, file: normalizePath(relative(rootDirectory, filePath)) },
+        ];
+      })
+    );
+
+    const serverBuildDirectory = resolve(buildDirectory, 'server');
+
+    const buildManifest: BuildManifest = {
+      routes: rootRelativeRoutes,
+      serverBundles: {},
+      routeIdToServerBundleId: {},
+    };
+
+    yield* Effect.forEach(
+      getAddressableRoutes(routes),
+      route =>
+        Effect.gen(function* () {
+          const branch = getRouteBranch(routes, route.id);
+          const serverBundleId = yield* tryPluginPromise(() =>
+            serverBundles({
+              branch: branch.map(branchRoute =>
+                configRouteToBranchRoute({
+                  ...branchRoute,
+                  file: resolve(appDirectory, branchRoute.file),
+                })
+              ),
+            })
+          );
+
+          if (typeof serverBundleId !== 'string') {
+            return yield* Effect.fail(
+              new Error('The "serverBundles" function must return a string')
+            );
+          }
+
+          const validationError = validateServerBundleId(
+            serverBundleId,
+            future
+          );
+          if (validationError) {
+            return yield* Effect.fail(validationError);
+          }
+
+          buildManifest.routeIdToServerBundleId![route.id] = serverBundleId;
+          buildManifest.serverBundles![serverBundleId] ??= {
+            id: serverBundleId,
+            file: normalizePath(
+              relative(
+                rootDirectory,
+                resolve(serverBuildDirectory, serverBundleId, serverBuildFile)
+              )
+            ),
+          };
+        }),
+      { concurrency: getCappedPluginConcurrency(), discard: true }
+    );
+
+    return buildManifest;
+  });
+
+export const getBuildManifest = (
+  options: GetBuildManifestOptions
+): Promise<BuildManifest | undefined> =>
+  runPluginEffect(getBuildManifestEffect(options));
+
+export const getRoutesByServerBundleId = (
+  buildManifest: BuildManifest | undefined,
+  sourceRoutes: Record<string, Route>
+): Record<string, Record<string, Route>> => {
+  if (!buildManifest || !('routeIdToServerBundleId' in buildManifest)) {
+    return {};
+  }
+
+  const routesByServerBundleId: Record<string, Record<string, Route>> = {};
+  for (const [routeId, serverBundleId] of Object.entries(
+    buildManifest.routeIdToServerBundleId
+  )) {
+    routesByServerBundleId[serverBundleId] ??= {};
+    const branch = getRouteBranch(sourceRoutes, routeId);
+    for (const route of branch) {
+      routesByServerBundleId[serverBundleId][route.id] = route;
+    }
+  }
+  return routesByServerBundleId;
+};