rsbuild-plugin-react-router 0.3.0 → 0.4.0

package/dist/dev-hmr.d.ts

@@ -0,0 +1,45 @@
+import type { Rspack } from '@rsbuild/core';
+export declare const DEV_HMR_RUNTIME_MODULE_ID = "virtual/react-router/hmr-runtime";
+export declare const isRspackSwcReactRefreshEnabled: (rspackConfig: Rspack.Configuration) => boolean;
+/**
+ * Resolves the `react-refresh/runtime` module that
+ * `@rspack/plugin-react-refresh` injects into the web bundle. The resolution
+ * walks the same dependency chain the refresh plugin uses so the returned file
+ * is the exact runtime instance already present in the browser module graph.
+ * Returns `undefined` when React Fast Refresh is unavailable, in which case
+ * 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 DEV_HDR_REVISION_RELATIVE_PATH = ".react-router/hdr-revision.mjs";
+export declare const getDevHdrRevisionFilePath: (rootPath: string) => string;
+export type DevHdrRevisionSignal = {
+    /** 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.
+ *
+ * This mirrors React Router's Vite 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),
+ * recreating the client routes with revalidation opt-out, revalidating loader
+ * data, and finally performing a React refresh.
+ */
+export declare const generateDevHmrRuntimeModule: ({ reactRefreshRuntimePath, hdrRevisionFilePath, }: {
+    reactRefreshRuntimePath: string;
+    hdrRevisionFilePath: string;
+}) => string;

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

@@ -8,6 +8,11 @@ export type ReactRouterDevBuildPlan = {
 };
 export type ReactRouterDevManifestSet = Readonly<Record<string, ReactRouterDevManifest>>;
 export type ReactRouterServerBuilds = Readonly<Record<string, ServerBuild>>;
