rsbuild-plugin-react-router 0.1.1 → 0.3.0

package/dist/bounded-cache.d.ts

@@ -0,0 +1 @@
+export declare const setBoundedCacheEntry: <Key, Value>(cache: Map<Key, Value>, key: Key, value: Value, maxEntries: number) => void;

package/dist/build-manifest.d.ts

@@ -15,5 +15,5 @@ export declare const getBuildManifest: ({ reactRouterConfig, routes, rootDirecto
     routes: Record<string, Route>;
     rootDirectory: string;
 }) => Promise<BuildManifest | undefined>;
-export declare const getRoutesByServerBundleId: (buildManifest: BuildManifest | undefined) => Record<string, Record<string, Route>>;
+export declare const getRoutesByServerBundleId: (buildManifest: BuildManifest | undefined, sourceRoutes: Record<string, Route>) => Record<string, Record<string, Route>>;
 export {};

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

@@ -0,0 +1,30 @@
+import type { RsbuildPluginAPI } from '@rsbuild/core';
+import { getReactRouterManifestForDev, type ReactRouterManifestStats } from './manifest.js';
+import type { RouteTransformExecutor } from './parallel-route-transforms.js';
+import type { ReactRouterPerformanceProfiler } from './performance.js';
+import type { RouteChunkConfig } from './route-chunks.js';
+import type { PluginOptions, Route } from './types.js';
+type ReactRouterManifest = Awaited<ReturnType<typeof getReactRouterManifestForDev>>;
+type RegisterBuildOutputTransformsOptions = {
+    api: RsbuildPluginAPI;
+    resolvedServerOutput: 'module' | 'commonjs';
+    performanceProfiler: ReactRouterPerformanceProfiler;
+    getLatestServerManifest: () => ReactRouterManifest | null;
+    getLatestServerManifestByBundleId: (bundleId: string) => ReactRouterManifest | undefined;
+    routes: Record<string, Route>;
+    pluginOptions: PluginOptions;
+    getClientStats: () => ReactRouterManifestStats | undefined;
+    appDirectory: string;
+    getAssetPrefix: () => string;
+    routeChunkOptions: Parameters<typeof getReactRouterManifestForDev>[5];
+    routeTransformExecutor: RouteTransformExecutor;
+    routeByFilePath: Map<string, Route>;
+    routeChunkConfig: RouteChunkConfig;
+    isBuild: boolean;
+    splitRouteModules: boolean;
+    ssr: boolean;
+    isSpaMode: boolean;
+    rootRoutePath: string;
+};
+export declare const registerBuildOutputTransforms: ({ api, resolvedServerOutput, performanceProfiler, getLatestServerManifest, getLatestServerManifestByBundleId, routes, pluginOptions, getClientStats, appDirectory, getAssetPrefix, routeChunkOptions, routeTransformExecutor, routeByFilePath, routeChunkConfig, isBuild, splitRouteModules, ssr, isSpaMode, rootRoutePath, }: RegisterBuildOutputTransformsOptions) => void;
+export {};

package/dist/concurrency.d.ts

@@ -0,0 +1,2 @@
+export declare const getDefaultConcurrency: (cpuCount?: number) => number;
+export declare const mapWithConcurrency: <Item, Result>(items: readonly Item[], concurrency: number, worker: (item: Item, index: number) => Promise<Result>) => Promise<Result[]>;

package/dist/config-imports.d.ts

@@ -0,0 +1,3 @@
+import type { ModuleCache } from 'jiti';
+export declare const collectConfigImportWatchPaths: (configPath: string, moduleCache: ModuleCache, previousCacheKeys: ReadonlySet<string>) => string[];
+export declare const clearConfigImportCache: (moduleCache: ModuleCache, filePaths: readonly string[]) => void;

package/dist/constants.d.ts

@@ -10,10 +10,13 @@ export declare const JS_LOADERS: {
 };
 export declare const BUILD_CLIENT_ROUTE_QUERY_STRING = "?__react-router-build-client-route";
 export declare const SERVER_ONLY_ROUTE_EXPORTS: readonly ["loader", "action", "middleware", "headers"];
+export declare const SERVER_ONLY_ROUTE_EXPORTS_SET: ReadonlySet<string>;
 export declare const CLIENT_NON_COMPONENT_EXPORTS: readonly ["clientAction", "clientLoader", "clientMiddleware", "handle", "meta", "links", "shouldRevalidate"];
 export declare const CLIENT_COMPONENT_EXPORTS: readonly ["default", "ErrorBoundary", "HydrateFallback", "Layout"];
 export declare const CLIENT_ROUTE_EXPORTS: readonly ((typeof CLIENT_NON_COMPONENT_EXPORTS)[number] | (typeof CLIENT_COMPONENT_EXPORTS)[number])[];
