rsbuild-plugin-react-router 0.4.1 → 0.5.0

package/README.md

@@ -77,16 +77,16 @@ pluginReactRouter({
 });
 ```
 
-| Option                           | Default     | Description                                                                                                                                                                                                                                                                                                                                          |
-| -------------------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `customServer`                   | `false`     | Disables the built-in development SSR middleware. Enable this when an app owns the server with `createDevServer()` or an adapter.                                                                                                                                                                                                                    |
-| `serverOutput`                   | Derived     | Emitted Rsbuild server format: `'module'` or `'commonjs'`. When omitted, React Router's `serverModuleFormat` selects the format (`'esm'` -> `'module'`, `'cjs'` -> `'commonjs'`); setting `serverOutput` overrides it.                                                                                                                               |
-| `lazyCompilation`                | `true`      | Optional Rsbuild dev lazy-compilation config. When enabled here or through `dev.lazyCompilation`, React Router hydration-critical modules stay eager so the browser manifest and route modules are not replaced by lazy proxies.                                                                                                                     |
-| `unstableLazyCompilationPrewarm` | `false`     | Experimental prewarm for emitted Rspack lazy-compilation proxy modules after dev compiles. Enable with `true` when route JS proxy startup should happen shortly after compiler readiness.                                                                                                                                                            |
-| `logPerformance`                 | `false`     | Logs structured React Router plugin timing information through the Rsbuild logger.                                                                                                                                                                                                                                                                   |
-| `parallelRouteTransform`         | `undefined` | Controls worker-thread route transforms. `undefined` auto-enables workers for 256+ routes, `true` forces the default worker count (in dev this is 0 on machines with 4 or fewer cores, where workers cost more than they save; production builds always use workers), a positive integer sets the worker count, and `false` keeps transforms inline. |
-| `onRouteTopologyChange`          | `undefined` | Notification for programmatic/custom dev servers. Recreate the Rsbuild server when route files are added, removed, or moved. The callback is not awaited.                                                                                                                                                                                            |
-| `federation`                     | `false`     | Enables the plugin's experimental Module Federation integration.                                                                                                                                                                                                                                                                                     |
+| Option                           | Default     | Description                                                                                                                                                                                                                      |
+| -------------------------------- | ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `customServer`                   | `false`     | Disables the built-in development SSR middleware. Enable this when an app owns the server with `createDevServer()` or an adapter.                                                                                                |
+| `serverOutput`                   | Derived     | Emitted Rsbuild server format: `'module'` or `'commonjs'`. When omitted, React Router's `serverModuleFormat` selects the format (`'esm'` -> `'module'`, `'cjs'` -> `'commonjs'`); setting `serverOutput` overrides it.           |
+| `lazyCompilation`                | `true`      | Optional Rsbuild dev lazy-compilation config. When enabled here or through `dev.lazyCompilation`, React Router hydration-critical modules stay eager so the browser manifest and route modules are not replaced by lazy proxies. |
+| `unstableLazyCompilationPrewarm` | `false`     | Experimental prewarm for emitted Rspack lazy-compilation proxy modules after dev compiles. Enable with `true` when route JS proxy startup should happen shortly after compiler readiness.                                        |
+| `logPerformance`                 | `false`     | Logs structured React Router plugin timing information.                                                                                                                                                                          |
+| `parallelRouteTransform`         | `undefined` | Controls worker-thread route transforms. `undefined` and `false` keep transforms inline, `true` uses Rspack's default worker count, and a positive integer sets the maximum worker count.                                        |
+| `onRouteTopologyChange`          | `undefined` | Notification for programmatic/custom dev servers. Recreate the Rsbuild server when route files are added, removed, or moved. The callback is not awaited.                                                                        |
+| `federation`                     | `false`     | Enables the plugin's experimental Module Federation integration.                                                                                                                                                                 |
 
 When `federation` is enabled, configure the Module Federation plugin with
 `experiments.asyncStartup: true`. The dev server resolves async server build
@@ -655,35 +655,17 @@ The plugin automatically:
 
 ### Benchmarking
 
-`pnpm bench:large` runs this repository's generated stress fixture for quick
-regression checks. `pnpm bench:synthetic-app` runs the embedded complex Rsbuild
-app under `benchmarks/synthetic-web-bundler-benchmark`, which adds heavier
-loader and transform contention for benchmark coverage closer to a large
-real-world application.
+Run the focused local suite for plugin regression checks:
 
 ```bash
