rsbuild-plugin-react-router 0.7.3 → 0.8.0

package/README.md

@@ -76,6 +76,16 @@ rsbuild.config.ts
 
 ## Configuration
 
+This plugin requires Rsbuild 2.2.8 or newer. Development hot data revalidation
+uses its custom-event connection API and no longer writes an HDR revision file.
+
+For server-only changes, `rsbuild build --environment node` can reuse the
+finalized browser manifest from a previous full build in the same project.
+Keep the browser output and build cache. Run a full build after changing routes
+or browser assets, or adding or removing a route's `loader` or `action` export.
+Node-only builds check the compiled exports against the cached manifest. If the
+manifest is missing or incompatible, the build fails and asks for a full build.
+
 React Router application settings live in `react-router.config.*`. The Rsbuild
 plugin only needs options for Rsbuild-specific behavior.
 
@@ -83,6 +93,7 @@ plugin only needs options for Rsbuild-specific behavior.
 
 ```ts
 pluginReactRouter({
+  typegen: true,
   customServer: false,
   lazyCompilation: true,
   unstableLazyCompilationPrewarm: false,
@@ -93,12 +104,13 @@ pluginReactRouter({
 
 | Option                           | Default     | Description                                                                                                                                                                                                                      |
 | -------------------------------- | ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `typegen`                        | `true`      | Generates React Router route types during development and builds. Set to `false` when type generation is managed separately.                                                                                                     |
 | `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 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 an automatic worker count, and a positive integer sets the maximum worker count.                                             |
+| `parallelRouteTransform`         | `undefined` | Controls worker-thread route transforms. `undefined` and `false` keep transforms inline, `true` uses an automatic 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.                                                                                                                                                                 |
 

package/dist/468.js

@@ -44,5 +44,5 @@ let PLUGIN_NAME = 'rsbuild:react-router', DEFAULT_JS_DIST_PATH = 'static/js', JS
     links: 'links',
     meta: 'meta',
     shouldRevalidate: 'shouldRevalidate'
-}, SPA_FALLBACK_HTML_FILE = '__spa-fallback.html';
-export { BUILD_CLIENT_ROUTE_QUERY_STRING, CLIENT_EXPORTS, CLIENT_NON_COMPONENT_EXPORTS, CLIENT_ROUTE_EXPORTS_SET, DEFAULT_JS_DIST_PATH, JS_EXTENSIONS, NAMED_COMPONENT_EXPORTS_SET, PLUGIN_NAME, SERVER_EXPORTS, SERVER_ONLY_ROUTE_EXPORTS, SERVER_ONLY_ROUTE_EXPORTS_SET, SPA_FALLBACK_HTML_FILE };
+}, SPA_FALLBACK_HTML_FILE = '__spa-fallback.html', BROWSER_MANIFEST_ENTRY_NAME = 'virtual/react-router/browser-manifest';
+export { BROWSER_MANIFEST_ENTRY_NAME, BUILD_CLIENT_ROUTE_QUERY_STRING, CLIENT_EXPORTS, CLIENT_NON_COMPONENT_EXPORTS, CLIENT_ROUTE_EXPORTS_SET, DEFAULT_JS_DIST_PATH, JS_EXTENSIONS, NAMED_COMPONENT_EXPORTS_SET, PLUGIN_NAME, SERVER_EXPORTS, SERVER_ONLY_ROUTE_EXPORTS, SERVER_ONLY_ROUTE_EXPORTS_SET, SPA_FALLBACK_HTML_FILE };

package/dist/511.js

@@ -2,7 +2,7 @@ import { basename, dirname, normalize, relative, resolve } from "pathe";
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { createRequire } from "node:module";
 import { langFromPath, parse, walk as external_yuku_parser_walk } from "yuku-parser";
-import { Analyzer } from "yuku-analyzer";
+import { Analyzer, SymbolFlags } from "yuku-analyzer";
 import { print } from "yuku-codegen";
 import { readFile, stat } from "node:fs/promises";
 import { rspack } from "@rsbuild/core";
@@ -300,9 +300,9 @@ let getProgram = (ast)=>ast.program ?? ast, getPatternIdentifierNames = (pattern
         if (declaration && declarationIncludesName(declaration, name)) return !0;
     }
     return !1;
