rsbuild-plugin-react-router 0.3.1 → 0.4.0

package/dist/index.js

@@ -1,9 +1,9 @@
 let globalStore, o, origin, bigint1e6, characters, charactersLength, O, quoteValue, whitespace, options, boundaries, description, options1, f;
-import { existsSync, readFileSync, realpathSync, watch } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, realpathSync, watch, writeFileSync } from "node:fs";
 import fs_extra from "fs-extra";
 import { rspack } from "@rsbuild/core";
 import { createJiti } from "jiti";
-import { dirname, isAbsolute, relative, resolve as external_pathe_resolve } from "pathe";
+import { dirname, isAbsolute, join as external_pathe_join, relative, resolve as external_pathe_resolve } from "pathe";
 import { availableParallelism, cpus } from "node:os";
 import { createRequestHandler as external_react_router_createRequestHandler, matchRoutes } from "react-router";
 import { access, mkdir, readdir, writeFile } from "node:fs/promises";
@@ -13,7 +13,7 @@ import jsesc from "jsesc";
 import { Worker } from "node:worker_threads";
 import { createRequire } from "node:module";
 import { dirname as external_node_path_dirname, isAbsolute as external_node_path_isAbsolute, relative as external_node_path_relative, resolve as external_node_path_resolve, sep as external_node_path_sep, dirname as __rspack_dirname } from "node:path";
-import { createRouteId, SERVER_EXPORTS, combineURLs, JS_EXTENSIONS, executeRouteTransformTask, setBoundedCacheEntry, PLUGIN_NAME, generateWithProps, getRouteModuleAnalysis, createEmptyRouteChunkByExportName, findEntryFile, routeChunkExportNames, validateRouteChunks, CLIENT_EXPORTS, buildManifestChunkValidity, BUILD_CLIENT_ROUTE_QUERY_STRING, getRouteChunkEntryName, getRouteChunkModuleId, normalizeAssetPrefix, detectRouteChunksIfEnabled, createBundlerRouteExportResolver } from "./451.js";
+import { createRouteId, HMR_PATCHABLE_ROUTE_FLAGS, SERVER_EXPORTS, combineURLs, JS_EXTENSIONS, executeRouteTransformTask, setBoundedCacheEntry, PLUGIN_NAME, generateWithProps, getRouteModuleAnalysis, createEmptyRouteChunkByExportName, findEntryFile, routeChunkExportNames, validateRouteChunks, CLIENT_EXPORTS, buildManifestChunkValidity, BUILD_CLIENT_ROUTE_QUERY_STRING, getRouteChunkEntryName, getRouteChunkModuleId, normalizeAssetPrefix, detectRouteChunksIfEnabled, createBundlerRouteExportResolver } from "./451.js";
 let getAvailableCpuCount = ()=>'function' == typeof availableParallelism ? availableParallelism() : cpus().length, getDefaultConcurrency = (cpuCount = getAvailableCpuCount())=>Math.max(0, Math.floor(cpuCount) - 2), getCappedPluginConcurrency = (cap = 16)=>Math.max(1, Math.min(cap, getDefaultConcurrency() || 1)), createReactRouterHydrationModuleTest = (entryClientPath)=>{
     let eagerPatterns = [
         'virtual/react-router/browser-manifest',
@@ -7118,7 +7118,7 @@ let normalizePath = (value)=>value.replace(/\/\/+/g, '/').replace(/(.+)\/$/, '$1
     }))([
         '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:',
-        ...paramRoutes1.map((path)=>`  - ${path}`)
+        ...paramRoutes1.map((path)=>`  - ${path.replace(/^\/(?=[:*])/, '')}`)
     ].join('\n')), paths1;
     if ('function' == typeof pathsConfig) {
         let resolved = await pathsConfig({
@@ -7334,11 +7334,11 @@ let redirectStatusCodes = new Set([
             }))), (controller)=>sync(()=>{
             controller.abort();
         }))), prerenderData = async ({ handler, prerenderPath, onlyRoutes, clientBuildDir, basename, trailingSlashAwareDataRequests, api, requestInit })=>{
-    let dataRequestPath = trailingSlashAwareDataRequests ? prerenderPath.endsWith('/') ? `${prerenderPath}_.data` : `${prerenderPath}.data` : '/' === prerenderPath ? '/_root.data' : `${prerenderPath.replace(/\/$/, '')}.data`, normalizedPath = `${basename}${dataRequestPath}`.replace(/\/\/+/g, '/'), url = new URL(`http://localhost${normalizedPath}`);
+    let dataOutputPath = trailingSlashAwareDataRequests ? prerenderPath.endsWith('/') ? `${prerenderPath}_.data` : `${prerenderPath}.data` : '/' === prerenderPath ? '/_root.data' : `${prerenderPath.replace(/\/$/, '')}.data`, 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 = external_pathe_resolve(clientBuildDir, ...normalizedPath.split('/'));
+        let outputPath = external_pathe_resolve(clientBuildDir, ...outputNormalizedPath.split('/'));
         return await mkdir(dirname(outputPath), {
             recursive: !0
         }), await writeFile(outputPath, data), api.logger.info(`Prerender (data): ${prerenderPath} -> ${relative(process.cwd(), outputPath)}`), data;
@@ -7431,18 +7431,21 @@ let redirectStatusCodes = new Set([
                         trailingSlashAwareDataRequests: future.unstable_trailingSlashAwareDataRequests,
                         api
                     })) : void 0;