-pnpm bench:large
-pnpm bench:synthetic-app -- --profile all --runs 2
+pnpm bench
+pnpm bench:smoke
+pnpm bench:codspeed
 ```
 
-The PR benchmark workflow reports production build, dev route-load, HMR/update,
-and embedded synthetic app timings in the same benchmark comment. It measures
-the PR and its base on the same runner instead of reusing cached timing data,
-counterbalances which side runs first, and excludes one warmup iteration. Small
-fixtures use five measured iterations; expensive large fixtures use three.
-
-Every raw median delta remains visible. The comment also reports each side's
-relative median absolute deviation (rMAD), a conservative noise band, and a
-signal label:
-
-- `regression` or `improvement` means the median delta exceeds the observed
-  run-to-run noise band.
-- `inconclusive` means the raw delta is not clearly separated from that noise.
-- `insufficient data` means either side has fewer than three finite samples.
-
-The labels are triage aids, not pass/fail gates. Use the uploaded diagnostics
-and raw per-run samples to investigate important changes, and rerun an
-inconclusive comparison before treating it as a performance result.
+See the [benchmark guide](./benchmarks/README.md) for JSON output, pull-request
+comparisons and comments, `BENCHMARK_PLUGIN_ROOT`, and optional CodSpeed
+publication.
 
 ## React Router Framework Mode
 

package/dist/{451.js → 511.js}

@@ -1217,5 +1217,96 @@ if (import.meta.webpackHot) {
         case 'routeModule':
             return transformRouteModule(task);
     }
+}, roundMs = (value)=>Math.round(10 * value) / 10, createReactRouterPerformanceProfiler = ({ enabled, log })=>{
+    let timingsByEnvironment = new Map(), recordDuration = (environment, operation, resource, startMs, endMs)=>{
+        let timings, timing, duration = endMs - startMs, timing1 = ((timings = timingsByEnvironment.get(environment)) || (timings = new Map(), timingsByEnvironment.set(environment, timings)), (timing = timings.get(operation)) || (timing = {
+            count: 0,
+            totalMs: 0,
+            maxMs: 0,
+            slowest: [],
+            intervals: []
+        }, timings.set(operation, timing)), timing);
+        timing1.count += 1, timing1.totalMs += duration, timing1.maxMs = Math.max(timing1.maxMs, duration), timing1.intervals.push({
+            startMs,
+            endMs
+        }), ((slowest, entry)=>{
+            if (5 === slowest.length && entry.durationMs <= slowest[slowest.length - 1].durationMs) return;
+            let insertIndex = slowest.length;
+            for(; insertIndex > 0 && entry.durationMs > slowest[insertIndex - 1].durationMs;)insertIndex -= 1;
+            slowest.splice(insertIndex, 0, entry), slowest.length > 5 && slowest.pop();
+        })(timing1.slowest, {
+            durationMs: duration,
+            resource
+        });
+    };
+    return {
+        record (environment, operation, resource, callback) {
+            if (!enabled) try {
+                return Promise.resolve(callback());
+            } catch (error) {
+                return Promise.reject(error);
+            }
+            let resolvedEnvironment = environment ?? 'unknown', start = performance.now();
+            try {
+                return callback().then((result)=>{
+                    let end = performance.now();
+                    return recordDuration(resolvedEnvironment, operation, resource, start, end), result;
+                }, (error)=>{
+                    let end = performance.now();
+                    throw recordDuration(resolvedEnvironment, operation, resource, start, end), error;
+                });
+            } catch (error) {
+                return recordDuration(resolvedEnvironment, operation, resource, start, performance.now()), Promise.reject(error);
+            }
+        },
+        recordSync (environment, operation, resource, callback) {
+            if (!enabled) return callback();
+            let start = performance.now();
+            try {
+                return callback();
+            } finally{
+                recordDuration(environment ?? 'unknown', operation, resource, start, performance.now());
+            }
+        },
+        flush (environment, details = {}) {
+            let report;
+            if (!enabled) return;
+            let resolvedEnvironment = environment ?? 'unknown', timings = timingsByEnvironment.get(resolvedEnvironment);
+            if (!timings || 0 === timings.size) return;
+            let operations = Object.fromEntries([
+                ...timings.entries()
+            ].map(([operation, timing])=>[
+                    operation,
+                    {
+                        count: timing.count,
+                        totalMs: roundMs(timing.totalMs),
+                        wallMs: ((intervals)=>{
+                            if (0 === intervals.length) return 0;
+                            let sortedIntervals = [
+                                ...intervals
+                            ].sort((a, b)=>a.startMs - b.startMs || a.endMs - b.endMs), mergedStart = sortedIntervals[0].startMs, mergedEnd = sortedIntervals[0].endMs, wallMs = 0;
+                            for (let interval of sortedIntervals.slice(1)){
+                                if (interval.startMs <= mergedEnd) {
+                                    mergedEnd = Math.max(mergedEnd, interval.endMs);
+                                    continue;
+                                }
+                                wallMs += mergedEnd - mergedStart, mergedStart = interval.startMs, mergedEnd = interval.endMs;
+                            }
+                            return roundMs(wallMs += mergedEnd - mergedStart);
+                        })(timing.intervals),
+                        maxMs: roundMs(timing.maxMs),
+                        slowest: timing.slowest.map((entry)=>({
+                                durationMs: roundMs(entry.durationMs),
+                                resource: entry.resource
+                            }))
+                    }
+                ]));
+            log((report = {
+                environment: resolvedEnvironment,
+                ...details,
+                operations
+            }, `[react-router:performance] ${JSON.stringify(report)}`)), timingsByEnvironment.delete(resolvedEnvironment);
+        }
+    };
 };
-export { BUILD_CLIENT_ROUTE_QUERY_STRING, CLIENT_EXPORTS, HMR_PATCHABLE_ROUTE_FLAGS, JS_EXTENSIONS, PLUGIN_NAME, SERVER_EXPORTS, buildManifestChunkValidity, combineURLs, createBundlerRouteExportResolver, createEmptyRouteChunkByExportName, createRouteId, detectRouteChunksIfEnabled, executeRouteTransformTask, findEntryFile, generateWithProps, getRouteChunkEntryName, getRouteChunkModuleId, getRouteModuleAnalysis, normalizeAssetPrefix, routeChunkExportNames, setBoundedCacheEntry, validateRouteChunks };
+export { BUILD_CLIENT_ROUTE_QUERY_STRING, CLIENT_EXPORTS, HMR_PATCHABLE_ROUTE_FLAGS, JS_EXTENSIONS, PLUGIN_NAME, SERVER_EXPORTS, buildManifestChunkValidity, combineURLs, createBundlerRouteExportResolver, createEmptyRouteChunkByExportName, createReactRouterPerformanceProfiler, createRouteId, detectRouteChunksIfEnabled, executeRouteTransformTask, findEntryFile, generateWithProps, getRouteChunkEntryName, getRouteChunkModuleId, getRouteModuleAnalysis, normalizeAssetPrefix, roundMs, routeChunkExportNames, validateRouteChunks };

package/dist/build-output-transforms.d.ts

@@ -1,8 +1,8 @@
 import type { RsbuildPluginAPI } from '@rsbuild/core';
 import { getReactRouterManifestForDev, type ReactRouterManifestStats } from './manifest.js';
-import type { RouteTransformExecutor } from './parallel-route-transforms.js';
 import type { ReactRouterPerformanceProfiler } from './performance.js';
 import type { RouteChunkConfig } from './route-chunks.js';
+import type { RouteTransformRunner } from './route-transform-tasks.js';
 import type { PluginOptions, Route } from './types.js';
 type ReactRouterManifest = Awaited<ReturnType<typeof getReactRouterManifestForDev>>;
 type RegisterBuildOutputTransformsOptions = {
@@ -17,15 +17,16 @@ type RegisterBuildOutputTransformsOptions = {
     appDirectory: string;
     getAssetPrefix: () => string;
     routeChunkOptions: Parameters<typeof getReactRouterManifestForDev>[5];
-    routeTransformExecutor: RouteTransformExecutor;
+    routeTransformRunner: RouteTransformRunner;
     routeByFilePath: Map<string, Route>;
     routeChunkConfig: RouteChunkConfig;
     isBuild: boolean;
     splitRouteModules: boolean;
+    useRouteModuleTransformApi: boolean;
     ssr: boolean;
     isSpaMode: boolean;
     rootRoutePath: string;
     isDevHmrEnabled?: () => boolean;
 };
-export declare const registerBuildOutputTransforms: ({ api, resolvedServerOutput, performanceProfiler, getLatestServerManifest, getLatestServerManifestByBundleId, routes, pluginOptions, getClientStats, appDirectory, getAssetPrefix, routeChunkOptions, routeTransformExecutor, routeByFilePath, routeChunkConfig, isBuild, splitRouteModules, ssr, isSpaMode, rootRoutePath, isDevHmrEnabled, }: RegisterBuildOutputTransformsOptions) => void;
+export declare const registerBuildOutputTransforms: ({ api, resolvedServerOutput, performanceProfiler, getLatestServerManifest, getLatestServerManifestByBundleId, routes, pluginOptions, getClientStats, appDirectory, getAssetPrefix, routeChunkOptions, routeTransformRunner, routeByFilePath, routeChunkConfig, isBuild, splitRouteModules, useRouteModuleTransformApi, ssr, isSpaMode, rootRoutePath, isDevHmrEnabled, }: RegisterBuildOutputTransformsOptions) => void;
 export {};

package/dist/dev-background-resources.d.ts

@@ -1,14 +1,12 @@
 import type { RsbuildPluginAPI } from '@rsbuild/core';
 import type { RouteConfigEntry } from '@react-router/dev/routes';
 import { type ReactRouterManifestForDev } from './manifest.js';
-import type { RouteTransformExecutor } from './parallel-route-transforms.js';
 import { type WatchFileConfig } from './route-watch.js';
 import type { PluginOptions } from './types.js';
 type RegisterReactRouterDevBackgroundResourcesOptions = {
     api: RsbuildPluginAPI;
     isBuild: boolean;
     lazyCompilationPrewarm: PluginOptions['unstableLazyCompilationPrewarm'];
-    routeTransformExecutor: RouteTransformExecutor;
     routeRestartMarkerPath: string;
     watchDirectory: string;
     getRouteTopology: () => Promise<Set<string>>;
@@ -34,5 +32,5 @@ export declare const createReactRouterRouteWatchFiles: ({ configWatchPaths, rout
     routeRestartMarkerPath: string;
     onRouteTopologyChange: PluginOptions["onRouteTopologyChange"];
 }) => WatchFileConfig[];
-export declare const registerReactRouterDevBackgroundResources: ({ api, isBuild, lazyCompilationPrewarm, routeTransformExecutor, routeRestartMarkerPath, watchDirectory, getRouteTopology, initialRouteTopology, onRouteTopologyChange, }: RegisterReactRouterDevBackgroundResourcesOptions) => ReactRouterDevBackgroundResources;
+export declare const registerReactRouterDevBackgroundResources: ({ api, isBuild, lazyCompilationPrewarm, routeRestartMarkerPath, watchDirectory, getRouteTopology, initialRouteTopology, onRouteTopologyChange, }: RegisterReactRouterDevBackgroundResourcesOptions) => ReactRouterDevBackgroundResources;
 export {};

package/dist/federation.d.ts

@@ -0,0 +1,2 @@
+import type { Rspack } from '@rsbuild/core';
+export declare const ensureFederationAsyncStartup: (rspackConfig: Rspack.Configuration | undefined) => void;