+export declare const CLIENT_ROUTE_EXPORTS_SET: ReadonlySet<string>;
 export declare const NAMED_COMPONENT_EXPORTS: readonly ["HydrateFallback", "ErrorBoundary"];
+export declare const NAMED_COMPONENT_EXPORTS_SET: ReadonlySet<string>;
 export declare const SERVER_EXPORTS: {
     readonly loader: "loader";
     readonly action: "action";

package/dist/dev-generation.d.ts

@@ -0,0 +1,25 @@
+import type { RsbuildDevServer, Rspack } from '@rsbuild/core';
+import type { ServerBuild } from 'react-router';
+import { type DevGraphChanges, type DevGraphIdentity, 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 ReactRouterDevRuntime = {
+    beginAttempt: () => void;
+    captureWeb: (compilation: Rspack.Compilation, manifestsByEntryName: ReactRouterDevManifestSet) => void;
+    finishAttempt: (stats: Rspack.Stats | Rspack.MultiStats, changes: DevGraphChanges, identity: DevGraphIdentity) => Promise<void>;
+    failAttempt: (error: Error) => void;
+    load: (entryName?: string) => Promise<ServerBuild>;
+    close: (error?: Error) => void;
+};
+type CreateReactRouterDevRuntimeOptions = {
+    server: RsbuildDevServer;
+    buildPlan: ReactRouterDevBuildPlan;
+    onEvaluationError: (error: Error) => void;
+    onCssAssetOwnershipChanged?: (change: 'removed' | 'restored') => void;
+    onRouteManifestChanged?: () => void;
+    onWarning?: (message: string) => void;
+};
+export declare const createReactRouterDevRuntime: ({ server, buildPlan, onEvaluationError, onCssAssetOwnershipChanged, onRouteManifestChanged, onWarning, }: CreateReactRouterDevRuntimeOptions) => ReactRouterDevRuntime;
+export declare const registerReactRouterDevRuntime: (server: RsbuildDevServer, runtime: ReactRouterDevRuntime) => void;
+export declare const unregisterReactRouterDevRuntime: (server: RsbuildDevServer, runtime: ReactRouterDevRuntime) => void;
+export declare const loadReactRouterServerBuild: (server: RsbuildDevServer, entryName?: string) => Promise<ServerBuild>;

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

@@ -0,0 +1,39 @@
+import type { RsbuildDevServer, Rspack } from '@rsbuild/core';
+import type { ServerBuild } from 'react-router';
+import type { ReactRouterManifestForDev } from './manifest.js';
+export type ReactRouterDevManifest = ReactRouterManifestForDev;
+export type ReactRouterDevBuildPlan = {
+    defaultEntryName: string;
+    entryNames: readonly string[];
+};
+export type ReactRouterDevManifestSet = Readonly<Record<string, ReactRouterDevManifest>>;
+export type ReactRouterServerBuilds = Readonly<Record<string, ServerBuild>>;
+export type DependencySnapshot = {
+    files: ReadonlySet<string>;
+    contexts: ReadonlySet<string>;
+    missing: ReadonlySet<string>;
+};
+export type DevChangedFiles = {
+    known: boolean;
+    files: ReadonlySet<string>;
+};
+export type DevGraphChanges = {
+    web: DevChangedFiles;
+    node: DevChangedFiles;
+};
+export type DevCompilationIdentity = symbol;
+export type DevGraphIdentity = {
+    web: DevCompilationIdentity | undefined;
+    node: DevCompilationIdentity | undefined;
+    nodeWeb: DevCompilationIdentity | undefined;
+};
+export type WebArtifact = {
+    manifestsByEntryName: ReactRouterDevManifestSet;
+    dependencies: DependencySnapshot;
+};
+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 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

@@ -0,0 +1,32 @@
+import type { Rspack } from '@rsbuild/core';
+import type { DevCompilationIdentity, DevGraphChanges, DevGraphIdentity } from './dev-runtime-artifacts.js';
+export type DevCompilerPair = {
+    web: Rspack.Compiler;
+    node: Rspack.Compiler;
+    settledCompilations: WeakSet<Rspack.Compilation>;
+    pendingAttempt?: PendingDevCompilation;
+    latestCompletedWebIdentity?: DevCompilationIdentity;
+    latestWebStart?: CompilationStart;
+    latestNodeStart?: CompilationStart;
+};
+export type PendingDevCompilation = {
+    stats: Rspack.Stats | Rspack.MultiStats;
+    changes: DevGraphChanges;
+    identity: DevGraphIdentity;
+    webCompilation: Rspack.Compilation;
+    nodeCompilation: Rspack.Compilation;
+};
+export type CompilationStart = {
+    status: 'pending';
+} | {
+    status: 'started';
+    identity: DevCompilationIdentity;
+};
+export declare const isLatestStartedCompilation: (identity: DevCompilationIdentity | undefined, start: CompilationStart | undefined) => boolean;
+export declare const hasPendingCompilation: (pair: DevCompilerPair) => boolean;
+export type CompilationIdentityTracker = {
+    getCompilationIdentity(compilation: Rspack.Compilation): DevCompilationIdentity;
+    getWebIdentityForNodeCompilation(compilation: Rspack.Compilation): DevCompilationIdentity | undefined;
+    setWebIdentityForNodeCompilation(compilation: Rspack.Compilation, identity: DevCompilationIdentity): void;
+};
+export declare const createCompilationIdentityTracker: () => CompilationIdentityTracker;

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

@@ -0,0 +1,14 @@
+import type { RsbuildPluginAPI, Rspack } from '@rsbuild/core';
+import type { ServerBuild } from 'react-router';
+import { type ReactRouterDevBuildPlan, type ReactRouterDevManifestSet } from './dev-runtime-artifacts.js';
+export type ReactRouterDevRuntimeController = {
+    captureWeb: (compilation: Rspack.Compilation, manifestsByEntryName: ReactRouterDevManifestSet) => void;
+    createBuildLoader: (entryName?: string) => () => Promise<ServerBuild>;
+};
+type CreateControllerOptions = {
+    api: RsbuildPluginAPI;
+    isBuild: boolean;
+    buildPlan: ReactRouterDevBuildPlan;
+};
+export declare const createReactRouterDevRuntimeController: ({ api, isBuild, buildPlan, }: CreateControllerOptions) => ReactRouterDevRuntimeController;
+export {};

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

@@ -0,0 +1,34 @@
+import type { RsbuildDevServer } from '@rsbuild/core';
+import type { ReactRouterDevRuntime } from './dev-generation.js';
+import type { DevCompilerPair } from './dev-runtime-compilation.js';
+export type RuntimeBinding = {
+    id: number;
+    server: RsbuildDevServer;
+    runtime: ReactRouterDevRuntime;
+    compilers?: DevCompilerPair;
+};
+export type ControllerState = {
+    status: 'idle';
+} | {
+    status: 'active';
+    binding: RuntimeBinding;
+} | {
+    status: 'closing';
+    binding: RuntimeBinding;
+} | {
+    status: 'terminal';
+    error: Error;
+};
+type CloseBinding = (binding: RuntimeBinding, error?: Error) => void;
+export type DevRuntimeSessionManager = {
+    getState(): ControllerState;
+    getActiveBinding(): RuntimeBinding | undefined;
+    observeClose(server: RsbuildDevServer): void;
+    assertCanStart(): void;
+    createBinding(server: RsbuildDevServer, runtime: ReactRouterDevRuntime): RuntimeBinding;
+    bindCloseObservation(binding: RuntimeBinding): void;
+    markClosing(binding: RuntimeBinding): void;
+    terminate(binding: RuntimeBinding, error: Error): void;
+};
+export declare const createDevRuntimeSessionManager: (closeBinding: CloseBinding) => DevRuntimeSessionManager;
+export {};

package/dist/dev-server.d.ts

@@ -1,3 +1,12 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
-export type DevServerMiddleware = (req: IncomingMessage, res: ServerResponse, next: (err?: any) => void) => Promise<void>;
-export declare const createDevServerMiddleware: (server: any) => DevServerMiddleware;
+import type { ServerBuild } from 'react-router';
+export type DevServerMiddleware = (req: IncomingMessage, res: ServerResponse, next: (err?: unknown) => void) => Promise<void>;
+type RequestHandler = (request: Request) => Response | Promise<Response>;
+type BuildProvider = () => Promise<ServerBuild>;
+export type DevServerMiddlewareDependencies = {
+    loadBuild: BuildProvider;
+    createRequestHandler?: (build: BuildProvider, mode: 'development') => RequestHandler;
+    createRequestListener?: (handler: RequestHandler) => (req: IncomingMessage, res: ServerResponse) => void | Promise<void>;
+};
+export declare const createDevServerMiddleware: (dependencies: DevServerMiddlewareDependencies) => DevServerMiddleware;
+export {};

package/dist/export-utils.d.ts

@@ -1,7 +1,15 @@
-export declare const transformToEsm: (code: string, resourcePath: string) => Promise<string>;
-export declare const getExportNames: (code: string) => Promise<string[]>;
-export declare const getExportNamesAndExportAll: (code: string) => Promise<{
-    exportNames: string[];
-    exportAllModules: string[];
-}>;
-export declare const getRouteModuleExports: (resourcePath: string) => Promise<string[]>;
+import { type ProgramNode } from './route-ast.js';
+type ExportInfo = {
+    readonly exportNames: readonly string[];
+    readonly exportAllModules: readonly string[];
+};
+type RouteModuleAnalysis = {
+    readonly code: string;
+    readonly exports: readonly string[];
+    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 getRouteModuleAnalysis: (resourcePath: string) => Promise<RouteModuleAnalysis>;
+export {};