rsbuild-plugin-react-router 0.7.2 → 0.8.0

package/dist/manifest-assets.d.ts

@@ -0,0 +1,34 @@
+export type ReactRouterManifestStats = {
+    assetsByChunkName?: Record<string, string[]>;
+    entrypointFilesByName?: Record<string, string[]>;
+    assetTypesByName?: Record<string, string>;
+};
+type ManifestStatsChunk = {
+    files?: Iterable<string>;
+};
+type ManifestStatsEntrypoint = {
+    getFiles?: () => Iterable<string>;
+};
+type ManifestStatsLookup<T> = Iterable<[string, T | null | undefined]> & {
+    get?: (name: string) => T | null | undefined;
+};
+type ManifestStatsCompilation = {
+    namedChunks: ManifestStatsLookup<ManifestStatsChunk>;
+    entrypoints?: ManifestStatsLookup<ManifestStatsEntrypoint>;
+    getAsset?: (name: string) => {
+        name?: string;
+        info?: {
+            assetType?: string;
+            javascriptModule?: boolean;
+        };
+    } | void;
+};
+export declare const stripAssetQuery: (name: string) => string;
+export declare const getManifestAssetType: (name: string, assetTypesByName?: Readonly<Record<string, string>>) => string | undefined;
+export declare const createReactRouterManifestStats: (compilation: ManifestStatsCompilation | undefined, chunkNames?: ReadonlySet<string>) => ReactRouterManifestStats | undefined;
+type ChunkAssets = {
+    js: string[];
+    css: string[];
+};
+export declare const createChunkAssetResolver: (clientStats: ReactRouterManifestStats | undefined, includeEntrypointJavaScript: boolean) => ((chunkName: string) => ChunkAssets);
+export {};

package/dist/manifest-snapshot.d.ts

@@ -0,0 +1,17 @@
+import type { ReactRouterManifestForDev, RouteManifestModuleExports } from './manifest.js';
+import type { ReactRouterServerBuildPlan } from './server-build-plan.js';
+import type { Route } from './types.js';
+export type ReactRouterManifestSnapshot = {
+    browser: ReactRouterManifestForDev;
+    moduleExportsByRouteId: RouteManifestModuleExports;
+    server: ReactRouterManifestForDev;
+    serverByBundleId: Readonly<Record<string, ReactRouterManifestForDev>>;
+    serverByEntryName: Readonly<Record<string, ReactRouterManifestForDev>>;
+};
+export declare const createReactRouterManifestSnapshot: ({ manifest, sri, moduleExportsByRouteId, serverBuildPlan, routesByServerBundleId, }: {
+    manifest: ReactRouterManifestForDev;
+    sri: ReactRouterManifestForDev["sri"];
+    moduleExportsByRouteId: RouteManifestModuleExports;
+    serverBuildPlan: Pick<ReactRouterServerBuildPlan, "defaultEntryName" | "serverBundleEntries">;
+    routesByServerBundleId: Readonly<Record<string, Readonly<Record<string, Route>>>>;
+}) => ReactRouterManifestSnapshot;

package/dist/manifest-state.d.ts

@@ -0,0 +1,12 @@
+import type { RsbuildPluginAPI, Rspack } from '@rsbuild/core';
+import type { ReactRouterManifestSnapshot } from './manifest-snapshot.js';
+type ReactRouterManifestState = {
+    stage(compilation: Rspack.Compilation, snapshot: ReactRouterManifestSnapshot): void;
+    read(): ReactRouterManifestSnapshot | null;
+};
+export declare const createReactRouterManifestState: ({ api, isBuild, onPublish, }: {
+    api: Pick<RsbuildPluginAPI, "onBeforeEnvironmentCompile" | "onAfterEnvironmentCompile">;
+    isBuild: boolean;
+    onPublish: (compilation: Rspack.Compilation, snapshot: ReactRouterManifestSnapshot) => void;
+}) => ReactRouterManifestState;
+export {};

package/dist/manifest.d.ts

