rsbuild-plugin-react-router 0.4.1 → 0.5.0

package/src/route-module-transform-loader.ts

@@ -0,0 +1,149 @@
+import { threadId } from 'node:worker_threads';
+import remapping, { type SourceMapInput } from '@jridgewell/remapping';
+import type { LoaderDefinition } from '@rspack/core';
+import { createReactRouterPerformanceProfiler } from './performance.js';
+import { executeRouteTransformTask } from './route-transform-tasks.js';
+
+export type RouteModuleTransformLoaderOptions = {
+  environmentName: string;
+  performanceScopeId: string;
+  logPerformance: boolean;
+  ssr: boolean;
+  isBuild: boolean;
+  isSpaMode: boolean;
+  rootRoutePath: string | null;
+  devHmr: boolean;
+};
+
+type LoaderContextWithSourceMap = ThisParameterType<
+  LoaderDefinition<RouteModuleTransformLoaderOptions>
+> & {
+  sourceMap?: boolean;
+};
+type LoaderInputSourceMap = Parameters<
+  LoaderDefinition<RouteModuleTransformLoaderOptions>
+>[1];
+type RawLoaderSourceMap = Exclude<LoaderInputSourceMap, string | undefined>;
+
+const LOADER_PERFORMANCE_FLUSH_DELAY_MS = 50;
+const performanceWorkerId = `process-${process.pid}:thread-${threadId}`;
+
+const composeSourceMaps = (
+  generatedMap: SourceMapInput,
+  inputSourceMap: SourceMapInput
+): RawLoaderSourceMap =>
+  JSON.parse(
+    remapping([generatedMap, inputSourceMap], () => null).toString()
+  ) as RawLoaderSourceMap;
+
+const performanceProfilersByScope = new Map<
+  string,
+  Map<string, ReturnType<typeof createReactRouterPerformanceProfiler>>
+>();
+let performanceFlushTimer: ReturnType<typeof setTimeout> | undefined;
+
+const getPerformanceProfiler = (
+  scopeId: string,
+  environment: string | undefined
+): ReturnType<typeof createReactRouterPerformanceProfiler> => {
+  let profilers = performanceProfilersByScope.get(scopeId);
+  if (!profilers) {
+    profilers = new Map();
+    performanceProfilersByScope.set(scopeId, profilers);
+  }
+  const environmentKey = environment ?? 'unknown';
+  let profiler = profilers.get(environmentKey);
+  if (!profiler) {
+    profiler = createReactRouterPerformanceProfiler({
+      enabled: true,
+      log: message => console.info(message),
+    });
+    profilers.set(environmentKey, profiler);
+  }
+  return profiler;
+};
+
+export const flushRouteModuleTransformLoaderPerformance = (): void => {
+  if (performanceFlushTimer) {
+    clearTimeout(performanceFlushTimer);
+    performanceFlushTimer = undefined;
+  }
+
+  for (const profilers of performanceProfilersByScope.values()) {
+    for (const [environment, profiler] of profilers) {
+      profiler.flush(environment === 'unknown' ? undefined : environment, {
+        partial: true,
+        workerId: performanceWorkerId,
+      });
+    }
+  }
+  performanceProfilersByScope.clear();
+};
+
+const schedulePerformanceFlush = (): void => {
+  if (performanceFlushTimer) {
+    clearTimeout(performanceFlushTimer);
+  }
+  performanceFlushTimer = setTimeout(
+    flushRouteModuleTransformLoaderPerformance,
+    LOADER_PERFORMANCE_FLUSH_DELAY_MS
+  );
+};
+
+process.once('beforeExit', flushRouteModuleTransformLoaderPerformance);
+
+const routeModuleTransformLoader: LoaderDefinition<RouteModuleTransformLoaderOptions> =
+  async function routeModuleTransformLoader(
+    this: LoaderContextWithSourceMap,
+    source,
+    inputSourceMap
+  ) {
+    const callback = this.async();
+    const options = this.getOptions();
+
+    const transform = () =>
+      executeRouteTransformTask({
+        kind: 'routeModule',
+        code: String(source),
+        resource: this.resource,
+        resourcePath: this.resourcePath,
+        environmentName: options.environmentName,
+        sourceMaps: Boolean(this.sourceMap),
+        ssr: options.ssr,
+        isBuild: options.isBuild,
+        isSpaMode: options.isSpaMode,
+        rootRoutePath: options.rootRoutePath,
+        devHmr: options.devHmr,
+      });
+
+    try {
+      const result = options.logPerformance
+        ? await getPerformanceProfiler(
+            options.performanceScopeId,
+            options.environmentName
+          ).record(
+            options.environmentName,
+            'route:module',
+            this.resource,
+            transform
+          )
+        : await transform();
+
+      const outputSourceMap =
+        result.map && inputSourceMap
+          ? composeSourceMaps(
+              result.map as SourceMapInput,
+              inputSourceMap as SourceMapInput
+            )
+          : result.map;
+      callback(null, result.code, outputSourceMap ?? undefined);
+    } catch (error) {
+      callback(error instanceof Error ? error : new Error(String(error)));
+    } finally {
+      if (options.logPerformance) {
+        schedulePerformanceFlush();
+      }
+    }
+  };
+
+export default routeModuleTransformLoader;