-}, requireFromApp = createRequire(resolve(process.cwd(), 'package.json')), resolveAppPackagePath = (specifier)=>{
+}, requireFromApp = createRequire(resolve(process.cwd(), 'package.json')), resolveAppPackagePath = (specifier, rootPath)=>{
     try {
-        return requireFromApp.resolve(specifier);
+        return (rootPath ? createRequire(resolve(rootPath, 'package.json')) : requireFromApp).resolve(specifier);
     } catch  {
         return;
     }
@@ -408,12 +408,7 @@ let mightContainRouteChunkExportName = (source)=>routeChunkExportNames.some((exp
             module,
             program: module.ast
         };
-    }), isTopLevelExportedVariableDeclarator = (module, node)=>{
-    let declaration = module.parentOf(node);
-    if (declaration?.type !== 'VariableDeclaration') return !1;
-    let statement = module.parentOf(declaration);
-    return statement?.type === 'ExportNamedDeclaration';
-}, route_chunks_getExportedName = (exported)=>'Identifier' === exported.type ? exported.name : String(exported.value), setsIntersect = (set1, set2)=>{
+    }), route_chunks_getExportedName = (exported)=>'Identifier' === exported.type ? exported.name : String(exported.value), setsIntersect = (set1, set2)=>{
     let smallerSet = set1, largerSet = set2;
     for (let element of (set1.size > set2.size && (smallerSet = set2, largerSet = set1), smallerSet))if (largerSet.has(element)) return !0;
     return !1;
@@ -422,7 +417,13 @@ let mightContainRouteChunkExportName = (source)=>routeChunkExportNames.some((exp
     let resolved = normalize(resolve('/', dirname(importer), source));
     return /(?:^|\/)entry\.client(?:\.[cm]?[jt]sx?)?$/.test(resolved);
 }, getExportDependencies = (code, cache, cacheKey)=>getOrSetFromCache(cache, `${cacheKey}::getExportDependencies`, code, ()=>{
-        let { module } = analyzeCode(code, cache, cacheKey), exportDependencies = new Map(), topLevelStatementCache = new Map(), variableDeclaratorCache = new Map(), getCachedTopLevelStatementForNode = (node)=>{
+        let { module } = analyzeCode(code, cache, cacheKey), namedExports = module.exports.filter((exp)=>null !== exp.name && !exp.typeOnly && !exp.isStar && !exp.isExportEquals), hasDecorators = !1;
+        external_yuku_parser_walk(module.ast, {
+            Decorator (_node, context) {
+                hasDecorators = !0, context.stop();
+            }
+        });
+        let exportDependencies = new Map(), topLevelStatementCache = new Map(), exportedVariableDeclaratorCache = new Map(), getCachedTopLevelStatementForNode = (node)=>{
             let cached = topLevelStatementCache.get(node);
             if (cached) return cached;
             let statement = ((module, node)=>{
@@ -431,17 +432,34 @@ let mightContainRouteChunkExportName = (source)=>routeChunkExportNames.some((exp
                 return invariant(parent?.type === 'Program', 'Expected node to be within Program'), current;
             })(module, node);
             return topLevelStatementCache.set(node, statement), statement;
-        }, getCachedVariableDeclaratorForNode = (node)=>{
-            if (variableDeclaratorCache.has(node)) return variableDeclaratorCache.get(node) ?? null;
+        }, nonShareableExportedSymbols = new Set();
+        for (let { local } of namedExports){
+            if (!local?.has(SymbolFlags.ValueSpace | SymbolFlags.ValueImport)) continue;
+            let isImport = local.declarations.every((declaration)=>'ImportDeclaration' === getCachedTopLevelStatementForNode(declaration).type), hasSetup = isImport && local.references.some((reference)=>{
+                let statement = getCachedTopLevelStatementForNode(reference.node);
+                return 'value' === reference.kind && 'ImportDeclaration' !== statement.type && !statement.type.startsWith('Export');
+            });
+            (!isImport || hasSetup) && nonShareableExportedSymbols.add(local);
+        }
+        let isRuntimeRelevantReference = (reference)=>hasDecorators || 'value' === reference.kind || ((reference)=>{
+                let node = reference.node, parent = module.parentOf(node);
+                for(; parent?.type === 'TSQualifiedName';)node = parent, parent = module.parentOf(node);
+                return parent?.type === 'TSImportEqualsDeclaration' && parent.moduleReference === node && 'type' !== parent.importKind;
+            })(reference), getCachedExportedVariableDeclaratorForNode = (node)=>{
+            if (exportedVariableDeclaratorCache.has(node)) return exportedVariableDeclaratorCache.get(node) ?? null;
             let declarator = ((module, node)=>{
                 let current = node;
-                for(; current;){
-                    if ('VariableDeclarator' === current.type) return current;
-                    current = module.parentOf(current);
+                for(;;){
+                    let parent = module.parentOf(current);
+                    if (!parent || 'Program' === parent.type) return null;
+                    if ('VariableDeclarator' === current.type && 'VariableDeclaration' === parent.type) {
+                        let exported = module.parentOf(parent);
+                        if (exported?.type === 'ExportNamedDeclaration' && module.parentOf(exported)?.type === 'Program') return current;
+                    }
+                    current = parent;
                 }
-                return null;
             })(module, node);
-            return variableDeclaratorCache.set(node, declarator), declarator;
+            return exportedVariableDeclaratorCache.set(node, declarator), declarator;
         }, addCachedTopLevelStatement = (dependencies, node)=>{
             let statement = getCachedTopLevelStatementForNode(node);
             return dependencies.topLevelStatements.add(statement), 'ImportDeclaration' === statement.type || statement.type.startsWith('Export') || dependencies.topLevelNonModuleStatements.add(statement), statement;
@@ -451,46 +469,47 @@ let mightContainRouteChunkExportName = (source)=>routeChunkExportNames.some((exp
                 topLevelNonModuleStatements: new Set(),
                 importedIdentifierNames: new Set(),
                 importSources: new Set(),
-                exportedVariableDeclarators: new Set()
-            }, visitedSymbols = new Set(), scannedNodes = new Set(), scanNode = (node)=>{
+                exportedVariableDeclarators: new Set(),
+                exportedLocalSymbols: new Set()
+            }, visitedSymbols = new Set(), scannedNodes = new Set(), visitIdentifier = (node)=>{
+                let reference = module.referenceOf(node);
+                if (reference) {
+                    reference.symbol && isRuntimeRelevantReference(reference) && visitSymbol(reference.symbol);
+                    return;
+                }
+                let symbol = module.symbolOf(node);
+                symbol?.scope === module.rootScope && symbol.has(SymbolFlags.ValueSpace | SymbolFlags.ValueImport) && dependencies.topLevelNonModuleStatements.has(getCachedTopLevelStatementForNode(node)) && visitSymbol(symbol);
+            }, scanNode = (node)=>{
                 scannedNodes.has(node) || (scannedNodes.add(node), external_yuku_parser_walk(node, {
-                    Identifier (node) {
-                        let reference = module.referenceOf(node);
-                        reference?.symbol && visitSymbol(reference.symbol);
-                    }
+                    Identifier: visitIdentifier,
+                    JSXIdentifier: visitIdentifier
                 }));
             }, visitSymbol = (symbol)=>{
                 if (!visitedSymbols.has(symbol) && (visitedSymbols.add(symbol), 0 !== symbol.declarations.length)) {
-                    for (let declaration of symbol.declarations){
+                    for (let declaration of (nonShareableExportedSymbols.has(symbol) && dependencies.exportedLocalSymbols.add(symbol), symbol.declarations)){
                         let statement = addCachedTopLevelStatement(dependencies, declaration);
-                        if ('ImportDeclaration' === statement.type) {
-                            dependencies.importedIdentifierNames.add(symbol.name), 'string' == typeof statement.source?.value && dependencies.importSources.add(statement.source.value);
-                            return;
-                        }
-                        let declarator = getCachedVariableDeclaratorForNode(declaration);
-                        declarator && isTopLevelExportedVariableDeclarator(module, declarator) && dependencies.exportedVariableDeclarators.add(declarator), scanNode(declarator ?? statement);
+                        if ('ImportDeclaration' === statement.type && (dependencies.importedIdentifierNames.add(symbol.name), 'string' == typeof statement.source?.value && dependencies.importSources.add(statement.source.value), symbol !== localSymbol)) return;
+                        let declarator = getCachedExportedVariableDeclaratorForNode(declaration);
+                        declarator && dependencies.exportedVariableDeclarators.add(declarator), scanNode(declarator ?? statement);
                     }
                     for (let reference of symbol.references){
+                        if (!isRuntimeRelevantReference(reference)) continue;
                         let statement = addCachedTopLevelStatement(dependencies, reference.node);
-                        scanNode(getCachedVariableDeclaratorForNode(reference.node) ?? statement);
+                        scanNode(getCachedExportedVariableDeclaratorForNode(reference.node) ?? statement);
                     }
                 }
             };
             addCachedTopLevelStatement(dependencies, exportNode), localSymbol ? visitSymbol(localSymbol) : scanNode(getCachedTopLevelStatementForNode(exportNode)), exportDependencies.set(exportName, dependencies);
         };
-        for (let exp of module.exports)exp.typeOnly || exp.isStar || exp.isExportEquals || handleExport(exp.name, exp.node, exp.local ?? null);
+        for (let exp of namedExports)handleExport(exp.name, exp.node, exp.local ?? null);
         return exportDependencies;
     }), isExportChunkable = (exportName, exportDependencies, importer)=>{
     let dependencies = exportDependencies.get(exportName);
-    if (!dependencies || 'clientLoader' === exportName && hasHydrateAssignment(dependencies) || 'clientLoader' === exportName && ((dependencies, importer)=>{
+    if (!dependencies || dependencies.exportedVariableDeclarators.size > 1 || 'clientLoader' === exportName && hasHydrateAssignment(dependencies) || 'clientLoader' === exportName && ((dependencies, importer)=>{
         for (let source of dependencies.importSources)if (isEntryClientImport(source, importer)) return !0;
         return !1;
     })(dependencies, importer)) return !1;
-    for (let [currentExportName, currentDependencies] of exportDependencies)if (currentExportName !== exportName && setsIntersect(currentDependencies.topLevelNonModuleStatements, dependencies.topLevelNonModuleStatements)) return !1;
-    if (dependencies.exportedVariableDeclarators.size > 1) return !1;
-    if (dependencies.exportedVariableDeclarators.size > 0) {
-        for (let [currentExportName, currentDependencies] of exportDependencies)if (currentExportName !== exportName && setsIntersect(currentDependencies.exportedVariableDeclarators, dependencies.exportedVariableDeclarators)) return !1;
-    }
+    for (let [currentExportName, currentDependencies] of exportDependencies)if (currentExportName !== exportName && (setsIntersect(currentDependencies.topLevelNonModuleStatements, dependencies.topLevelNonModuleStatements) || setsIntersect(currentDependencies.exportedVariableDeclarators, dependencies.exportedVariableDeclarators) || setsIntersect(currentDependencies.exportedLocalSymbols, dependencies.exportedLocalSymbols))) return !1;
     return !0;
 }, hasHydrateAssignment = (dependencies)=>Array.from(dependencies.topLevelNonModuleStatements).some((statement)=>{
         let expression = statement.expression, left = expression?.left;

package/dist/constants.d.ts

@@ -39,3 +39,4 @@ export declare const CLIENT_EXPORTS: {
     readonly shouldRevalidate: "shouldRevalidate";
 };
 export declare const SPA_FALLBACK_HTML_FILE = "__spa-fallback.html";
+export declare const BROWSER_MANIFEST_ENTRY_NAME = "virtual/react-router/browser-manifest";

package/dist/dev-hdr-channel.d.ts

@@ -0,0 +1,9 @@
+import type { RsbuildDevServer } from '@rsbuild/core';
+export declare const DEV_HDR_UPDATE_EVENT = "react-router:hdr-update";
+export declare const createDevHdrChannel: ({ hot, isEnabled, }: {
+    hot: RsbuildDevServer["environments"][string]["hot"];
+    isEnabled: () => boolean;
+}) => {
+    publish(): void;
+    close(): void;
+};

package/dist/dev-hmr.d.ts

@@ -4,7 +4,6 @@ export declare const DEV_MANIFEST_UPDATE_EVENT = "react-router:manifest-update";
 export type DevHmrPlanOptions = {
     isEnabled: () => boolean;
     runtimeModule: string;
-    onNodeRebuildCommitted: () => void;
 };
 export declare const isRspackSwcReactRefreshEnabled: (rspackConfig: Rspack.Configuration) => boolean;
 /**
@@ -16,25 +15,6 @@ export declare const isRspackSwcReactRefreshEnabled: (rspackConfig: Rspack.Confi
  * dev HMR falls back to full reloads.
  */
 export declare const resolveReactRefreshRuntimePath: (rootPath: string) => string | undefined;
-/**
- * The HDR revision module is a real file (not a virtual module) because it
- * must wake the web compiler through the regular file watcher: the browser
- * HMR runtime imports it, so bumping the revision produces a web hot update
- * whenever server code changes, which the client answers by revalidating
- * React Router loader data.
- */
-export declare const getDevHdrRevisionFilePath: (rootPath: string) => string;
-export type DevHdrRevisionSignal = {
-    filePath: string;
-    /** Writes the initial revision module so the first compile can resolve it. */
-    ensure: () => void;
-    /** Increments the revision, signaling hot data revalidation to the client. */
-    bump: () => void;
-};
-export declare const createDevHdrRevisionSignal: ({ filePath, onError, }: {
-    filePath: string;
-    onError?: (error: Error) => void;
-}) => DevHdrRevisionSignal;
 /**
  * Browser-side HMR runtime shared by all route client entries in development.
  *
@@ -45,7 +25,6 @@ export declare const createDevHdrRevisionSignal: ({ filePath, onError, }: {
  * recreating the client routes with revalidation opt-out, revalidating loader
  * data, and finally performing a React refresh.
  */
-export declare const generateDevHmrRuntimeModule: ({ reactRefreshRuntimePath, hdrRevisionFilePath, }: {
+export declare const generateDevHmrRuntimeModule: ({ reactRefreshRuntimePath, }: {
     reactRefreshRuntimePath: string;
-    hdrRevisionFilePath: string;
 }) => string;

package/dist/dev-runtime-controller.d.ts

@@ -14,11 +14,6 @@ type CreateControllerOptions = {
      * flags) in place, so metadata-only changes no longer need a full reload.
      */
     clientPatchesRouteMetadata?: boolean | (() => boolean);
-    /**
-     * Invoked after a development attempt commits a re-evaluated node build for
-     * changed server files. Used to signal hot data revalidation to the client.
-     */
-    onNodeRebuildCommitted?: () => void;
 };
-export declare const createReactRouterDevRuntimeController: ({ api, isBuild, buildPlan, clientPatchesRouteMetadata, onNodeRebuildCommitted, }: CreateControllerOptions) => ReactRouterDevRuntimeController;
+export declare const createReactRouterDevRuntimeController: ({ api, isBuild, buildPlan, clientPatchesRouteMetadata, }: CreateControllerOptions) => ReactRouterDevRuntimeController;
 export {};

package/dist/dev-server.d.ts

@@ -6,12 +6,14 @@ export type DevServerMiddleware = (req: IncomingMessage, res: ServerResponse, ne
 type RequestHandler = (request: Request) => Response | Promise<Response>;
 type BuildProvider = () => Promise<ServerBuild>;
 export type DevServerMiddlewareDependencies = {
+    rootPath: string;
     loadBuild: BuildProvider;
     createRequestHandler?: (build: BuildProvider, mode: 'development') => RequestHandler;
     createRequestListener?: (handler: RequestHandler) => (req: IncomingMessage, res: ServerResponse) => void | Promise<void>;
 };
 export declare const createDevServerMiddleware: (dependencies: DevServerMiddlewareDependencies) => DevServerMiddleware;
-export declare const createReactRouterDevServerSetup: ({ loadBuild, }: {
+export declare const createReactRouterDevServerSetup: ({ loadBuild, rootPath, }: {
     loadBuild: BuildProvider;
+    rootPath: string;
 }) => ServerSetup;
 export {};