@@ -1,3 +1,5 @@
+import { type ReactRouterManifestStats } from './manifest-assets.js';
+export { createReactRouterManifestStats, type ReactRouterManifestStats, } from './manifest-assets.js';
 import type { Route, PluginOptions, RouteManifestItem } from './types.js';
 import { type RouteChunkCache } from './route-chunks.js';
 import { type RouteModuleAnalysis } from './export-utils.js';
@@ -44,26 +46,6 @@ export type ReactRouterManifestForDev = {
     sri?: Record<string, string> | true;
     routes: Record<string, RouteManifestItem>;
 };
-export type ReactRouterManifestStats = {
-    assetsByChunkName?: Record<string, string[]>;
-    entrypointFilesByName?: Record<string, string[]>;
-};
-type ReactRouterManifestStatsChunk = {
-    files?: Iterable<string>;
-};
-type ReactRouterManifestStatsEntrypoint = {
-    getFiles?: () => Iterable<string>;
-};
-type ReactRouterManifestStatsLookup<T> = Iterable<[
-    string,
-    T | null | undefined
-]> & {
-    get?: (name: string) => T | null | undefined;
-};
-type ReactRouterManifestStatsCompilation = {
-    namedChunks: ReactRouterManifestStatsLookup<ReactRouterManifestStatsChunk>;
-    entrypoints?: ReactRouterManifestStatsLookup<ReactRouterManifestStatsEntrypoint>;
-};
 export declare const isManifestJsAsset: (asset: string) => boolean;
 export declare const isManifestCssAsset: (asset: string) => boolean;
 /**
@@ -95,7 +77,6 @@ export type RscScriptAssetChunk = {
  * emits it, so function templates and `tools.rspack` overrides are covered.
  */
 export declare const collectUnsupportedRscScriptAssets: (compilation: RscScriptAssetCompilation) => string[];