-                yield* tryPluginPromise(()=>prerenderRoute({
+                yield* tryPluginPromise(()=>{
+                    let encodedData;
+                    return prerenderRoute({
                         handler: requestHandler,
                         prerenderPath: path,
                         clientBuildDir,
                         basename,
                         api,
-                        requestInit: data ? {
+                        requestInit: data && (encodedData = encodeURI(data)).length < 8192 ? {
                             headers: {
-                                'X-React-Router-Prerender-Data': encodeURI(data)
+                                'X-React-Router-Prerender-Data': encodedData
                             }
                         } : void 0
-                    }));
+                    });
+                });
             }))({
             path,
             build,
@@ -8002,7 +8005,7 @@ let roundMs = (value)=>Math.round(10 * value) / 10, VIRTUAL_MODULE_PREFIX = 'vir
 }, hasSameRouteMetadata = (previous, next)=>previous.caseSensitive === next.caseSensitive && previous.clientActionModule === next.clientActionModule && previous.clientLoaderModule === next.clientLoaderModule && previous.clientMiddlewareModule === next.clientMiddlewareModule && previous.hasErrorBoundary === next.hasErrorBoundary && previous.hasAction === next.hasAction && previous.hasClientAction === next.hasClientAction && previous.hasClientLoader === next.hasClientLoader && previous.hasClientMiddleware === next.hasClientMiddleware && previous.hasDefaultExport === next.hasDefaultExport && previous.hasLoader === next.hasLoader && previous.hydrateFallbackModule === next.hydrateFallbackModule && previous.id === next.id && previous.index === next.index && previous.parentId === next.parentId && previous.path === next.path, DEV_RUNTIME_KEY = Symbol.for('rsbuild-plugin-react-router.dev-runtime.v1'), loadReactRouterServerBuild = (server, entryName)=>{
     let runtime = Reflect.get(server, DEV_RUNTIME_KEY);
     return runtime ? runtime.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().'));
-}, TYPEGEN_IDLE_DELAY_MS = 10000, loadDefaultExeca = async ()=>{
+}, 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), DEV_HDR_REVISION_RELATIVE_PATH = '.react-router/hdr-revision.mjs', isHdrRevisionFile = (file)=>file.includes(DEV_HDR_REVISION_RELATIVE_PATH), isCssSourceFile = (file)=>/\.css(?:\.[cm]?[jt]s)?$/.test(file), TYPEGEN_IDLE_DELAY_MS = 10000, loadDefaultExeca = async ()=>{
     let { execa } = await import("execa");
     return execa;
 }, config_imports_normalizePath = (filePath)=>external_pathe_resolve(filePath), isNodeModulePath = (filePath)=>filePath.split(/[\\/]/).includes('node_modules'), collectConfigImportWatchPaths = (configPath, moduleCache, previousCacheKeys)=>{
@@ -8780,7 +8783,35 @@ let shouldParallelizeEnvironmentBuilds = ({ isBuild, spareCoreCount = getDefault
                 routesByServerBundleId,
                 serverBuildFile,
                 defaultEntryName: devServerBuildEntryName
-            }), { serverBundleEntries } = serverBuildPlan, devRuntime = (({ api, isBuild, buildPlan })=>{
+            }), { serverBundleEntries } = serverBuildPlan, devHmrRefreshRuntimePath = isBuild ? void 0 : ((rootPath)=>{
+                let resolveFrom = (base, request)=>createRequire(base).resolve(request), rootPackageJson = external_pathe_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;
+                }
+            })(api.context.rootPath), devHdrSignal = devHmrRefreshRuntimePath ? (({ filePath, onError })=>{
+                let revision = 0, dirEnsured = !1, write = ()=>{
+                    try {
+                        let revision1;
+                        dirEnsured || (mkdirSync(dirname(filePath), {
+                            recursive: !0
+                        }), dirEnsured = !0), writeFileSync(filePath, (revision1 = revision, `export default ${revision1};\n`));
+                    } catch (error) {
+                        onError?.(error instanceof Error ? error : Error(String(error)));
+                    }
+                };
+                return {
+                    ensure: write,
+                    bump () {
+                        revision += 1, write();
+                    }
+                };
+            })({
+                filePath: external_pathe_join(api.context.rootPath, DEV_HDR_REVISION_RELATIVE_PATH),
+                onError: (error)=>api.logger.debug(`[${PLUGIN_NAME}] Failed to signal hot data revalidation: ${error.message}`)
+            }) : void 0, devHmrEnabled = !1, devRuntime = (({ api, isBuild, buildPlan, onNodeRebuildCommitted })=>{
                 let scheduledCssAssetOwnershipReload, state, nextSessionId, closeObservationByServer, isCurrentBinding, applyCloseOutcome, observeClose, identityByCompilation, webIdentityByNodeCompilation, attemptIdentityByCompilation;
                 if (isBuild) return {
                     captureWeb () {},
@@ -8887,8 +8918,14 @@ let shouldParallelizeEnvironmentBuilds = ({ isBuild, spareCoreCount = getDefault
                     setWebIdentityForNodeCompilation (compilation, identity) {
                         webIdentityByNodeCompilation.set(compilation, identity);
                     }
-                }), { getCompilationIdentity } = compilationIdentities, finishRuntimeAttempt = (binding, pair, stats, changes, identity)=>runPluginEffect(tryPluginPromise(()=>binding.runtime.finishAttempt(stats, changes, identity)).pipe(core_flatMap((result)=>tryPluginSync(()=>{
-                            'retry-node' === result && sessions.getActiveBinding()?.id === binding.id && pair.node.watching?.invalidate();
+                }), { getCompilationIdentity } = compilationIdentities, hdrSignaledNodeIdentity = new WeakMap(), finishRuntimeAttempt = (binding, pair, stats, changes, identity)=>runPluginEffect(tryPluginPromise(()=>binding.runtime.finishAttempt(stats, changes, identity)).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 !== identity.node && hdrSignaledNodeIdentity.get(pair) !== identity.node && ((files)=>{
+                                    for (let file of files)if (!isHdrRevisionFile(file) && !isCssSourceFile(file)) return !0;
+                                    return !1;
+                                })(changes.node.files) && (hdrSignaledNodeIdentity.set(pair, identity.node), onNodeRebuildCommitted?.());
+                            }
                         })), catchAll((cause)=>tryPluginSync(()=>{
                             sessions.getActiveBinding()?.id === binding.id && binding.runtime.failAttempt(normalizeEffectError(cause));
                         })))), flushSettledAttempt = (binding, pair)=>{
@@ -9233,7 +9270,8 @@ let shouldParallelizeEnvironmentBuilds = ({ isBuild, spareCoreCount = getDefault
             })({
                 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) {
@@ -9314,7 +9352,288 @@ let shouldParallelizeEnvironmentBuilds = ({ isBuild, spareCoreCount = getDefault
                     }),
                     ...bundleVirtualModules,
                     ...bundleManifestModules,
-                    'virtual/react-router/with-props': generateWithProps()
+                    'virtual/react-router/with-props': generateWithProps(),
+                    ...devHmrRefreshRuntimePath ? {
+                        'virtual/react-router/hmr-runtime': (({ 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
+  );
+}
+`)({
+                            reactRefreshRuntimePath: devHmrRefreshRuntimePath,
+                            hdrRevisionFilePath: external_pathe_join(api.context.rootPath, DEV_HDR_REVISION_RELATIVE_PATH)
+                        })
+                    } : {}
                 }).map(([moduleId, contents])=>[
                         ((moduleId)=>{
                             if (!moduleId.startsWith(VIRTUAL_MODULE_PREFIX)) throw Error(`Virtual module id must start with ${JSON.stringify(VIRTUAL_MODULE_PREFIX)}: ${moduleId}`);
@@ -9530,7 +9849,7 @@ let shouldParallelizeEnvironmentBuilds = ({ isBuild, spareCoreCount = getDefault
             }), api.modifyEnvironmentConfig(async (config, { name, mergeEnvironmentConfig })=>'web' !== name && 'node' !== name ? config : mergeEnvironmentConfig(config, {
                     tools: {
                         rspack: (rspackConfig)=>{
-                            if (pluginOptions.federation && ((rspackConfig)=>{
+                            (pluginOptions.federation && ((rspackConfig)=>{
                                 if (rspackConfig?.plugins?.length) for (let plugin of rspackConfig.plugins){
                                     if (!plugin || 'object' != typeof plugin || 'ModuleFederationPlugin' !== plugin.name) continue;
                                     let pluginOptions = plugin._options ?? plugin.options;
@@ -9539,7 +9858,8 @@ let shouldParallelizeEnvironmentBuilds = ({ isBuild, spareCoreCount = getDefault
                                         asyncStartup: !0
                                     });
                                 }
-                            })(rspackConfig), 'node' === name) {
+                            })(rspackConfig), 'web' === name) && (devHmrEnabled = !isBuild && void 0 !== devHmrRefreshRuntimePath && 'development' === config.mode && config.dev?.hmr !== !1 && readRuleSetSwcRefresh(rspackConfig.module?.rules)) && devHdrSignal?.ensure();
+                            if ('node' === name) {
                                 let output = rspackConfig.output;
                                 if (output) {
                                     let library = output.library, libraryOptions = library && 'object' == typeof library && !Array.isArray(library) ? library : {};
@@ -9649,7 +9969,7 @@ let shouldParallelizeEnvironmentBuilds = ({ isBuild, spareCoreCount = getDefault
                         isBuild || devRuntime.captureWeb(compilation, manifestsByEntryName);
                     });
                 }
-            }), (({ api, resolvedServerOutput, performanceProfiler, getLatestServerManifest, getLatestServerManifestByBundleId, routes, pluginOptions, getClientStats, appDirectory, getAssetPrefix, routeChunkOptions, routeTransformExecutor, routeByFilePath, routeChunkConfig, isBuild, splitRouteModules, ssr, isSpaMode, rootRoutePath })=>{
+            }), (({ 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,
@@ -9660,7 +9980,8 @@ let shouldParallelizeEnvironmentBuilds = ({ isBuild, spareCoreCount = getDefault
                             ssr,
                             isBuild,
                             isSpaMode,
-                            rootRoutePath
+                            rootRoutePath,
+                            devHmr: isDevHmrEnabled()
                         }));
                 api.processAssets({
                     stage: 'additional',
@@ -9690,7 +10011,9 @@ let shouldParallelizeEnvironmentBuilds = ({ isBuild, spareCoreCount = getDefault
                             resourcePath: args.resourcePath,
                             environmentName: args.environment?.name,
                             isBuild,
-                            routeChunkConfig
+                            routeChunkConfig,
+                            routeId: routeByFilePath.get(args.resourcePath)?.id,
+                            devHmr: isDevHmrEnabled()
                         }))), api.transform({
                     resourceQuery: /route-chunk=/,
                     environments: [
@@ -9767,7 +10090,8 @@ let shouldParallelizeEnvironmentBuilds = ({ isBuild, spareCoreCount = getDefault
                 splitRouteModules: !!splitRouteModules,
                 ssr,
                 isSpaMode,
-                rootRoutePath
+                rootRoutePath,
+                isDevHmrEnabled: ()=>devHmrEnabled
             });
         }
     });

package/dist/route-artifacts.d.ts

@@ -6,6 +6,10 @@ export type RouteClientEntryArtifactOptions = {
     isBuild: boolean;
     routeChunkCache?: RouteChunkCache;
     routeChunkConfig: RouteChunkConfig;
+    /** React Router route id for this route module, when known. */
+    routeId?: string;
+    /** Emit development HMR/HDR glue into web route client entries. */
+    devHmr?: boolean;
 };
 type RouteClientEntryArtifact = {
     code: string;
@@ -22,12 +26,16 @@ type RouteChunkArtifact = {
     code: string;
     map: null;
 };
-export declare const buildRouteClientEntryCode: ({ exportNames, chunkedExports, isServer, resourcePath, }: {
+export declare const HMR_PATCHABLE_ROUTE_FLAGS: readonly ["hasAction", "hasClientAction", "hasClientLoader", "hasClientMiddleware", "hasErrorBoundary", "hasLoader"];
+export declare const buildRouteHmrFlags: (exportNames: readonly string[]) => number;
+export declare const buildRouteClientEntryCode: ({ exportNames, chunkedExports, isServer, resourcePath, routeId, devHmr, }: {
     exportNames: readonly string[];
     chunkedExports: readonly string[];
     isServer: boolean;
     resourcePath: string;
+    routeId?: string;
+    devHmr?: boolean;
 }) => string;
-export declare const createRouteClientEntryArtifact: ({ code, resourcePath, environmentName, isBuild, routeChunkCache, routeChunkConfig, }: RouteClientEntryArtifactOptions) => Promise<RouteClientEntryArtifact>;
+export declare const createRouteClientEntryArtifact: ({ code, resourcePath, environmentName, isBuild, routeChunkCache, routeChunkConfig, routeId, devHmr, }: RouteClientEntryArtifactOptions) => Promise<RouteClientEntryArtifact>;
 export declare const createRouteChunkArtifact: ({ code, resource, resourcePath, isBuild, routeChunkCache, routeChunkConfig, }: RouteChunkArtifactOptions) => Promise<RouteChunkArtifact>;
 export {};

package/dist/route-transform-tasks.d.ts

@@ -14,6 +14,8 @@ export type RouteClientEntryTransformTask = BaseRouteTransformTask & {
     environmentName?: string;
     isBuild: boolean;
     routeChunkConfig: RouteChunkConfig;
+    routeId?: string;
+    devHmr?: boolean;
 };
 export type RouteChunkTransformTask = BaseRouteTransformTask & {
     kind: 'routeChunk';
@@ -38,6 +40,7 @@ export type RouteModuleTransformTask = BaseRouteTransformTask & {
     isBuild: boolean;
     isSpaMode: boolean;
     rootRoutePath: string | null;
+    devHmr?: boolean;
 };
 export type RouteTransformTask = RouteClientEntryTransformTask | RouteChunkTransformTask | SplitRouteExportsTransformTask | ClientOnlyStubTransformTask | RouteModuleTransformTask;
 export type RouteTransformTaskOptions = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rsbuild-plugin-react-router",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "React Router plugin for Rsbuild",
   "repository": {
     "type": "git",
@@ -82,7 +82,7 @@
     "es-module-lexer": "1.7.0",
     "kill-port": "^2.0.1",
     "pkg-pr-new": "^0.0.75",
-    "playwright": "1.58.0",
+    "playwright": "^1.61.1",
     "prettier": "3.8.1",
     "react": "^19.2.4",
     "react-dom": "^19.2.4",
@@ -92,8 +92,14 @@
     "@rsbuild/config": "1.0.1"
   },
   "peerDependencies": {
+    "@react-router/dev": "^7.13.0 || ^8.0.0",
     "@rsbuild/core": "^2.0.0"
   },
+  "peerDependenciesMeta": {
+    "@react-router/dev": {
+      "optional": true
+    }
+  },
   "publishConfig": {
     "access": "public",
     "provenance": false,

package/src/build-output-transforms.ts

@@ -39,6 +39,7 @@ type RegisterBuildOutputTransformsOptions = {
   ssr: boolean;
   isSpaMode: boolean;
   rootRoutePath: string;
+  isDevHmrEnabled?: () => boolean;
 };
 
 export const registerBuildOutputTransforms = ({
@@ -61,6 +62,7 @@ export const registerBuildOutputTransforms = ({
   ssr,
   isSpaMode,
   rootRoutePath,
+  isDevHmrEnabled = () => false,
 }: RegisterBuildOutputTransformsOptions): void => {
   const transformRouteModule = async (args: Parameters<TransformHandler>[0]) =>
     performanceProfiler.record(
@@ -81,6 +83,7 @@ export const registerBuildOutputTransforms = ({
           isBuild,
           isSpaMode,
           rootRoutePath,
+          devHmr: isDevHmrEnabled(),
         })
     );
 
@@ -158,6 +161,8 @@ export const registerBuildOutputTransforms = ({
             environmentName: args.environment?.name,
             isBuild,
             routeChunkConfig,
+            routeId: routeByFilePath.get(args.resourcePath)?.id,
+            devHmr: isDevHmrEnabled(),
           })
       )
   );