rsbuild-plugin-react-router 0.4.1 → 0.6.0

package/src/types.ts

@@ -1,4 +1,4 @@
-import type { RsbuildConfig } from '@rsbuild/core';
+import type { RsbuildConfig, Rspack } from '@rsbuild/core';
 
 export type Route = {
   id: string;
@@ -30,6 +30,23 @@ export type PluginOptions = {
    */
   federation?: boolean;
 
+  /**
+   * Enable experimental React Router RSC framework mode.
+   * This composes `rsbuild-plugin-rsc` with React Router's Rsbuild
+   * environments. Environment names are managed by this plugin.
+   * Requires `react-router >=7.18.0 || >=8.0.0`, `rsbuild-plugin-rsc`,
+   * and `react-server-dom-rspack`.
+   * @default false
+   */
+  rsc?:
+    | boolean
+    | {
+        layers?: {
+          rsc?: Rspack.RuleSetCondition;
+          ssr?: Rspack.RuleSetCondition;
+        };
+      };
+
   /**
    * Rsbuild dev-only lazy compilation behavior.
    *
@@ -57,11 +74,10 @@ export type PluginOptions = {
   logPerformance?: boolean;
 
   /**
-   * Run route transforms in a worker-thread pool.
-   * Pass `true` to force the default worker count, a positive integer to set
-   * the worker count, or `false` to disable.
-   * @default Automatically enabled for 256+ resolved routes. The automatic
-   * pool uses available CPU cores minus 2.
+   * Run route module transforms with Rspack's parallel loader workers.
+   * Pass `true` to use Rspack's default worker count, a positive integer to set
+   * the maximum worker count, or `false` to disable.
+   * @default false
    */
   parallelRouteTransform?: boolean | number;
 
@@ -74,6 +90,27 @@ export type PluginOptions = {
   onRouteTopologyChange?: () => void | Promise<void>;
 };
 
+export type ReactRouterRSCPluginOptions = Omit<PluginOptions, 'rsc'> & {
+  /**
+   * Optional overrides forwarded to `rsbuild-plugin-rsc`.
+   * Environment names are managed by this plugin.
+   */
+  rsc?: Exclude<NonNullable<PluginOptions['rsc']>, boolean>;
+};
+
+export type PrerenderPathsConfig =
+  | boolean
+  | string[]
+  | ((args: {
+      getStaticPaths: () => string[];
+    }) => boolean | string[] | Promise<boolean | string[]>);
+
+export type PrerenderConfigObject = {
+  paths: PrerenderPathsConfig;
+  concurrency?: number;
+  unstable_concurrency?: number;
+};
+
 export type RouteManifestItem = Omit<Route, 'file' | 'children'> & {
   module: string;
   clientActionModule?: string;

package/src/warnings/warn-on-client-source-maps.ts

@@ -13,10 +13,8 @@ export function isSourceMapEnabled(value: unknown): boolean {
   // Rsbuild normalizes `output.sourceMap` into either:
   //  - boolean
   //  - { js?: devtool; css: boolean }
-  if (value === true) return true;
-  if (value === false || value == null) return false;
-  if (typeof value === 'string') return true;
-  if (typeof value === 'object') {
+  if (value === true || typeof value === 'string') return true;
+  if (value !== null && typeof value === 'object') {
     const js = (value as SourceMapConfigObject).js;
     // Any truthy devtool string/object means source maps are on for JS.
     return Boolean(js);
@@ -26,12 +24,11 @@ export function isSourceMapEnabled(value: unknown): boolean {
 
 function isDevtoolSourceMap(value: unknown): boolean {
   if (value === true) return true;
-  if (value == null || value === false) return false;
   if (typeof value === 'string') {
     return value.includes('source-map');
   }
   // Unknown object shape - treat as enabled to be safe.
-  return typeof value === 'object';
+  return value !== null && typeof value === 'object';
 }
 
 export function getClientSourceMapSetting(
@@ -58,10 +55,9 @@ export function getClientDevtoolSetting(
 }
 
 function getDevtoolFromRspackConfig(config?: ToolsRspackConfig): unknown {
-  if (!config) return undefined;
-  if (typeof config === 'function') return undefined;
-  if (typeof config !== 'object') return undefined;
-  return (config as { devtool?: unknown }).devtool;
+  return config !== null && typeof config === 'object'
+    ? (config as { devtool?: unknown }).devtool
+    : undefined;
 }
 
 export function warnOnClientSourceMaps(

package/dist/parallel-route-transform-protocol.d.ts

@@ -1,25 +0,0 @@
-import type { RouteTransformResult, RouteTransformTask } from './route-transform-tasks.js';
-type WithoutRequiredSource<Task> = Task extends RouteTransformTask ? Omit<Task, 'code'> & {
-    code?: string;
-} : never;
-export type CachedRouteTransformTask = WithoutRequiredSource<RouteTransformTask>;
-export type WorkerRequest = {
-    id: number;
-    task: RouteTransformTask | CachedRouteTransformTask;
-    sourceCacheKey?: string;
-};
-export type WorkerErrorPayload = {
-    name?: string;
-    message: string;
-    stack?: string;
-};
-export type WorkerResponse = {
-    id: number;
-    ok: true;
-    result: RouteTransformResult;
-} | {
-    id: number;
-    ok: false;
-    error: WorkerErrorPayload;
-};
-export {};

package/dist/parallel-route-transform-worker.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/parallel-route-transform-worker.js

@@ -1,38 +0,0 @@
-import { parentPort } from "node:worker_threads";
-import { setBoundedCacheEntry, executeRouteTransformTask } from "./451.js";
-if (!parentPort) throw Error('parallel route transform worker requires parentPort');
-let sourceCache = new Map();
-parentPort.on('message', async ({ id, task, sourceCacheKey })=>{
-    try {
-        let hydratedTask = (({ task, sourceCacheKey })=>{
-            if (!sourceCacheKey) return task;
-            if ('string' == typeof task.code) return setBoundedCacheEntry(sourceCache, sourceCacheKey, task.code, 2048), task;
-            let code = sourceCache.get(sourceCacheKey);
-            if (void 0 === code) throw Error(`Missing cached route transform source for ${sourceCacheKey}.`);
-            return {
-                ...task,
-                code
-            };
-        })({
-            task,
-            sourceCacheKey
-        }), result = await executeRouteTransformTask(hydratedTask);
-        parentPort?.postMessage({
-            id,
-            ok: !0,
-            result
-        });
-    } catch (error) {
-        parentPort?.postMessage({
-            id,
-            ok: !1,
-            error: error instanceof Error ? {
-                name: error.name,
-                message: error.message,
-                stack: error.stack
-            } : {
-                message: String(error)
-            }
-        });
-    }
-});

package/dist/parallel-route-transforms.d.ts

@@ -1,29 +0,0 @@
-import { type RouteTransformResult, type RouteTransformTask, type RouteTransformTaskOptions } from './route-transform-tasks.js';
-import type { PluginOptions } from './types.js';
-import type { WorkerRequest, WorkerResponse } from './parallel-route-transform-protocol.js';
-export type ParallelRouteTransformConfig = NonNullable<PluginOptions['parallelRouteTransform']> extends infer Config ? Exclude<Config, false> : never;
-export type RouteTransformExecutorOptions = RouteTransformTaskOptions & {
-    parallelRouteTransform?: PluginOptions['parallelRouteTransform'];
-    splitRouteModules?: boolean;
-    isBuild?: boolean;
-};
-export type RouteTransformExecutor = {
-    run: (task: RouteTransformTask) => Promise<RouteTransformResult>;
-    prewarm: () => void;
-    close: () => Promise<void>;
-};
-type RouteTransformWorker = {
-    on(event: 'message', handler: (response: WorkerResponse) => void): unknown;
-    on(event: 'error', handler: (error: Error) => void): unknown;
-    on(event: 'exit', handler: (code: number) => void): unknown;
-    postMessage(message: WorkerRequest): void;
-    terminate(): Promise<number> | number;
-};
-type RouteTransformWorkerFactory = () => RouteTransformWorker;
-export declare const getDefaultWorkerCount: (cpuCount?: number, { isBuild }?: {
-    isBuild?: boolean;
-}) => number;
-export declare const shouldParallelizeRouteTransforms: (routeCount: number) => boolean;
-export declare const createRouteTransformExecutor: ({ parallelRouteTransform, routeChunkCache, splitRouteModules, isBuild, }?: RouteTransformExecutorOptions) => RouteTransformExecutor;
-export declare const createRouteTransformExecutorForTesting: (options: RouteTransformExecutorOptions, createWorker: RouteTransformWorkerFactory) => RouteTransformExecutor;
-export {};

package/src/parallel-route-transform-protocol.ts

@@ -1,35 +0,0 @@
-import type {
-  RouteTransformResult,
-  RouteTransformTask,
-} from './route-transform-tasks.js';
-
-type WithoutRequiredSource<Task> = Task extends RouteTransformTask
-  ? Omit<Task, 'code'> & { code?: string }
-  : never;
-
-export type CachedRouteTransformTask =
-  WithoutRequiredSource<RouteTransformTask>;
-
-export type WorkerRequest = {
-  id: number;
-  task: RouteTransformTask | CachedRouteTransformTask;
-  sourceCacheKey?: string;
-};
-
-export type WorkerErrorPayload = {
-  name?: string;
-  message: string;
-  stack?: string;
-};
-
-export type WorkerResponse =
-  | {
-      id: number;
-      ok: true;
-      result: RouteTransformResult;
-    }
-  | {
-      id: number;
-      ok: false;
-      error: WorkerErrorPayload;
-    };

package/src/parallel-route-transform-worker.ts

@@ -1,82 +0,0 @@
-import { parentPort } from 'node:worker_threads';
-import { setBoundedCacheEntry } from './bounded-cache.js';
-import {
-  executeRouteTransformTask,
-  type RouteTransformTask,
-} from './route-transform-tasks.js';
-import type {
-  WorkerErrorPayload,
-  WorkerRequest,
-  WorkerResponse,
-} from './parallel-route-transform-protocol.js';
-
-const serializeError = (error: unknown): WorkerErrorPayload => {
-  if (error instanceof Error) {
-    return {
-      name: error.name,
-      message: error.message,
-      stack: error.stack,
-    };
-  }
-  return {
-    message: String(error),
-  };
-};
-
-if (!parentPort) {
-  throw new Error('parallel route transform worker requires parentPort');
-}
-
-const MAX_SOURCE_CACHE_ENTRIES = 2048;
-const sourceCache = new Map<string, string>();
-
-const hydrateTaskSource = ({
-  task,
-  sourceCacheKey,
-}: Pick<WorkerRequest, 'task' | 'sourceCacheKey'>): RouteTransformTask => {
-  if (!sourceCacheKey) {
-    return task as RouteTransformTask;
-  }
-
-  if (typeof task.code === 'string') {
-    setBoundedCacheEntry(
-      sourceCache,
-      sourceCacheKey,
-      task.code,
-      MAX_SOURCE_CACHE_ENTRIES
-    );
-    return task as RouteTransformTask;
-  }
-
-  const code = sourceCache.get(sourceCacheKey);
-  if (code === undefined) {
-    throw new Error(
-      `Missing cached route transform source for ${sourceCacheKey}.`
-    );
-  }
-  return {
-    ...task,
-    code,
-  } as RouteTransformTask;
-};
-
-parentPort.on(
-  'message',
-  async ({ id, task, sourceCacheKey }: WorkerRequest) => {
-    try {
-      const hydratedTask = hydrateTaskSource({ task, sourceCacheKey });
-      const result = await executeRouteTransformTask(hydratedTask);
-      parentPort?.postMessage({
-        id,
-        ok: true,
-        result,
-      } satisfies WorkerResponse);
-    } catch (error) {
-      parentPort?.postMessage({
-        id,
-        ok: false,
-        error: serializeError(error),
-      } satisfies WorkerResponse);
-    }
-  }
-);