-export declare const createReactRouterManifestStats: (compilation: ReactRouterManifestStatsCompilation | undefined, chunkNames?: ReadonlySet<string>) => ReactRouterManifestStats | undefined;
 export type RouteManifestModuleExports = Record<string, readonly string[]>;
 export type ReactRouterManifestGenerationResult = {
     manifest: ReactRouterManifestForDev;
@@ -109,4 +90,3 @@ export declare const getReactRouterManifestPath: ({ version, isBuild, entryModul
 export declare const getReactRouterManifestChunkNames: (routes: Record<string, Route>, appDirectory: string, splitRouteModules?: boolean | "enforce") => Set<string>;
 export declare function generateReactRouterManifestForDev(routes: Record<string, Route>, _options: PluginOptions, clientStats: ReactRouterManifestStats | undefined, context: string, assetPrefix?: string, manifestOptions?: ReactRouterManifestOptions): Promise<ReactRouterManifestGenerationResult>;
 export declare function getReactRouterManifestForDev(...args: Parameters<typeof generateReactRouterManifestForDev>): Promise<ReactRouterManifestForDev>;
-export {};

package/dist/modify-browser-manifest.d.ts

@@ -15,6 +15,8 @@ type CompilationAssetWithIntegrity = {
     };
     info?: {
         integrity?: unknown;
+        assetType?: string;
+        javascriptModule?: boolean;
     };
 };
 type CompilationWithIntegrityAssets = {

package/dist/node-only-manifest.d.ts

@@ -0,0 +1,8 @@
+import { type RsbuildPluginAPI } from '@rsbuild/core';
+import type { ReactRouterManifestSnapshot } from './manifest-snapshot.js';
+import type { Route } from './types.js';
+export declare const registerNodeOnlyManifestValidation: ({ api, routeByFilePath, getSnapshot, }: {
+    api: RsbuildPluginAPI;
+    routeByFilePath: ReadonlyMap<string, Route>;
+    getSnapshot: () => ReactRouterManifestSnapshot | null;
+}) => void;

package/dist/plugin-utils.d.ts

@@ -1,4 +1,4 @@
-export declare const resolveAppPackagePath: (specifier: string) => string | undefined;
+export declare const resolveAppPackagePath: (specifier: string, rootPath?: string) => string | undefined;
 export declare const parseVersionMajorMinor: (version: string | undefined) => {
     major: number;
     minor: number;

package/dist/rsc-prerender.d.ts

@@ -13,8 +13,9 @@ import type { Config } from './react-router-config.js';
  *   inline `__FLIGHT_DATA` scripts, served for client-side navigations
  *
  * Instead of an HTTP round-trip through a preview server, the RSC server
- * bundle's default-exported `fetch` handler is invoked in-process, matching
- * how classic mode prerenders through `createRequestHandler`.
+ * bundle's default-exported `fetch` handler is invoked directly (in the
+ * server build worker), matching how classic mode prerenders through
+ * `createRequestHandler`.
  */
 export declare const SPA_FALLBACK_REQUEST_PATH: string;
 type RscPrerenderBuildApi = Pick<RsbuildPluginAPI, 'logger'>;

package/dist/server-build-worker-client.d.ts

@@ -0,0 +1,20 @@
+import { type ServerBuildDescription, type ServerBuildWorkerData } from './server-build-worker-protocol.js';
+export type ServerBuildWorker = {
+    /** Plain-data view of the classic server build (routes, assets, prerender). */
+    description: ServerBuildDescription | undefined;
+    /** Runs the request against the server build in the worker. */
+    handler(request: Request): Promise<Response>;
+    /** Terminates the worker, and with it any handle the server graph opened. */
+    close(): Promise<void>;
+};
+/**
+ * Evaluate a built server bundle in a worker thread and proxy requests to it.
+ * Build-time rendering used to `import()` the bundle into the build process;
+ * a module-scope handle in the app's server graph then kept `rsbuild build`
+ * alive forever (#135). The worker is terminated by `close()`.
+ *
+ * The worker's `exit` is its final event, so any exit (including one between
+ * requests, e.g. the app calling `process.exit`) is terminal: outstanding and
+ * later requests reject instead of waiting for a reply that cannot come.
+ */
+export declare const startServerBuildWorker: (data: ServerBuildWorkerData, workerPath?: string) => Promise<ServerBuildWorker>;

package/dist/server-build-worker-protocol.d.ts

@@ -0,0 +1,84 @@
+/** Headers as a structured-cloneable list (the DOM lib's Headers is not iterable here). */
+export declare const headerEntries: (headers: Headers) => [string, string][];
+export type ServerBuildWorkerData = {
+    serverBuildPath: string;
+    mode: 'classic' | 'rsc';
+};
+export type ServerBuildWorkerRequest = {
+    type: 'close';
+} | {
+    id: number;
+    type: 'request';
+    url: string;
+    method: string;
+    headers: [string, string][];
+    body?: Uint8Array<ArrayBuffer>;
+}
+/** Consume a response body only when the parent asks for it. */
+ | {
+    id: number;
+    type: 'read';
+}
+/** The parent released the request, possibly without reading its body. */
+ | {
+    id: number;
+    type: 'abort';
+};
+export type SerializedResponse = {
+    status: number;
+    statusText: string;
+    headers: [string, string][];
+    hasBody: boolean;
+};
+export type SerializedError = {
+    message: string;
+    stack?: string;
+    name?: string;
+};
+export type ServerBuildWorkerResponse = {
+    type: 'closed';
+}
+/** Sent once the bundle is evaluated; carries the classic build description. */
+ | {
+    type: 'ready';
+    description?: ServerBuildDescription;
+} | {
+    type: 'reply';
+    id: number;
+    ok: true;
+    response: SerializedResponse;
+} | {
+    type: 'body';
+    id: number;
+    ok: true;
+    body: Uint8Array<ArrayBuffer>;
+} | {
+    type: 'reply';
+    id: number;
+    ok: false;
+    error: SerializedError;
+};
+/**
+ * The parts of a classic React Router server build that build-time rendering
+ * reads, as plain data: route module exports are reported by presence only.
+ */
+export type ServerBuildDescription = {
+    prerender?: string[];
+    routes: Record<string, {
+        id?: string;
+        parentId?: string;
+        path?: string;
+        index?: boolean;
+        caseSensitive?: boolean;
+        module: {
+            default: boolean;
+            ErrorBoundary: boolean;
+            loader: boolean;
+        };
+    }>;
+    assets: {
+        routes: Record<string, {
+            hasLoader?: boolean;
+        }>;
+    };
+};

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

@@ -0,0 +1 @@
+export {};

package/dist/server-build-worker.js

@@ -0,0 +1,123 @@
+let description, handler;
+import { parentPort, workerData } from "node:worker_threads";
+import { pathToFileURL } from "node:url";
+import { createRequestHandler } from "react-router";
+import { PLUGIN_NAME } from "./468.js";
+import { resolveServerBuildModule, headerEntries } from "./819.js";
+if (!parentPort) throw Error('server-build-worker must run as a worker thread');
+let { serverBuildPath: serverBuildPath, mode: mode } = workerData;
+process.env.IS_RR_BUILD_REQUEST = 'yes';
+let post = (message, transfer = [])=>{
+    parentPort.postMessage(message, transfer);
+}, serializeError = (error)=>({
+        message: String(error?.message ?? error),
+        stack: 'string' == typeof error?.stack ? error.stack : void 0,
+        name: 'string' == typeof error?.name ? error.name : void 0
+    }), server_build_worker_buildModule = await import(pathToFileURL(serverBuildPath).href);
+if ('classic' === mode) {
+    let build = await resolveServerBuildModule(server_build_worker_buildModule, `Server build ${JSON.stringify(serverBuildPath)}`);
+    description = {
+        prerender: build.prerender,
+        routes: Object.fromEntries(Object.entries(build.routes).flatMap(([id, route])=>route ? [
+                [
+                    id,
+                    {
+                        id: route.id,
+                        parentId: route.parentId,
+                        path: route.path,
+                        index: route.index,
+                        caseSensitive: route.caseSensitive,
+                        module: {
+                            default: void 0 !== route.module.default,
+                            ErrorBoundary: void 0 !== route.module.ErrorBoundary,
+                            loader: void 0 !== route.module.loader
+                        }
+                    }
+                ]
+            ] : [])),
+        assets: {
+            routes: Object.fromEntries(Object.entries(build.assets.routes).flatMap(([id, route])=>route ? [
+                    [
+                        id,
+                        {
+                            hasLoader: route.hasLoader
+                        }
+                    ]
+                ] : []))
+        }
+    }, handler = createRequestHandler(build, 'production');
+} else handler = ((buildModule)=>{
+    let fetch = 'function' == typeof buildModule?.default?.fetch ? buildModule.default.fetch : 'function' == typeof buildModule?.default?.default?.fetch ? buildModule.default.default.fetch : null;
+    if (!fetch) throw Error(`[${PLUGIN_NAME}] RSC server build ${JSON.stringify(serverBuildPath)} must default-export an object with a fetch function.`);
+    return fetch;
+})(server_build_worker_buildModule);
+let controllers = new Map(), responses = new Map(), release = (id)=>{
+    controllers.get(id)?.abort(), controllers.delete(id), responses.delete(id);
+};
+parentPort.on('message', async (message)=>{
+    if ('close' === message.type) {
+        for (let id of controllers.keys())release(id);
+        post({
+            type: 'closed'
+        });
+        return;
+    }
+    if ('abort' === message.type) {
+        responses.get(message.id)?.body?.cancel().catch(()=>{}), release(message.id);
+        return;
+    }
+    if ('read' === message.type) {
+        try {
+            let response = responses.get(message.id);
+            if (!response) throw Error('Server build response was released');
+            let body = new Uint8Array(await response.arrayBuffer());
+            release(message.id), post({
+                type: 'body',
+                id: message.id,
+                ok: !0,
+                body
+            }, [
+                body.buffer
+            ]);
+        } catch (error) {
+            release(message.id), post({
+                type: 'reply',
+                id: message.id,
+                ok: !1,
+                error: serializeError(error)
+            });
+        }
+        return;
+    }
+    let controller = new AbortController();
+    controllers.set(message.id, controller);
+    try {
+        let response = await handler(new Request(message.url, {
+            method: message.method,
+            headers: message.headers,
+            body: message.body,
+            signal: controller.signal
+        }));
+        response.body ? responses.set(message.id, response) : release(message.id), post({
+            type: 'reply',
+            id: message.id,
+            ok: !0,
+            response: {
+                status: response.status,
+                statusText: response.statusText,
+                headers: headerEntries(response.headers),
+                hasBody: null !== response.body
+            }
+        });
+    } catch (error) {
+        release(message.id), post({
+            type: 'reply',
+            id: message.id,
+            ok: !1,
+            error: serializeError(error)
+        });
+    }
+}), post({
+    type: 'ready',
+    description: description
+});

package/dist/server-utils.d.ts

@@ -1,5 +1,4 @@
 import type { ServerBuild } from 'react-router';
-import { resolveServerBuildModule } from './server-build-resolution.js';
 import type { Route } from './types.js';
 /**
  * Generates the server build template string.
@@ -34,5 +33,5 @@ interface ServerBuildOptions {
  * @returns The generated module content as a string
  */
 export declare function generateServerBuild(routes: Record<string, Route>, options: ServerBuildOptions): string;
-export { resolveServerBuildModule };
 export declare function resolveReactRouterServerBuild(buildModule: unknown): Promise<ServerBuild>;
+export {};

package/dist/types.d.ts

@@ -9,6 +9,12 @@ export type Route = {
     children?: Route[];
 };
 export type PluginOptions = {
+    /**
+     * Generate React Router route types during development and builds.
+     * Set to false when type generation is managed separately.
+     * @default true
+     */
+    typegen?: boolean;
     /**
      * Whether to disable automatic middleware setup for custom server implementation.
      * Use this when you want to handle server setup manually.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rsbuild-plugin-react-router",
-  "version": "0.7.2",
+  "version": "0.8.0",
   "description": "React Router plugin for Rsbuild",
   "repository": {
     "type": "git",
@@ -86,7 +86,7 @@
     "@react-router/fs-routes": "^8.3.1",
     "@react-router/remix-routes-option-adapter": "^8.3.1",
     "@react-router/serve": "^8.3.1",
-    "@rsbuild/core": "2.2.0",
+    "@rsbuild/core": "2.2.8",
     "@rsbuild/plugin-less": "1.6.4",
     "@rsbuild/plugin-mdx": "^1.1.3",
     "@rsbuild/plugin-react": "2.1.0",
@@ -94,7 +94,7 @@
     "@rsbuild/plugin-svgr": "2.0.4",
     "@rsbuild/plugin-tailwindcss": "2.0.3",
     "@rslib/core": "^0.23.2",
-    "@rspack/core": "2.2.0",
+    "@rspack/core": "2.2.6",
     "@rstest/core": "^0.11.4",
     "@rstest/coverage-istanbul": "^0.11.4",
     "@swc/helpers": "^0.5.23",
@@ -136,7 +136,7 @@
   },
   "peerDependencies": {
     "@react-router/dev": "^7.13.0 || ^8.0.0",
-    "@rsbuild/core": "^2.2.0",
+    "@rsbuild/core": "^2.2.8",
     "react-router": "^7.13.0 || ^8.0.0",
     "react-server-dom-rspack": "0.1.0",
     "rsbuild-plugin-rsc": "^0.1.1"

package/src/build-output-transforms.ts

@@ -1,3 +1,4 @@
+import { existsSync } from 'node:fs';
 import type { RsbuildPluginAPI, TransformHandler } from '@rsbuild/core';
 import jsesc from 'jsesc';
 import { relative } from 'pathe';
@@ -80,6 +81,8 @@ type RegisterBuildOutputTransformsOptions = {
   resolvedServerOutput: 'module' | 'commonjs';
   performanceProfiler: ReactRouterPerformanceProfiler;
   getLatestServerManifest: () => ReactRouterManifest | null;
+  /** File holding the captured manifests; a dependency of the server-manifest module. */
+  serverManifestStampPath: string;
   getLatestServerManifestByBundleId: (
     bundleId: string
   ) => ReactRouterManifest | undefined;
@@ -112,6 +115,7 @@ export const registerBuildOutputTransforms = ({
   resolvedServerOutput,
   performanceProfiler,
   getLatestServerManifest,
+  serverManifestStampPath,
   getLatestServerManifestByBundleId,
   routes,
   pluginOptions,
@@ -191,7 +195,7 @@ export const registerBuildOutputTransforms = ({
 
   api.transform(
     {
-      test: /virtual\/react-router\/(browser|server)-manifest/,
+      test: /virtual\/react-router\/((browser|server)-manifest|server-build)/,
     },
     async args =>
       performanceProfiler.record(
@@ -205,11 +209,28 @@ export const registerBuildOutputTransforms = ({
             };
           }
 
+          // Cache identity for a module whose source never changes (#136);
+          // see `serverManifestStampPath` in index.ts.
+          if (existsSync(serverManifestStampPath)) {
+            args.addDependency(serverManifestStampPath);
+          } else {
+            args.addMissingDependency(serverManifestStampPath);
+          }
+          // The virtual server build contains the bundle's route table. A
+          // partition change must invalidate it alongside the asset manifest.
+          if (args.resource.includes('virtual/react-router/server-build')) {
+            return { code: args.code };
+          }
           const bundleMatch = args.resource.match(
             /virtual\/react-router\/server-manifest(?:-([^?]+))?/
           );
           const bundleId = bundleMatch?.[1]?.replace(/\.js$/, '');
           const latestServerManifest = getLatestServerManifest();
+          if (isBuild && !latestServerManifest) {
+            throw new Error(
+              `[${PLUGIN_NAME}] Production server manifest requested before the browser manifest was finalized.`
+            );
+          }
           const manifest =
             (latestServerManifest
               ? ((bundleId && getLatestServerManifestByBundleId(bundleId)) ??

package/src/classic-mode.ts

@@ -125,7 +125,6 @@ export const createClassicBuildArtifacts = async ({
       isBuild,
       buildPlan: serverBuildPlan,
       clientPatchesRouteMetadata: devHmr?.isEnabled,
-      onNodeRebuildCommitted: devHmr?.onNodeRebuildCommitted,
     }),
     prerenderPaths,
     routesByServerBundleId,

package/src/constants.ts

@@ -93,3 +93,6 @@ export const CLIENT_EXPORTS = {
 
 // SPA-mode prerender fallback document, served when no prerendered page matches.
 export const SPA_FALLBACK_HTML_FILE = '__spa-fallback.html';
+
+export const BROWSER_MANIFEST_ENTRY_NAME =
+  'virtual/react-router/browser-manifest';

package/src/dev-hdr-channel.ts

@@ -0,0 +1,38 @@
+import { randomUUID } from 'node:crypto';
+import type { RsbuildDevServer } from '@rsbuild/core';
+
+export const DEV_HDR_UPDATE_EVENT = 'react-router:hdr-update';
+
+export const createDevHdrChannel = ({
+  hot,
+  isEnabled,
+}: {
+  hot: RsbuildDevServer['environments'][string]['hot'];
+  isEnabled: () => boolean;
+}) => {
+  const sessionId = randomUUID();
+  let revision = 0;
+  let closed = false;
+  const payload = () => ({
+    event: DEV_HDR_UPDATE_EVENT,
+    data: { sessionId, revision },
+  });
+  const unsubscribe = hot.onConnect(client => {
+    if (!closed && isEnabled() && revision > 0) {
+      client.send('custom', payload());
+    }
+  });
+
+  return {
+    publish(): void {
+      if (closed || !isEnabled()) return;
+      revision += 1;
+      hot.send('custom', payload());
+    },
+    close(): void {
+      if (closed) return;
+      closed = true;
+      unsubscribe();
+    },
+  };
+};