package/src/route-module-transform-rules.ts

@@ -0,0 +1,115 @@
+import { fileURLToPath } from 'node:url';
+import type { Rspack } from '@rsbuild/core';
+import type { RouteModuleTransformLoaderOptions } from './route-module-transform-loader.js';
+import type { PluginOptions, Route } from './types.js';
+
+const routeModuleTransformLoaderPath = fileURLToPath(
+  new URL('./route-module-transform-loader.js', import.meta.url)
+);
+
+const getRouteModuleTransformParallel = (
+  parallelRouteTransform: PluginOptions['parallelRouteTransform']
+): Rspack.RuleSetLoaderWithOptions['parallel'] => {
+  if (
+    parallelRouteTransform === undefined ||
+    parallelRouteTransform === false
+  ) {
+    return undefined;
+  }
+  if (parallelRouteTransform === true) {
+    return true;
+  }
+  if (typeof parallelRouteTransform === 'number') {
+    if (
+      !Number.isInteger(parallelRouteTransform) ||
+      parallelRouteTransform < 1
+    ) {
+      throw new Error(
+        '[react-router] parallelRouteTransform must be true, false, or a positive integer.'
+      );
+    }
+    return { maxWorkers: parallelRouteTransform };
+  }
+  throw new Error(
+    '[react-router] parallelRouteTransform must be true, false, or a positive integer.'
+  );
+};
+
+export const shouldUseRouteModuleTransformLoader = (
+  parallelRouteTransform: PluginOptions['parallelRouteTransform']
+): boolean =>
+  getRouteModuleTransformParallel(parallelRouteTransform) !== undefined;
+
+const createRouteModuleTransformUse = (
+  options: RouteModuleTransformLoaderOptions,
+  parallelRouteTransform: PluginOptions['parallelRouteTransform']
+): Rspack.RuleSetLoaderWithOptions => {
+  const parallel = getRouteModuleTransformParallel(parallelRouteTransform);
+  return {
+    loader: routeModuleTransformLoaderPath,
+    options,
+    ...(parallel ? { parallel } : {}),
+  };
+};
+
+export const registerRouteModuleTransformRules = (
+  rspackConfig: Rspack.Configuration,
+  {
+    environmentName,
+    ssr,
+    isBuild,
+    isSpaMode,
+    rootRoutePath,
+    devHmr,
+    logPerformance,
+    routeByFilePath,
+    parallelRouteTransform,
+  }: {
+    environmentName: string;
+    ssr: boolean;
+    isBuild: boolean;
+    isSpaMode: boolean;
+    rootRoutePath: string | null;
+    devHmr: boolean;
+    logPerformance: boolean;
+    routeByFilePath: Map<string, Route>;
+    parallelRouteTransform: PluginOptions['parallelRouteTransform'];
+  }
+): void => {
+  const routeModuleTransformUse = createRouteModuleTransformUse(
+    {
+      environmentName,
+      performanceScopeId: [
+        environmentName,
+        isBuild ? 'build' : 'dev',
+        ssr ? 'ssr' : 'spa',
+        rootRoutePath ?? 'rootless',
+      ].join(':'),
+      logPerformance,
+      ssr,
+      isBuild,
+      isSpaMode,
+      rootRoutePath,
+      devHmr,
+    },
+    parallelRouteTransform
+  );
+
+  rspackConfig.module ??= {};
+  rspackConfig.module.rules ??= [];
+  rspackConfig.module.rules.push(
+    {
+      resourceQuery: /\?react-router-route/,
+      enforce: 'post',
+      use: [routeModuleTransformUse],
+    },
+    {
+      test: path => routeByFilePath.has(path),
+      resourceQuery: {
+        not: /__react-router-build-client-route|react-router-route|route-chunk=/,
+      },
+      enforce: 'post',
+      use: [routeModuleTransformUse],
+    }
+  );
+};

package/src/route-transform-tasks.ts

@@ -24,10 +24,7 @@ import {
   type RouteChunkCache,
   type RouteChunkConfig,
 } from './route-chunks.js';
-import {
-  getProgram,
-  type AnyNode,
-} from './route-ast.js';
+import { getProgram, type AnyNode } from './route-ast.js';
 
 export type RouteTransformResult = {
   code: string;
@@ -88,6 +85,10 @@ export type RouteTransformTaskOptions = {
   routeChunkCache?: RouteChunkCache;
 };
 
+export type RouteTransformRunner = (
+  task: RouteTransformTask
+) => Promise<RouteTransformResult>;
+
 const defaultRouteChunkCache: RouteChunkCache = new Map();
 
 const getRouteChunkCache = (options?: RouteTransformTaskOptions) =>

package/src/types.ts

@@ -57,11 +57,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;
 

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);
-    }
-  }
-);