rsbuild-plugin-react-router 0.3.1 → 0.4.1

package/dist/index.cjs

@@ -11056,7 +11056,7 @@ const external_react_router_namespaceObject = require("react-router"), normalize
     }))([
         'Warning: Paths with dynamic/splat params cannot be prerendered when using `prerender: true`.',
         'You may want to use the `prerender()` API to prerender the following paths:',
-        ...paramRoutes.map((path)=>`  - ${path}`)
+        ...paramRoutes.map((path)=>`  - ${path.replace(/^\/(?=[:*])/, '')}`)
     ].join('\n')), paths;
     if ('function' == typeof pathsConfig) {
         let resolved = await pathsConfig({
@@ -11636,11 +11636,11 @@ const redirectStatusCodes = new Set([
             }))), (controller)=>sync(()=>{
             controller.abort();
         })), withBuildRequest = (input, init, handle)=>runPluginEffect(createBuildRequestEffect(input, init, handle)), prerenderData = async ({ handler, prerenderPath, onlyRoutes, clientBuildDir, basename, trailingSlashAwareDataRequests, api, requestInit })=>{
-    let dataRequestPath = createDataRequestPath(prerenderPath, trailingSlashAwareDataRequests), normalizedPath = `${basename}${dataRequestPath}`.replace(/\/\/+/g, '/'), url = new URL(`http://localhost${normalizedPath}`);
+    let dataOutputPath = createDataRequestPath(prerenderPath, trailingSlashAwareDataRequests), dataRequestPath = trailingSlashAwareDataRequests && '/' === prerenderPath ? '/_root.data' : dataOutputPath, normalizedPath = `${basename}${dataRequestPath}`.replace(/\/\/+/g, '/'), outputNormalizedPath = dataOutputPath === dataRequestPath ? normalizedPath : `${basename}${dataOutputPath}`.replace(/\/\/+/g, '/'), url = new URL(`http://localhost${normalizedPath}`);
     return onlyRoutes?.length && url.searchParams.set('_routes', onlyRoutes.join(',')), withBuildRequest(url, requestInit, async (request)=>{
         let response = await handler(request), data = await response.text();
         if (200 !== response.status && 202 !== response.status) throw Error(`Prerender (data): Received a ${response.status} status code from \`entry.server.tsx\` while prerendering the \`${prerenderPath}\` path.\n${normalizedPath}`);
-        let outputPath = (0, external_pathe_namespaceObject.resolve)(clientBuildDir, ...normalizedPath.split('/'));
+        let outputPath = (0, external_pathe_namespaceObject.resolve)(clientBuildDir, ...outputNormalizedPath.split('/'));
         return await (0, promises_namespaceObject.mkdir)((0, external_pathe_namespaceObject.dirname)(outputPath), {
             recursive: !0
         }), await (0, promises_namespaceObject.writeFile)(outputPath, data), api.logger.info(`Prerender (data): ${prerenderPath} -> ${(0, external_pathe_namespaceObject.relative)(process.cwd(), outputPath)}`), data;
@@ -11751,13 +11751,16 @@ const redirectStatusCodes = new Set([
                 clientBuildDir,
                 basename,
                 api,
-                requestInit: data ? {
-                    headers: {
-                        'X-React-Router-Prerender-Data': encodeURI(data)
-                    }
-                } : void 0
+                requestInit: data ? createPrerenderDataRequestInit(data) : void 0
             }));
-    }), runPrerenderPaths = async ({ build, requestHandler, clientBuildDir, options })=>{
+    }), createPrerenderDataRequestInit = (data)=>{
+    let encodedData = encodeURI(data);
+    return encodedData.length < 8192 ? {
+        headers: {
+            'X-React-Router-Prerender-Data': encodedData
+        }
+    } : void 0;
+}, runPrerenderPaths = async ({ build, requestHandler, clientBuildDir, options })=>{
     let { prerenderConfig, prerenderPaths } = options, buildRoutes = createPrerenderRoutes(build.routes), concurrency = getPrerenderConcurrency(prerenderConfig);
     await runPluginEffect(createBoundedPrerenderTasksEffect(prerenderPaths, concurrency, (path)=>createPrerenderPathEffect({
             path,
@@ -12113,7 +12116,7 @@ function warnOnClientSourceMaps(normalized, warn, clientEnvName = 'web') {
     let sourceMapSetting = getClientSourceMapSetting(normalized, clientEnvName), devtoolSetting = getClientDevtoolSetting(normalized, clientEnvName);
     (isSourceMapEnabled(sourceMapSetting) || isDevtoolSourceMap(devtoolSetting)) && warn("\n  WARNING: Source maps are enabled in production\n  This makes your server code publicly visible in the browser.\n  This is highly discouraged! If you insist, ensure that you are using\n  environment variables for secrets and not hard-coding them in your source code.\n");
 }
-const registerBuildOutputTransforms = ({ api, resolvedServerOutput, performanceProfiler, getLatestServerManifest, getLatestServerManifestByBundleId, routes, pluginOptions, getClientStats, appDirectory, getAssetPrefix, routeChunkOptions, routeTransformExecutor, routeByFilePath, routeChunkConfig, isBuild, splitRouteModules, ssr, isSpaMode, rootRoutePath })=>{
+const registerBuildOutputTransforms = ({ api, resolvedServerOutput, performanceProfiler, getLatestServerManifest, getLatestServerManifestByBundleId, routes, pluginOptions, getClientStats, appDirectory, getAssetPrefix, routeChunkOptions, routeTransformExecutor, routeByFilePath, routeChunkConfig, isBuild, splitRouteModules, ssr, isSpaMode, rootRoutePath, isDevHmrEnabled = ()=>!1 })=>{
     let transformRouteModule = async (args)=>performanceProfiler.record(args.environment?.name, 'route:module', args.resource, async ()=>routeTransformExecutor.run({
                 kind: 'routeModule',
                 code: args.code,
@@ -12124,7 +12127,8 @@ const registerBuildOutputTransforms = ({ api, resolvedServerOutput, performanceP
                 ssr,
                 isBuild,
                 isSpaMode,
-                rootRoutePath
+                rootRoutePath,
+                devHmr: isDevHmrEnabled()
             }));
     api.processAssets({
         stage: 'additional',
@@ -12154,7 +12158,9 @@ const registerBuildOutputTransforms = ({ api, resolvedServerOutput, performanceP
                 resourcePath: args.resourcePath,
                 environmentName: args.environment?.name,
                 isBuild,
-                routeChunkConfig
+                routeChunkConfig,
+                routeId: routeByFilePath.get(args.resourcePath)?.id,
+                devHmr: isDevHmrEnabled()
             }))), api.transform({
         resourceQuery: /route-chunk=/,
         environments: [
@@ -12240,17 +12246,70 @@ const registerBuildOutputTransforms = ({ api, resolvedServerOutput, performanceP
         code: generated.code,
         map
     };
-}, buildRouteClientEntryCode = ({ exportNames, chunkedExports, isServer, resourcePath })=>{
-    let chunkedExportSet = chunkedExports.length > 0 ? new Set(chunkedExports) : void 0, reexports = exportNames.filter((exp)=>!chunkedExportSet?.has(exp) && (CLIENT_ROUTE_EXPORTS_SET.has(exp) || isServer && SERVER_ONLY_ROUTE_EXPORTS_SET.has(exp))).sort(), target = `${resourcePath}?react-router-route`;
-    return `export { ${reexports.join(', ')} } from ${JSON.stringify(target)};`;
-}, createRouteClientEntryArtifact = async ({ code, resourcePath, environmentName, isBuild, routeChunkCache, routeChunkConfig })=>{
+}, HMR_PATCHABLE_ROUTE_FLAGS = [
+    'hasAction',
+    'hasClientAction',
+    'hasClientLoader',
+    'hasClientMiddleware',
+    'hasErrorBoundary',
+    'hasLoader'
+], HMR_FLAG_EXPORT_NAME = {
+    hasAction: SERVER_EXPORTS.action,
+    hasClientAction: CLIENT_EXPORTS.clientAction,
+    hasClientLoader: CLIENT_EXPORTS.clientLoader,
+    hasClientMiddleware: CLIENT_EXPORTS.clientMiddleware,
+    hasErrorBoundary: CLIENT_EXPORTS.ErrorBoundary,
+    hasLoader: SERVER_EXPORTS.loader
+}, buildRouteHmrFlags = (exportNames)=>{
+    let exports1 = new Set(exportNames), flags = 0;
+    return HMR_PATCHABLE_ROUTE_FLAGS.forEach((flag, index)=>{
+        exports1.has(HMR_FLAG_EXPORT_NAME[flag]) && (flags |= 1 << index);
+    }), flags;
+}, buildRouteClientEntryHmrCode = ({ routeId, target, acceptTarget, flags })=>{
+    let targetJson = JSON.stringify(target), acceptTargetJson = JSON.stringify(acceptTarget);
+    return `
+import * as __rrm from ${targetJson};
+import {
+  registerReactRouterRouteExports as __rrr,
+  scheduleReactRouterRouteUpdate as __rru,
+} 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);
+};
+
+__rrr(__rrid, __rrm);
+
+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();
+}
+`;
+}, createRouteHmrAcceptTarget = (resourcePath)=>`./${(0, external_pathe_namespaceObject.basename)(resourcePath)}?react-router-route`, buildRouteClientEntryCode = ({ exportNames, chunkedExports, isServer, resourcePath, routeId, devHmr })=>{
+    let chunkedExportSet = chunkedExports.length > 0 ? new Set(chunkedExports) : void 0, reexports = exportNames.filter((exp)=>!chunkedExportSet?.has(exp) && (CLIENT_ROUTE_EXPORTS_SET.has(exp) || isServer && SERVER_ONLY_ROUTE_EXPORTS_SET.has(exp))).sort(), target = `${resourcePath}?react-router-route`, reexportCode = `export { ${reexports.join(', ')} } from ${JSON.stringify(target)};`;
+    return !devHmr || isServer || void 0 === routeId ? reexportCode : reexportCode + buildRouteClientEntryHmrCode({
+        routeId,
+        target,
+        acceptTarget: createRouteHmrAcceptTarget(resourcePath),
+        flags: buildRouteHmrFlags(exportNames)
+    });
+}, createRouteClientEntryArtifact = async ({ code, resourcePath, environmentName, isBuild, routeChunkCache, routeChunkConfig, routeId, devHmr })=>{
     let isServer = 'node' === environmentName, routeChunkInfo = !isServer && isBuild && shouldAnalyzeRouteChunks(routeChunkConfig, resourcePath, code) ? await detectRouteChunksIfEnabled(routeChunkCache, routeChunkConfig, resourcePath, code) : null;
     return {
         code: buildRouteClientEntryCode({
             exportNames: routeChunkInfo?.exportNames ?? await getExportNames(code, resourcePath),
             chunkedExports: routeChunkInfo?.chunkedExports ?? [],
             isServer,
-            resourcePath
+            resourcePath,
+            routeId,
+            devHmr: devHmr && !isBuild
         })
     };
 }, createRouteChunkArtifact = async ({ code, resource, resourcePath, isBuild, routeChunkCache, routeChunkConfig })=>{
@@ -12295,7 +12354,71 @@ const registerBuildOutputTransforms = ({ api, resolvedServerOutput, performanceP
 }, createClientOnlyStub = async (task)=>({
         code: Array.from(await collectClientOnlyStubExportNames(task.code, task.resourcePath, task.resolveExportAllModule)).map((name)=>'default' === name ? 'export default undefined;' : `export const ${name} = undefined;`).join('\n'),
         map: null
-    }), route_transform_tasks_transformRouteModule = async (task)=>{
+    }), isComponentishName = (name)=>/^[A-Z]/.test(name), argumentResolvesToComponent = (node)=>{
+    switch(node?.type){
+        case 'FunctionExpression':
+            return !0;
+        case 'ArrowFunctionExpression':
+            return node.body?.type !== 'ArrowFunctionExpression';
+        case 'Identifier':
+            let name;
+            return !!node.name && (name = node.name, /^[A-Z]/.test(name));
+        case 'CallExpression':
+            return callResolvesToComponent(node);
+        default:
+            return !1;
+    }
+}, callResolvesToComponent = (node)=>{
+    let args = node.arguments ?? [];
+    if (0 === args.length) return !1;
+    let callee = node.callee;
+    if (!callee || 'Import' === callee.type) return !1;
+    if ('Identifier' === callee.type) {
+        let calleeName = callee.name ?? '';
+        if (calleeName.startsWith('require') || calleeName.startsWith('import')) return !1;
+    } else if ('MemberExpression' !== callee.type) return !1;
+    return argumentResolvesToComponent(args[0]);
+}, initResolvesToComponent = (init)=>{
+    switch(init.type){
+        case 'FunctionExpression':
+        case 'TaggedTemplateExpression':
+            return !0;
+        case 'ArrowFunctionExpression':
+            return init.body?.type !== 'ArrowFunctionExpression';
+        case 'CallExpression':
+            return callResolvesToComponent(init);
+        default:
+            return !1;
+    }
+}, collectDeclaredComponentNames = (declaration, names)=>{
+    let name, name1;
+    if ('FunctionDeclaration' === declaration.type && declaration.id?.name && (name = declaration.id.name, /^[A-Z]/.test(name))) return void names.add(declaration.id.name);
+    if ('VariableDeclaration' !== declaration.type) return;
+    let declarators = declaration.declarations ?? [];
+    if (1 !== declarators.length) return;
+    let [declarator] = declarators;
+    declarator?.id?.type === 'Identifier' && declarator.id.name && (name1 = declarator.id.name, /^[A-Z]/.test(name1)) && declarator.init && initResolvesToComponent(declarator.init) && names.add(declarator.id.name);
+}, collectUnregisteredComponentNames = (program)=>{
+    let declared = new Set(), registered = new Set();
+    for (let statement of program.body ?? []){
+        if ('ExportNamedDeclaration' === statement.type && statement.declaration) {
+            collectDeclaredComponentNames(statement.declaration, declared);
+            continue;
+        }
+        if ('ExpressionStatement' === statement.type && statement.expression?.type === 'CallExpression' && statement.expression.callee?.type === 'Identifier' && '$RefreshReg$' === statement.expression.callee.name) {
+            let nameArgument = statement.expression.arguments?.[1];
+            'string' == typeof nameArgument?.value && registered.add(nameArgument.value);
+            continue;
+        }
+        collectDeclaredComponentNames(statement, declared);
+    }
+    return [
+        ...declared
+    ].filter((name)=>!registered.has(name));
+}, buildComponentRefreshRegistrations = (names)=>{
+    let registrations = names.map((name)=>`  if (typeof ${name} === 'function' || (typeof ${name} === 'object' && ${name} !== null)) $RefreshReg$(${name}, ${JSON.stringify(name)});`).join('\n');
+    return `\nif (typeof $RefreshReg$ === 'function') {\n${registrations}\n}\n`;
+}, route_transform_tasks_transformRouteModule = async (task)=>{
     let code = task.code, defaultExportMatch = code.match(/\n\s{0,}([\w\d_]+)\sas default,?/);
     defaultExportMatch && 'number' == typeof defaultExportMatch.index && (code = code.slice(0, defaultExportMatch.index) + code.slice(defaultExportMatch.index + defaultExportMatch[0].length) + `\nexport default ${defaultExportMatch[1]};`);
     let ast = yuku_parse(code, {
@@ -12310,11 +12433,17 @@ const registerBuildOutputTransforms = ({ api, resolvedServerOutput, performanceP
         if (!isRootRoute && resolvedExportNames.includes('HydrateFallback')) throw Error(`SPA Mode: Invalid \`HydrateFallback\` export found in \`${relativePath}\`. \`HydrateFallback\` is only permitted on the root route in SPA Mode. See https://reactrouter.com/how-to/spa for more information.`);
     }
     let removedServerOnlyExports = 'web' === task.environmentName && removeExports(ast, SERVER_ONLY_ROUTE_EXPORTS, SERVER_ONLY_ROUTE_EXPORTS_SET);
-    return transformRoute(ast), removedServerOnlyExports && removeUnusedImports(ast), yuku_generate(ast, {
+    transformRoute(ast), removedServerOnlyExports && removeUnusedImports(ast);
+    let result = yuku_generate(ast, {
         sourceMaps: task.sourceMaps,
         filename: task.resource,
         sourceFileName: task.resourcePath
     });
+    if (task.devHmr && 'web' === task.environmentName && !task.isBuild) {
+        let unregisteredComponents = collectUnregisteredComponentNames(ast.program ?? ast);
+        unregisteredComponents.length > 0 && (result.code += buildComponentRefreshRegistrations(unregisteredComponents));
+    }
+    return result;
 }, executeRouteTransformTask = async (task, options)=>{
     switch(task.kind){
         case 'routeClientEntry':
@@ -12324,7 +12453,9 @@ const registerBuildOutputTransforms = ({ api, resolvedServerOutput, performanceP
                 environmentName: task.environmentName,
                 isBuild: task.isBuild,
                 routeChunkCache: getRouteChunkCache(options),
-                routeChunkConfig: task.routeChunkConfig
+                routeChunkConfig: task.routeChunkConfig,
+                routeId: task.routeId,
+                devHmr: task.devHmr
             });
         case 'routeChunk':
             return createRouteChunkArtifact({
@@ -13280,7 +13411,306 @@ const MAX_SLOWEST_ENTRIES = 5, insertSlowestEntry = (slowest, entry)=>{
 }, loadReactRouterServerBuild = (server, entryName)=>{
     let runtime1 = Reflect.get(server, DEV_RUNTIME_KEY);
     return runtime1 ? runtime1.load(entryName) : Promise.reject(Error('[rsbuild-plugin-react-router] This Rsbuild development server is not registered with the React Router plugin. Add pluginReactRouter() before calling loadReactRouterServerBuild().'));
-}, createDevRuntimeSessionManager = (closeBinding)=>{
+}, DEV_HMR_RUNTIME_MODULE_ID = 'virtual/react-router/hmr-runtime', dev_hmr_isObject = (value)=>null !== value && 'object' == typeof value, isSwcLoader = (loader)=>'string' == typeof loader && loader.includes('builtin:swc-loader'), hasReactRefresh = (options)=>options?.jsc?.transform?.react?.refresh === !0, readSwcLoaderRefresh = (value)=>Array.isArray(value) ? value.some(readSwcLoaderRefresh) : !!dev_hmr_isObject(value) && (isSwcLoader(value.loader) ? hasReactRefresh(value.options) : Object.values(value).some(readSwcLoaderRefresh)), readRuleSwcRefresh = (rule)=>!!dev_hmr_isObject(rule) && (isSwcLoader(rule.loader) ? hasReactRefresh(rule.options) : readSwcLoaderRefresh(rule.use) || readRuleSetSwcRefresh(rule.oneOf) || readRuleSetSwcRefresh(rule.rules)), readRuleSetSwcRefresh = (rules)=>Array.isArray(rules) && rules.some(readRuleSwcRefresh), isRspackSwcReactRefreshEnabled = (rspackConfig)=>readRuleSetSwcRefresh(rspackConfig.module?.rules), resolveReactRefreshRuntimePath = (rootPath)=>{
+    let resolveFrom = (base, request)=>(0, external_node_module_namespaceObject.createRequire)(base).resolve(request), rootPackageJson = (0, external_pathe_namespaceObject.join)(rootPath, 'package.json');
+    try {
+        let pluginReactEntry = resolveFrom(rootPackageJson, '@rsbuild/plugin-react'), refreshPluginEntry = resolveFrom(pluginReactEntry, '@rspack/plugin-react-refresh');
+        return resolveFrom(refreshPluginEntry, 'react-refresh/runtime');
+    } catch  {
+        return;
+    }
+}, hdrRevisionModuleContent = (revision)=>`export default ${revision};\n`, DEV_HDR_REVISION_RELATIVE_PATH = '.react-router/hdr-revision.mjs', getDevHdrRevisionFilePath = (rootPath)=>(0, external_pathe_namespaceObject.join)(rootPath, DEV_HDR_REVISION_RELATIVE_PATH), createDevHdrRevisionSignal = ({ filePath, onError })=>{
+    let revision = 0, dirEnsured = !1, write = ()=>{
+        try {
+            dirEnsured || ((0, external_node_fs_namespaceObject.mkdirSync)((0, external_pathe_namespaceObject.dirname)(filePath), {
+                recursive: !0
+            }), dirEnsured = !0), (0, external_node_fs_namespaceObject.writeFileSync)(filePath, hdrRevisionModuleContent(revision));
+        } catch (error) {
+            onError?.(error instanceof Error ? error : Error(String(error)));
+        }
+    };
+    return {
+        ensure: write,
+        bump () {
+            revision += 1, write();
+        }
+    };
+}, generateDevHmrRuntimeModule = ({ reactRefreshRuntimePath, hdrRevisionFilePath })=>`
+import * as __refreshRuntimeModule from ${JSON.stringify(reactRefreshRuntimePath)};
+// Read revision so the import survives sideEffects: false tree-shaking.
+import __hdrRevision from ${JSON.stringify(hdrRevisionFilePath)};
+
+void __hdrRevision;
+
+const RefreshRuntime =
+  __refreshRuntimeModule && __refreshRuntimeModule.performReactRefresh
+    ? __refreshRuntimeModule
+    : __refreshRuntimeModule.default;
+
+const pendingRouteUpdates = new Map();
+let flushTimeout;
+let pendingRevalidation = false;
+
+function getCurrentRouterPath(router) {
+  const basename = router.basename || '/';
+  let pathname = window.location.pathname;
+  if (basename !== '/' && pathname.startsWith(basename)) {
+    pathname = pathname.slice(basename.length) || '/';
+    // A trailing-slash basename (e.g. "/mybase/") consumes the leading slash,
+    // leaving a relative path that react-router resolves against the current
+    // location and doubles. Force it back to absolute.
+    if (pathname[0] !== '/') pathname = '/' + pathname;
+  }
+  return pathname + window.location.search + window.location.hash;
+}
+
+export function registerReactRouterRouteExports(routeId, moduleExports) {
+  if (
+    typeof window === 'undefined' ||
+    !RefreshRuntime ||
+    typeof RefreshRuntime.register !== 'function'
+  ) {
+    return;
+  }
+  for (const key in moduleExports) {
+    if (key === '__esModule') continue;
+    const exportValue = moduleExports[key];
+    if (RefreshRuntime.isLikelyComponentType(exportValue)) {
+      RefreshRuntime.register(exportValue, routeId + ' export ' + key);
+    }
+  }
+}
+
+export function scheduleReactRouterRouteUpdate(
+  routeId,
+  routeFlags,
+  getRouteModuleExports
+) {
+  pendingRouteUpdates.set(routeId, { routeFlags, getRouteModuleExports });
+  scheduleFlush();
+}
+
+export function scheduleReactRouterRevalidation() {
+  pendingRevalidation = true;
+  scheduleFlush();
+}
+
+function scheduleFlush() {
+  if (typeof window === 'undefined') {
+    return;
+  }
+  clearTimeout(flushTimeout);
+  flushTimeout = setTimeout(flush, 16);
+}
+
+function takePendingRouteUpdates() {
+  const updates = Array.from(pendingRouteUpdates, ([routeId, update]) => ({
+    routeId,
+    update,
+  }));
+  pendingRouteUpdates.clear();
+  return updates;
+}
+
+function getRouteMetadata(routeFlags) {
+  return {
+${HMR_PATCHABLE_ROUTE_FLAGS.map((flag, index)=>`    ${flag}: Boolean(routeFlags & ${1 << index}),`).join('\n')}
+  };
+}
+
+function applyRouteModuleUpdate(routeId, update, routeEntry, routeModules) {
+  Object.assign(routeEntry, getRouteMetadata(update.routeFlags));
+  const imported = update.getRouteModuleExports();
+  registerReactRouterRouteExports(routeId, imported);
+  const current = routeModules[routeId];
+  const preserveIdentity = key =>
+    imported[key] ? (current && current[key]) || imported[key] : imported[key];
+  routeModules[routeId] = {
+    ...imported,
+    default: preserveIdentity('default'),
+    ErrorBoundary: preserveIdentity('ErrorBoundary'),
+    HydrateFallback: preserveIdentity('HydrateFallback'),
+  };
+}
+
+function getRouteById(routes, routeId) {
+  for (const route of routes) {
+    if (route.id === routeId) {
+      return route;
+    }
+    if (route.children) {
+      const child = getRouteById(route.children, routeId);
+      if (child) {
+        return child;
+      }
+    }
+  }
+}
+
+// Deliberate coupling to React Router's private dev API: patching the live
+// match objects is the only way to swap route implementations without a
+// navigation. The typeof guard below degrades to a no-op if RR removes it.
+function patchCurrentRouteMatches(router, routes) {
+  if (
+    !router.state ||
+    !Array.isArray(router.state.matches) ||
+    typeof router._internalSetStateDoNotUseOrYouWillBreakYourApp !== 'function'
+  ) {
+    return;
+  }
+
+  let changed = false;
+  const matches = router.state.matches.map(match => {
+    const route = getRouteById(routes, match.route.id);
+    if (!route || route === match.route) {
+      return match;
+    }
+    changed = true;
+    return { ...match, route };
+  });
+
+  if (changed) {
+    router._internalSetStateDoNotUseOrYouWillBreakYourApp({ matches });
+  }
+}
+
+function applyPendingRouteUpdates(router, routeModules, manifest, context) {
+  if (pendingRouteUpdates.size === 0) {
+    return {
+      nextManifest: undefined,
+      shouldRefreshRouteState: false,
+      routesToRevalidate: new Set(),
+    };
+  }
+
+  // Clone only entries mutated before the manifest is committed in flush().
+  const nextManifest = { ...manifest, routes: { ...manifest.routes } };
+  const routesToRevalidate = new Set();
+  let shouldRefreshRouteState = false;
+  for (const { routeId, update } of takePendingRouteUpdates()) {
+    const existingEntry = nextManifest.routes[routeId];
+    if (!existingEntry) continue;
+
+    // Shallow clone is enough: only top-level flags are mutated below.
+    const routeEntry = { ...existingEntry };
+    nextManifest.routes[routeId] = routeEntry;
+    applyRouteModuleUpdate(routeId, update, routeEntry, routeModules);
+    if (
+      routeEntry.hasLoader ||
+      routeEntry.hasClientLoader ||
+      routeEntry.hasClientMiddleware
+    ) {
+      routesToRevalidate.add(routeId);
+    }
+    if (
+      existingEntry.hasLoader ||
+      existingEntry.hasClientLoader ||
+      existingEntry.hasClientMiddleware ||
+      routeEntry.hasLoader ||
+      routeEntry.hasClientLoader ||
+      routeEntry.hasClientMiddleware
+    ) {
+      shouldRefreshRouteState = true;
+    }
+  }
+
+  if (
+    typeof router.createRoutesForHMR === 'function' &&
+    typeof router._internalSetRoutes === 'function'
+  ) {
+    const routes = router.createRoutesForHMR(
+      routesToRevalidate,
+      nextManifest.routes,
+      routeModules,
+      context.ssr,
+      context.isSpaMode
+    );
+    router._internalSetRoutes(routes);
+    patchCurrentRouteMatches(router, routes);
+  }
+
+  return { nextManifest, shouldRefreshRouteState, routesToRevalidate };
+}
+
+async function withHdrActive(fn) {
+  try {
+    window.__reactRouterHdrActive = true;
+    await fn();
+  } finally {
+    window.__reactRouterHdrActive = false;
+  }
+}
+
+async function revalidateRouter(router) {
+  if (typeof router.revalidate === 'function') {
+    await withHdrActive(() => router.revalidate());
+    return;
+  }
+  if (typeof router.navigate === 'function') {
+    await withHdrActive(() =>
+      router.navigate(getCurrentRouterPath(router), {
+        replace: true,
+        preventScrollReset: true,
+      })
+    );
+  }
+}
+
+async function refreshRouteState(router) {
+  if (typeof router.revalidate === 'function') {
+    await withHdrActive(() => router.revalidate());
+    return true;
+  }
+  return false;
+}
+
+function performReactRefresh() {
+  if (
+    RefreshRuntime &&
+    typeof RefreshRuntime.performReactRefresh === 'function'
+  ) {
+    RefreshRuntime.performReactRefresh();
+  }
+}
+
+async function flush() {
+  const router = window.__reactRouterDataRouter;
+  const routeModules = window.__reactRouterRouteModules;
+  const manifest = window.__reactRouterManifest;
+  const context = window.__reactRouterContext;
+  if (!router || !routeModules || !manifest || !context) {
+    return;
+  }
+
+  let shouldRevalidate = pendingRevalidation;
+  pendingRevalidation = false;
+  const { nextManifest, shouldRefreshRouteState, routesToRevalidate } =
+    applyPendingRouteUpdates(router, routeModules, manifest, context);
+  if (nextManifest) {
+    Object.assign(manifest, nextManifest);
+  }
+  // Component-only updates do not need a full loader revalidation.
+  if (
+    shouldRefreshRouteState &&
+    (routesToRevalidate.size > 0 || shouldRevalidate)
+  ) {
+    if (await refreshRouteState(router)) {
+      shouldRevalidate = false;
+    }
+  }
+  if (shouldRevalidate) {
+    await revalidateRouter(router);
+  }
+  performReactRefresh();
+}
+
+if (typeof window !== 'undefined' && import.meta.webpackHot) {
+  import.meta.webpackHot.accept(
+    ${JSON.stringify(hdrRevisionFilePath)},
+    scheduleReactRouterRevalidation
+  );
+}
+`, createDevRuntimeSessionManager = (closeBinding)=>{
     let state = {
         status: 'idle'
     }, nextSessionId = 1, closeObservationByServer = new WeakMap(), isCurrentBinding = (binding)=>('active' === state.status || 'closing' === state.status) && state.binding === binding, applyCloseOutcome = (observation, outcome)=>{
@@ -13352,7 +13782,10 @@ const MAX_SLOWEST_ENTRIES = 5, insertSlowestEntry = (slowest, entry)=>{
             });
         }
     };
-}, escapeHtml = (value)=>value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;'), CSS_SOURCE_RELOAD_DELAY_MS = 1000, createReactRouterDevRuntimeController = ({ api, isBuild, buildPlan })=>{
+}, escapeHtml = (value)=>value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;'), CSS_SOURCE_RELOAD_DELAY_MS = 1000, isHdrRevisionFile = (file)=>file.includes(DEV_HDR_REVISION_RELATIVE_PATH), isCssSourceFile = (file)=>/\.css(?:\.[cm]?[jt]s)?$/.test(file), hasHdrTriggeringChange = (files)=>{
+    for (let file of files)if (!isHdrRevisionFile(file) && !isCssSourceFile(file)) return !0;
+    return !1;
+}, createReactRouterDevRuntimeController = ({ api, isBuild, buildPlan, onNodeRebuildCommitted })=>{
     let scheduledCssAssetOwnershipReload;
     if (isBuild) return {
         captureWeb () {},
@@ -13373,8 +13806,11 @@ const MAX_SLOWEST_ENTRIES = 5, insertSlowestEntry = (slowest, entry)=>{
         scheduledCssAssetOwnershipReload && (clearTimeout(scheduledCssAssetOwnershipReload), scheduledCssAssetOwnershipReload = void 0), reloadAfterCssAssetOwnershipRemoval = !1;
         let pair = binding.compilers;
         pair && resetDevCompilerPair(pair), binding.compilers = void 0, binding.runtime.close(error), unregisterReactRouterDevRuntime(binding.server, binding.runtime);
-    }, sessions = createDevRuntimeSessionManager(closeBinding), compilationIdentities = createCompilationIdentityTracker(), { getCompilationIdentity } = compilationIdentities, finishRuntimeAttempt = (binding, pair, stats, changes, identity1)=>runPluginEffect(tryPluginPromise(()=>binding.runtime.finishAttempt(stats, changes, identity1)).pipe(core_flatMap((result)=>tryPluginSync(()=>{
-                'retry-node' === result && sessions.getActiveBinding()?.id === binding.id && pair.node.watching?.invalidate();
+    }, sessions = createDevRuntimeSessionManager(closeBinding), compilationIdentities = createCompilationIdentityTracker(), { getCompilationIdentity } = compilationIdentities, hdrSignaledNodeIdentity = new WeakMap(), finishRuntimeAttempt = (binding, pair, stats, changes, identity1)=>runPluginEffect(tryPluginPromise(()=>binding.runtime.finishAttempt(stats, changes, identity1)).pipe(core_flatMap((result)=>tryPluginSync(()=>{
+                if (sessions.getActiveBinding()?.id === binding.id) {
+                    if ('retry-node' === result) return void pair.node.watching?.invalidate();
+                    'committed' === result && changes.node.known && void 0 !== identity1.node && hdrSignaledNodeIdentity.get(pair) !== identity1.node && hasHdrTriggeringChange(changes.node.files) && (hdrSignaledNodeIdentity.set(pair, identity1.node), onNodeRebuildCommitted?.());
+                }
             })), catchAll((cause)=>tryPluginSync(()=>{
                 sessions.getActiveBinding()?.id === binding.id && binding.runtime.failAttempt(normalizeEffectError(cause));
             })))), flushSettledAttempt = (binding, pair)=>{
@@ -13974,10 +14410,14 @@ const MAX_SLOWEST_ENTRIES = 5, insertSlowestEntry = (slowest, entry)=>{
                 routesByServerBundleId,
                 serverBuildFile,
                 defaultEntryName: devServerBuildEntryName
-            }), { serverBundleEntries } = serverBuildPlan, devRuntime = createReactRouterDevRuntimeController({
+            }), { serverBundleEntries } = serverBuildPlan, devHmrRefreshRuntimePath = isBuild ? void 0 : resolveReactRefreshRuntimePath(api.context.rootPath), devHdrSignal = devHmrRefreshRuntimePath ? createDevHdrRevisionSignal({
+                filePath: getDevHdrRevisionFilePath(api.context.rootPath),
+                onError: (error)=>api.logger.debug(`[${PLUGIN_NAME}] Failed to signal hot data revalidation: ${error.message}`)
+            }) : void 0, devHmrEnabled = !1, devRuntime = createReactRouterDevRuntimeController({
                 api,
                 isBuild,
-                buildPlan: serverBuildPlan
+                buildPlan: serverBuildPlan,
+                onNodeRebuildCommitted: ()=>devHdrSignal?.bump()
             });
             api.onAfterEnvironmentCompile(({ stats, environment })=>{
                 if ('web' === environment.name && (clientStats = createReactRouterManifestStats(stats?.compilation, manifestChunkNames)), pluginOptions.federation && ssr) {
@@ -14058,7 +14498,13 @@ const MAX_SLOWEST_ENTRIES = 5, insertSlowestEntry = (slowest, entry)=>{
                     }),
                     ...bundleVirtualModules,
                     ...bundleManifestModules,
-                    'virtual/react-router/with-props': generateWithProps()
+                    'virtual/react-router/with-props': generateWithProps(),
+                    ...devHmrRefreshRuntimePath ? {
+                        'virtual/react-router/hmr-runtime': generateDevHmrRuntimeModule({
+                            reactRefreshRuntimePath: devHmrRefreshRuntimePath,
+                            hdrRevisionFilePath: getDevHdrRevisionFilePath(api.context.rootPath)
+                        })
+                    } : {}
                 }))), useAsyncNodeChunkLoading = options.federation && 'commonjs' === resolvedServerOutput, nodeChunkLoading = 'require';
                 'module' === resolvedServerOutput ? nodeChunkLoading = 'import' : useAsyncNodeChunkLoading && (nodeChunkLoading = 'async-node');
                 let nodeEntries = createReactRouterNodeEntries({
@@ -14087,7 +14533,6 @@ const MAX_SLOWEST_ENTRIES = 5, insertSlowestEntry = (slowest, entry)=>{
                         assetPrefix: config.output?.assetPrefix || '/'
                     },
                     dev: {
-                        writeToDisk: !0,
                         ...void 0 === guardedLazyCompilation ? {} : {
                             lazyCompilation: guardedLazyCompilation
                         },
@@ -14218,7 +14663,7 @@ const MAX_SLOWEST_ENTRIES = 5, insertSlowestEntry = (slowest, entry)=>{
             }), api.modifyEnvironmentConfig(async (config, { name, mergeEnvironmentConfig })=>'web' !== name && 'node' !== name ? config : mergeEnvironmentConfig(config, {
                     tools: {
                         rspack: (rspackConfig)=>{
-                            if (pluginOptions.federation && ensureFederationAsyncStartup(rspackConfig), 'node' === name) {
+                            if (pluginOptions.federation && ensureFederationAsyncStartup(rspackConfig), 'web' === name && (devHmrEnabled = !isBuild && void 0 !== devHmrRefreshRuntimePath && 'development' === config.mode && config.dev?.hmr !== !1 && isRspackSwcReactRefreshEnabled(rspackConfig)) && devHdrSignal?.ensure(), 'node' === name) {
                                 let output = rspackConfig.output;
                                 if (output) {
                                     let library = output.library, libraryOptions = library && 'object' == typeof library && !Array.isArray(library) ? library : {};
@@ -14285,7 +14730,8 @@ const MAX_SLOWEST_ENTRIES = 5, insertSlowestEntry = (slowest, entry)=>{
                 splitRouteModules: !!splitRouteModules,
                 ssr,
                 isSpaMode,
-                rootRoutePath
+                rootRoutePath,
+                isDevHmrEnabled: ()=>devHmrEnabled
             });
         }
     });

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import { type RsbuildPlugin } from '@rsbuild/core';
 import type { PluginOptions } from './types.js';
 import { resolveReactRouterServerBuild } from './server-utils.js';
+export type { Config as ReactRouterRsbuildConfig } from './react-router-config.js';
 export { loadReactRouterServerBuild } from './dev-generation.js';
 export { resolveReactRouterServerBuild };
 export declare const shouldParallelizeEnvironmentBuilds: ({ isBuild, spareCoreCount, }: {