+export type PairedDevStats = {
+    web: Rspack.Stats;
+    node: Rspack.Stats;
+};
+export type DevRuntimeStats = Rspack.Stats | Rspack.MultiStats | PairedDevStats;
 export type DependencySnapshot = {
     files: ReadonlySet<string>;
     contexts: ReadonlySet<string>;
@@ -22,10 +27,12 @@ export type DevGraphChanges = {
     node: DevChangedFiles;
 };
 export type DevCompilationIdentity = symbol;
+export type DevCompileAttemptIdentity = symbol;
 export type DevGraphIdentity = {
     web: DevCompilationIdentity | undefined;
     node: DevCompilationIdentity | undefined;
     nodeWeb: DevCompilationIdentity | undefined;
+    attempt: DevCompileAttemptIdentity | undefined;
 };
 export type WebArtifact = {
     manifestsByEntryName: ReactRouterDevManifestSet;
@@ -34,6 +41,7 @@ export type WebArtifact = {
 export declare const snapshotDevChangedFiles: (compiler: Pick<Rspack.Compiler, "modifiedFiles" | "removedFiles"> | undefined) => DevChangedFiles;
 export declare const snapshotDependencies: (compilation: Rspack.Compilation) => DependencySnapshot;
 export declare const isSafeOneSidedChange: (changes: DevChangedFiles, dependencies: DependencySnapshot) => boolean;
-export declare const getEnvironmentStats: (stats: Rspack.Stats | Rspack.MultiStats, name: "web" | "node") => Rspack.Stats | undefined;
+export declare const isPairedDevStats: (stats: DevRuntimeStats) => stats is PairedDevStats;
+export declare const getEnvironmentStats: (stats: DevRuntimeStats, name: "web" | "node") => Rspack.Stats | undefined;
 export declare const evaluateServerBuilds: (server: RsbuildDevServer, entryNames: readonly string[]) => Promise<ReactRouterServerBuilds>;
 export declare const pinServerBuildsToManifests: (builds: ReactRouterServerBuilds, entryNames: readonly string[], manifestsByEntryName: ReactRouterDevManifestSet) => ReactRouterServerBuilds;

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

@@ -1,16 +1,19 @@
 import type { Rspack } from '@rsbuild/core';
-import type { DevCompilationIdentity, DevGraphChanges, DevGraphIdentity } from './dev-runtime-artifacts.js';
+import type { DevCompileAttemptIdentity, DevCompilationIdentity, DevRuntimeStats, DevGraphChanges, DevGraphIdentity } from './dev-runtime-artifacts.js';
 export type DevCompilerPair = {
     web: Rspack.Compiler;
     node: Rspack.Compiler;
     settledCompilations: WeakSet<Rspack.Compilation>;
     pendingAttempt?: PendingDevCompilation;
+    currentAttemptIdentity?: DevCompileAttemptIdentity;
     latestCompletedWebIdentity?: DevCompilationIdentity;
+    latestCompletedWebStats?: Rspack.Stats;
+    latestCompletedNodeStats?: Rspack.Stats;
     latestWebStart?: CompilationStart;
     latestNodeStart?: CompilationStart;
 };
 export type PendingDevCompilation = {
-    stats: Rspack.Stats | Rspack.MultiStats;
+    stats: DevRuntimeStats;
     changes: DevGraphChanges;
     identity: DevGraphIdentity;
     webCompilation: Rspack.Compilation;
@@ -22,11 +25,23 @@ export type CompilationStart = {
     status: 'started';
     identity: DevCompilationIdentity;
 };
+type CompilerPairStartSide = 'latestWebStart' | 'latestNodeStart';
+export declare const createDevCompilerPair: ({ web, node, }: {
+    web: Rspack.Compiler;
+    node: Rspack.Compiler;
+}) => DevCompilerPair;
+export declare const resetDevCompilerPair: (pair: DevCompilerPair) => void;
 export declare const isLatestStartedCompilation: (identity: DevCompilationIdentity | undefined, start: CompilationStart | undefined) => boolean;
 export declare const hasPendingCompilation: (pair: DevCompilerPair) => boolean;
+export declare const beginDevCompilerAttempt: (pair: DevCompilerPair) => void;
+export declare const markDevCompilerPending: (pair: DevCompilerPair, side: CompilerPairStartSide) => boolean;
+export declare const clearDevCompilerStart: (pair: DevCompilerPair, side: CompilerPairStartSide) => void;
 export type CompilationIdentityTracker = {
     getCompilationIdentity(compilation: Rspack.Compilation): DevCompilationIdentity;
     getWebIdentityForNodeCompilation(compilation: Rspack.Compilation): DevCompilationIdentity | undefined;
+    getAttemptIdentityForCompilation(compilation: Rspack.Compilation): DevCompileAttemptIdentity | undefined;
+    setAttemptIdentityForCompilation(compilation: Rspack.Compilation, identity: DevCompileAttemptIdentity): void;
     setWebIdentityForNodeCompilation(compilation: Rspack.Compilation, identity: DevCompilationIdentity): void;
 };
 export declare const createCompilationIdentityTracker: () => CompilationIdentityTracker;
+export {};

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

@@ -9,6 +9,11 @@ type CreateControllerOptions = {
     api: RsbuildPluginAPI;
     isBuild: boolean;
     buildPlan: ReactRouterDevBuildPlan;
+    /**
+     * 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, }: CreateControllerOptions) => ReactRouterDevRuntimeController;
+export declare const createReactRouterDevRuntimeController: ({ api, isBuild, buildPlan, onNodeRebuildCommitted, }: CreateControllerOptions) => ReactRouterDevRuntimeController;
 export {};

package/dist/dev-server.d.ts

@@ -1,5 +1,7 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { RsbuildConfig } from '@rsbuild/core';
 import type { ServerBuild } from 'react-router';
+export type ServerSetup = Exclude<NonNullable<NonNullable<RsbuildConfig['server']>['setup']>, unknown[]>;
 export type DevServerMiddleware = (req: IncomingMessage, res: ServerResponse, next: (err?: unknown) => void) => Promise<void>;
 type RequestHandler = (request: Request) => Response | Promise<Response>;
 type BuildProvider = () => Promise<ServerBuild>;
@@ -9,4 +11,7 @@ export type DevServerMiddlewareDependencies = {
     createRequestListener?: (handler: RequestHandler) => (req: IncomingMessage, res: ServerResponse) => void | Promise<void>;
 };
 export declare const createDevServerMiddleware: (dependencies: DevServerMiddlewareDependencies) => DevServerMiddleware;
+export declare const createReactRouterDevServerSetup: ({ loadBuild, }: {
+    loadBuild: BuildProvider;
+}) => ServerSetup;
 export {};

package/dist/effect-runtime.d.ts

@@ -0,0 +1,18 @@
+import * as Effect from 'effect/Effect';
+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>;
+};
+export declare const createDelayedPluginTask: ({ delayMs, run, onError, }: {
+    delayMs: number;
+    run: () => Effect.Effect<void, Error, never>;
+    onError: (error: Error) => void;
+}) => DelayedPluginTask;
+export {};

package/dist/export-utils.d.ts

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