rsbuild-plugin-react-router 0.4.1 → 0.6.0

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

@@ -1,10 +1,31 @@
 import type { RsbuildPluginAPI } from '@rsbuild/core';
-import { getReactRouterManifestForDev, type ReactRouterManifestStats } from './manifest.js';
-import type { RouteTransformExecutor } from './parallel-route-transforms.js';
+import { type ReactRouterManifestForDev as ReactRouterManifest, type RouteChunkManifestOptions, type RouteModuleAnalysisProvider, type ReactRouterManifestStats } from './manifest.js';
 import type { ReactRouterPerformanceProfiler } from './performance.js';
-import type { RouteChunkConfig } from './route-chunks.js';
+import { type RouteTransformRunner } from './route-transform-tasks.js';
+import { type RouteChunkConfig } from './route-chunks.js';
 import type { PluginOptions, Route } from './types.js';
-type ReactRouterManifest = Awaited<ReturnType<typeof getReactRouterManifestForDev>>;
+import { type RouteModuleAnalysis } from './export-utils.js';
+/**
+ * Register the node-compilation hook that relocates server-only static assets
+ * (`?url` imports, `.css?url` files, and other `asset/resource` outputs
+ * referenced only by loaders or `.server` modules) into the client build. The
+ * loader/`links()` export returns the asset URL to the client, which fetches it
+ * from `build/client` at runtime, so the file must exist there even though only
+ * the node compilation referenced it. The assets are also stripped from the
+ * server build to avoid shipping duplicate static files, mirroring upstream
+ * React Router's Vite plugin. This runs for every node compilation, so it also
+ * covers `serverBundles` (multiple node outputs) and dev mode (where
+ * `writeToDisk` is enabled).
+ *
+ * Registered by both the classic build-output transforms and the RSC branch so
+ * `.css?url`/`?url` assets referenced from `links()` resolve in RSC framework
+ * mode too.
+ */
+export declare const registerSsrAssetRelocation: ({ api, outputClientPath, performanceProfiler, }: {
+    api: RsbuildPluginAPI;
+    outputClientPath: string;
+    performanceProfiler: ReactRouterPerformanceProfiler;
+}) => void;
 type RegisterBuildOutputTransformsOptions = {
     api: RsbuildPluginAPI;
     resolvedServerOutput: 'module' | 'commonjs';
@@ -16,16 +37,20 @@ type RegisterBuildOutputTransformsOptions = {
     getClientStats: () => ReactRouterManifestStats | undefined;
     appDirectory: string;
     getAssetPrefix: () => string;
-    routeChunkOptions: Parameters<typeof getReactRouterManifestForDev>[5];
-    routeTransformExecutor: RouteTransformExecutor;
+    routeChunkOptions: RouteChunkManifestOptions | undefined;
+    routeModuleAnalysis?: RouteModuleAnalysisProvider;
+    routeTransformRunner: RouteTransformRunner;
     routeByFilePath: Map<string, Route>;
     routeChunkConfig: RouteChunkConfig;
     isBuild: boolean;
     splitRouteModules: boolean;
+    useRouteModuleTransformApi: boolean;
     ssr: boolean;
     isSpaMode: boolean;
     rootRoutePath: string;
+    outputClientPath: string;
     isDevHmrEnabled?: () => boolean;
+    onRouteModuleAnalysis?: (resourcePath: string, analysis: RouteModuleAnalysis) => void;
 };
-export declare const registerBuildOutputTransforms: ({ api, resolvedServerOutput, performanceProfiler, getLatestServerManifest, getLatestServerManifestByBundleId, routes, pluginOptions, getClientStats, appDirectory, getAssetPrefix, routeChunkOptions, routeTransformExecutor, routeByFilePath, routeChunkConfig, isBuild, splitRouteModules, ssr, isSpaMode, rootRoutePath, isDevHmrEnabled, }: RegisterBuildOutputTransformsOptions) => void;
+export declare const registerBuildOutputTransforms: ({ api, resolvedServerOutput, performanceProfiler, getLatestServerManifest, getLatestServerManifestByBundleId, routes, pluginOptions, getClientStats, appDirectory, getAssetPrefix, routeChunkOptions, routeModuleAnalysis, routeTransformRunner, routeByFilePath, routeChunkConfig, isBuild, splitRouteModules, useRouteModuleTransformApi, ssr, isSpaMode, rootRoutePath, outputClientPath, isDevHmrEnabled, onRouteModuleAnalysis, }: RegisterBuildOutputTransformsOptions) => void;
 export {};

package/dist/classic-mode.d.ts

@@ -0,0 +1,56 @@
+import type { RsbuildEntryDescription, RsbuildPluginAPI } from '@rsbuild/core';
+import type { RouteConfigEntry } from '@react-router/dev/routes';
+import { getBuildManifest } from './build-manifest.js';
+import { type DevHmrPlanOptions } from './dev-hmr.js';
+import { type ReactRouterDevRuntimeController } from './dev-runtime-controller.js';
+import { type ReactRouterServerBundleEntry } from './server-build-plan.js';
+import type { Config } from './react-router-config.js';
+import type { Route } from './types.js';
+type CreateClassicWebRouteEntriesOptions = {
+    appDirectory: string;
+    isBuild: boolean;
+    routes: Record<string, Route>;
+    splitRouteModules: boolean;
+};
+type CreateClassicVirtualModulesOptions = {
+    allowedActionOrigins: string[] | undefined;
+    appDirectory: string;
+    assetsBuildDirectory: string;
+    basename: string;
+    devHmrRuntimeModule?: string;
+    entryServerPath: string;
+    future: Config['future'];
+    isSpaMode: boolean;
+    prerenderPaths: string[];
+    publicPath: string;
+    routeDiscovery: Config['routeDiscovery'];
+    routes: Record<string, Route>;
+    routesByServerBundleId: Record<string, Record<string, Route>>;
+    ssr: boolean;
+};
+type CreateClassicBuildArtifactsOptions = {
+    api: RsbuildPluginAPI;
+    defaultEntryName: string;
+    isBuild: boolean;
+    prerenderConfig: Config['prerender'];
+    reactRouterConfig: Required<Pick<Config, 'appDirectory' | 'buildDirectory' | 'serverBuildFile' | 'future'>> & Pick<Config, 'serverBundles'>;
+    routeConfig: RouteConfigEntry[];
+    routes: Record<string, Route>;
+    rootDirectory: string;
+    ssr: boolean;
+    devHmr?: DevHmrPlanOptions;
+};
+export type ClassicBuildArtifacts = {
+    buildManifest: Awaited<ReturnType<typeof getBuildManifest>>;
+    devRuntime: ReactRouterDevRuntimeController;
+    prerenderPaths: string[];
+    routesByServerBundleId: Record<string, Record<string, Route>>;
+    serverBundleEntries: ReactRouterServerBundleEntry[];
+};
+export declare const createClassicBuildArtifacts: ({ api, defaultEntryName, isBuild, prerenderConfig, reactRouterConfig, routeConfig, routes, rootDirectory, ssr, devHmr, }: CreateClassicBuildArtifactsOptions) => Promise<ClassicBuildArtifacts>;
+export declare const createClassicWebRouteEntries: ({ appDirectory, isBuild, routes, splitRouteModules, }: CreateClassicWebRouteEntriesOptions) => {
+    manifestChunkNames: Set<string>;
+    webRouteEntries: Record<string, RsbuildEntryDescription>;
+};
+export declare const createClassicVirtualModules: ({ allowedActionOrigins, appDirectory, assetsBuildDirectory, basename, devHmrRuntimeModule, entryServerPath, future, isSpaMode, prerenderPaths, publicPath, routeDiscovery, routes, routesByServerBundleId, ssr, }: CreateClassicVirtualModulesOptions) => Record<string, string>;
+export {};

package/dist/config-imports.d.ts

@@ -1,9 +1,15 @@
 import type { ModuleCache } from 'jiti';
 import { createJiti } from 'jiti';
-type ConfigImporter = Pick<ReturnType<typeof createJiti>, 'import'>;
+export type ConfigImporter = Pick<ReturnType<typeof createJiti>, 'import'>;
+type ConfigImportOptions = {
+    define?: Record<string, unknown>;
+    moduleCache?: boolean;
+};
+export declare const applyConfigDefines: (source: string, define: Record<string, unknown> | undefined) => string;
+export declare const createConfigImporter: ({ define, moduleCache, }?: ConfigImportOptions) => ReturnType<typeof createJiti>;
 export declare const collectConfigImportWatchPaths: (configPath: string, moduleCache: ModuleCache, previousCacheKeys: ReadonlySet<string>) => string[];
 export declare const clearConfigImportCache: (moduleCache: ModuleCache, filePaths: readonly string[]) => void;
-export declare const importConfigWithWatchPaths: <T>(configPath: string, load?: (importer: ConfigImporter) => PromiseLike<T> | T) => Promise<{
+export declare const importConfigWithWatchPaths: <T>(configPath: string, load?: (importer: ConfigImporter) => PromiseLike<T> | T, options?: ConfigImportOptions) => Promise<{
     value: Awaited<T>;
     watchPaths: string | string[];
 }>;

package/dist/constants.d.ts

@@ -1,4 +1,6 @@
 export declare const PLUGIN_NAME = "rsbuild:react-router";
+/** Default web `output.distPath.js` segment when the user has not customized it. */
+export declare const DEFAULT_JS_DIST_PATH = "static/js";
 export declare const JS_EXTENSIONS: readonly [".tsx", ".ts", ".jsx", ".js", ".mjs", ".mts"];
 export declare const JS_LOADERS: {
     readonly '.ts': "ts";
@@ -36,3 +38,4 @@ export declare const CLIENT_EXPORTS: {
     readonly meta: "meta";
     readonly shouldRevalidate: "shouldRevalidate";
 };
+export declare const SPA_FALLBACK_HTML_FILE = "__spa-fallback.html";

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

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

package/dist/dev-generation.d.ts

@@ -1,8 +1,7 @@
 import type { RsbuildDevServer, Rspack } from '@rsbuild/core';
 import type { ServerBuild } from 'react-router';
 import { type DevGraphChanges, type DevGraphIdentity, type DevRuntimeStats, type ReactRouterDevBuildPlan, type ReactRouterDevManifestSet } from './dev-runtime-artifacts.js';
-export { snapshotDevChangedFiles } from './dev-runtime-artifacts.js';
-export type { DevChangedFiles, DevGraphChanges, DevGraphIdentity, ReactRouterDevBuildPlan, ReactRouterDevManifest, ReactRouterDevManifestSet, } from './dev-runtime-artifacts.js';
+export type { DevGraphChanges, DevGraphIdentity, ReactRouterDevManifest, } from './dev-runtime-artifacts.js';
 export type ReactRouterDevRuntime = {
     beginAttempt: () => void;
     captureWeb: (compilation: Rspack.Compilation, manifestsByEntryName: ReactRouterDevManifestSet) => void;
@@ -16,7 +15,7 @@ type CreateReactRouterDevRuntimeOptions = {
     buildPlan: ReactRouterDevBuildPlan;
     onEvaluationError: (error: Error) => void;
     onCssAssetOwnershipChanged?: (change: 'removed' | 'restored') => void;
-    onRouteManifestChanged?: () => void;
+    onRouteManifestChanged?: (manifest: ReactRouterDevManifestSet[string]) => void;
     onWarning?: (message: string) => void;
 };
 export declare const createReactRouterDevRuntime: ({ server, buildPlan, onEvaluationError, onCssAssetOwnershipChanged, onRouteManifestChanged, onWarning, }: CreateReactRouterDevRuntimeOptions) => ReactRouterDevRuntime;

package/dist/dev-hmr.d.ts

@@ -1,5 +1,11 @@
 import type { Rspack } from '@rsbuild/core';
 export declare const DEV_HMR_RUNTIME_MODULE_ID = "virtual/react-router/hmr-runtime";
+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;
 /**
  * Resolves the `react-refresh/runtime` module that
@@ -17,9 +23,9 @@ export declare const resolveReactRefreshRuntimePath: (rootPath: string) => strin
  * whenever server code changes, which the client answers by revalidating
  * React Router loader data.
  */
-export declare const DEV_HDR_REVISION_RELATIVE_PATH = ".react-router/hdr-revision.mjs";
 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. */
@@ -32,7 +38,7 @@ export declare const createDevHdrRevisionSignal: ({ filePath, onError, }: {
 /**
  * Browser-side HMR runtime shared by all route client entries in development.
  *
- * This mirrors React Router's Vite HMR contract (see `refresh-utils.mjs` in
+ * This mirrors React Router framework HMR contract (see `refresh-utils.mjs` in
  * `@react-router/dev`): route module updates are applied by patching
  * `window.__reactRouterRouteModules` while preserving the previous component
  * identities (React Fast Refresh swaps their implementations in place),

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

@@ -9,11 +9,16 @@ type CreateControllerOptions = {
     api: RsbuildPluginAPI;
     isBuild: boolean;
     buildPlan: ReactRouterDevBuildPlan;
+    /**
+     * The browser HMR runtime patches route manifest metadata (loader/action
+     * 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, onNodeRebuildCommitted, }: CreateControllerOptions) => ReactRouterDevRuntimeController;
+export declare const createReactRouterDevRuntimeController: ({ api, isBuild, buildPlan, clientPatchesRouteMetadata, onNodeRebuildCommitted, }: CreateControllerOptions) => ReactRouterDevRuntimeController;
 export {};

package/dist/dev-source-maps.d.ts

@@ -0,0 +1,4 @@
+import type { Rspack } from '@rsbuild/core';
+export declare const registerDevServerSourceMaps: (compilation: Pick<Rspack.Compilation, "getAssets" | "outputOptions">) => void;
+export declare const remapDevServerStack: (stack: string) => string;
+export declare const installDevServerSourceMapSupport: () => void;

package/dist/effect-runtime.d.ts

@@ -1,18 +1,30 @@
+import * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
+import * as FiberSet from 'effect/FiberSet';
+import * as ManagedRuntime from 'effect/ManagedRuntime';
+import * as Scope from 'effect/Scope';
+type PluginResources = {
+    readonly scope: Scope.CloseableScope;
+};
+declare const PluginResources: Context.Tag<PluginResources, PluginResources>;
+type PluginRuntimeContext = Scope.Scope | FiberSet.FiberSet | PluginResources;
+export type PluginEffectRuntime = Pick<ManagedRuntime.ManagedRuntime<PluginRuntimeContext, never>, 'runFork' | 'runPromise'> & {
+    readonly dispose: () => Promise<void>;
+};
+export declare const createPluginEffectRuntime: () => PluginEffectRuntime;
 export declare const DEV_BACKGROUND_STARTUP_DELAY_MS = 3000;
 export declare const normalizeEffectError: (cause: unknown) => Error;
 export declare const runPluginEffect: <A, E>(effect: Effect.Effect<A, E, never>) => Promise<A>;
-export declare const tryPluginSync: <A>(evaluate: () => A) => Effect.Effect<A, Error, never>;
 export declare const tryPluginPromise: <A>(evaluate: () => PromiseLike<A> | A) => Effect.Effect<A, Error, never>;
 type DelayedPluginTask = {
     schedule(): void;
     reschedule(): void;
-    cancelEffect(): Effect.Effect<void, Error, never>;
-    cancel(): Promise<void>;
+    cancelEffect(): Effect.Effect<void>;
 };
-export declare const createDelayedPluginTask: ({ delayMs, run, onError, }: {
+export declare const createDelayedPluginTask: ({ runtime, delayMs, run, onError, }: {
+    runtime: PluginEffectRuntime;
     delayMs: number;
-    run: () => Effect.Effect<void, Error, never>;
+    run: () => Effect.Effect<void, Error, Scope.Scope>;
     onError: (error: Error) => void;
 }) => DelayedPluginTask;
 export {};

package/dist/entry-paths.d.ts

@@ -0,0 +1,16 @@
+type ReactRouterEntryPathsOptions = {
+    appDirectory: string;
+    templatesDirectory: string;
+};
+export type ReactRouterEntryPaths = {
+    devServerBuildEntryName: string;
+    finalEntryClientPath: string;
+    finalEntryRscClientPath: string;
+    finalEntryRscPath: string;
+    finalEntryRscSsrPath: string;
+    finalEntryServerPath: string;
+    hasServerApp: boolean;
+    serverAppPath: string;
+};
+export declare const resolveReactRouterEntryPaths: ({ appDirectory, templatesDirectory, }: ReactRouterEntryPathsOptions) => ReactRouterEntryPaths;
+export {};

package/dist/environment-output.d.ts

@@ -0,0 +1,6 @@
+import type { RsbuildPluginAPI } from '@rsbuild/core';
+export declare const registerReactRouterEnvironmentOutput: ({ api, federation, resolvedServerOutput, }: {
+    api: RsbuildPluginAPI;
+    federation: boolean | undefined;
+    resolvedServerOutput: "commonjs" | "module";
+}) => void;

package/dist/export-utils.d.ts

@@ -3,7 +3,7 @@ type ExportInfo = {
     readonly exportNames: readonly string[];
     readonly exportAllModules: readonly string[];
 };
-type RouteModuleAnalysis = {
+export type RouteModuleAnalysis = {
     readonly code: string;
     readonly exports: readonly string[];
     readonly exportAllModules: readonly string[];
@@ -11,5 +11,6 @@ type RouteModuleAnalysis = {
 export declare const collectProgramExportNames: (program: ProgramNode) => string[];
 export declare const getExportNames: (code: string, resourcePath?: string) => Promise<readonly string[]>;
 export declare const getExportNamesAndExportAll: (code: string, resourcePath?: string) => Promise<ExportInfo>;
+export declare const analyzeRouteModuleCode: (code: string, resourcePath?: string) => RouteModuleAnalysis;
 export declare const getRouteModuleAnalysis: (resourcePath: string) => Promise<RouteModuleAnalysis>;
 export {};

package/dist/federation.d.ts

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