rsbuild-plugin-react-router 0.3.0 → 0.3.1

package/src/react-router-config.ts

@@ -4,6 +4,9 @@ import type {
 } from '@react-router/dev/config';
 import type { NormalizedConfig } from '@rsbuild/core';
 import type { RouteConfigEntry } from '@react-router/dev/routes';
+import * as Effect from 'effect/Effect';
+import { getCappedPluginConcurrency } from './concurrency.js';
+import { runPluginEffect, tryPluginPromise } from './effect-runtime.js';
 
 export type BuildEndHook = {
   bivarianceHack(args: {
@@ -45,6 +48,12 @@ type RouteManifestEntry = {
 
 type RouteManifest = Record<string, RouteManifestEntry>;
 
+type ResolveReactRouterConfigResult = {
+  resolved: ResolvedReactRouterConfig;
+  presets: NonNullable<Config['presets']>;
+  hasConfiguredServerModuleFormat: boolean;
+};
+
 export type ResolvedReactRouterConfig = Readonly<{
   appDirectory: string;
   basename: string;
@@ -102,10 +111,15 @@ const mergeReactRouterConfig = (...configs: Config[]): Config => {
             buildEnd: async (
               ...args: Parameters<NonNullable<Config['buildEnd']>>
             ) => {
-              await Promise.all([
-                configA.buildEnd?.(...args),
-                configB.buildEnd?.(...args),
-              ]);
+              await runPluginEffect(
+                Effect.all(
+                  [
+                    tryPluginPromise(() => configA.buildEnd?.(...args)),
+                    tryPluginPromise(() => configB.buildEnd?.(...args)),
+                  ],
+                  { discard: true }
+                )
+              );
             },
           }
         : {}),
@@ -145,76 +159,87 @@ const normalizeSubResourceIntegrity = (config: Config): Config => {
   };
 };
 
-export const resolveReactRouterConfig = async (
+export const resolveReactRouterConfigEffect = (
   reactRouterUserConfig: Config
-): Promise<{
-  resolved: ResolvedReactRouterConfig;
-  presets: NonNullable<Config['presets']>;
-  hasConfiguredServerModuleFormat: boolean;
-}> => {
-  const presets = await Promise.all(
-    (reactRouterUserConfig.presets ?? []).map(async preset => {
-      if (!preset.name) {
-        throw new Error(
-          'React Router presets must have a `name` property defined.'
-        );
-      }
-      if (!preset.reactRouterConfig) {
-        return null;
-      }
-      const { buildEnd: _buildEnd, ...reactRouterUserConfigForPreset } =
-        reactRouterUserConfig;
-      const presetConfig = await preset.reactRouterConfig({
-        reactRouterUserConfig: reactRouterUserConfigForPreset,
-      });
-      if (!presetConfig) return null;
-      const { presets: _presets, ...rest } = presetConfig as Config;
-      return rest;
-    })
-  );
-
-  const userAndPresetConfigs = mergeReactRouterConfig(
-    ...(presets.filter(Boolean) as Config[]).map(normalizeSubResourceIntegrity),
-    normalizeSubResourceIntegrity(reactRouterUserConfig)
-  );
+): Effect.Effect<ResolveReactRouterConfigResult, Error, never> =>
+  Effect.gen(function* () {
+    const presets = yield* Effect.forEach(
+      reactRouterUserConfig.presets ?? [],
+      preset =>
+        Effect.gen(function* () {
+          if (!preset.name) {
+            return yield* Effect.fail(
+              new Error(
+                'React Router presets must have a `name` property defined.'
+              )
+            );
+          }
+          if (!preset.reactRouterConfig) {
+            return null;
+          }
+          const { buildEnd: _buildEnd, ...reactRouterUserConfigForPreset } =
+            reactRouterUserConfig;
+          const presetConfig = yield* tryPluginPromise(() =>
+            preset.reactRouterConfig?.({
+              reactRouterUserConfig: reactRouterUserConfigForPreset,
+            })
+          );
+          if (!presetConfig) return null;
+          const { presets: _presets, ...rest } = presetConfig as Config;
+          return rest;
+        }),
+      { concurrency: getCappedPluginConcurrency() }
+    );
+
+    const userAndPresetConfigs = mergeReactRouterConfig(
+      ...(presets.filter(Boolean) as Config[]).map(
+        normalizeSubResourceIntegrity
+      ),
+      normalizeSubResourceIntegrity(reactRouterUserConfig)
+    );
+
+    const subResourceIntegrity =
+      userAndPresetConfigs.subResourceIntegrity ??
+      userAndPresetConfigs.future?.unstable_subResourceIntegrity ??
+      DEFAULT_CONFIG.subResourceIntegrity;
+    const resolvedFuture: FutureConfig = {
+      ...DEFAULT_CONFIG.future,
+      ...(userAndPresetConfigs.future ?? {}),
+      unstable_subResourceIntegrity: subResourceIntegrity,
+    };
+    const splitRouteModules =
+      userAndPresetConfigs.splitRouteModules ??
+      userAndPresetConfigs.future?.v8_splitRouteModules ??
+      DEFAULT_CONFIG.splitRouteModules;
+
+    let resolved: ResolvedReactRouterConfig = {
+      ...DEFAULT_CONFIG,
+      ...userAndPresetConfigs,
+      future: resolvedFuture,
+      splitRouteModules,
+      subResourceIntegrity,
+      allowedActionOrigins:
+        userAndPresetConfigs.allowedActionOrigins ??
+        DEFAULT_CONFIG.allowedActionOrigins,
+      routes: DEFAULT_CONFIG.routes,
+      unstable_routeConfig: DEFAULT_CONFIG.unstable_routeConfig,
+    };
+    if (!resolved.ssr) {
+      resolved = {
+        ...resolved,
+        serverBundles: undefined,
+      };
+    }
 
-  const subResourceIntegrity =
-    userAndPresetConfigs.subResourceIntegrity ??
-    userAndPresetConfigs.future?.unstable_subResourceIntegrity ??
-    DEFAULT_CONFIG.subResourceIntegrity;
-  const resolvedFuture: FutureConfig = {
-    ...DEFAULT_CONFIG.future,
-    ...(userAndPresetConfigs.future ?? {}),
-    unstable_subResourceIntegrity: subResourceIntegrity,
-  };
-  const splitRouteModules =
-    userAndPresetConfigs.splitRouteModules ??
-    userAndPresetConfigs.future?.v8_splitRouteModules ??
-    DEFAULT_CONFIG.splitRouteModules;
-
-  let resolved: ResolvedReactRouterConfig = {
-    ...DEFAULT_CONFIG,
-    ...userAndPresetConfigs,
-    future: resolvedFuture,
-    splitRouteModules,
-    subResourceIntegrity,
-    allowedActionOrigins:
-      userAndPresetConfigs.allowedActionOrigins ??
-      DEFAULT_CONFIG.allowedActionOrigins,
-    routes: DEFAULT_CONFIG.routes,
-    unstable_routeConfig: DEFAULT_CONFIG.unstable_routeConfig,
-  };
-  if (!resolved.ssr) {
-    resolved = {
-      ...resolved,
-      serverBundles: undefined,
+    return {
+      resolved,
+      presets: reactRouterUserConfig.presets ?? [],
+      hasConfiguredServerModuleFormat:
+        userAndPresetConfigs.serverModuleFormat !== undefined,
     };
-  }
+  });
 
-  return {
-    resolved,
-    presets: reactRouterUserConfig.presets ?? [],
-    hasConfiguredServerModuleFormat:
-      userAndPresetConfigs.serverModuleFormat !== undefined,
-  };
-};
+export const resolveReactRouterConfig = (
+  reactRouterUserConfig: Config
+): Promise<ResolveReactRouterConfigResult> =>
+  runPluginEffect(resolveReactRouterConfigEffect(reactRouterUserConfig));

package/src/route-artifacts.ts

@@ -92,7 +92,7 @@ export const createRouteClientEntryArtifact = async ({
       )
     : null;
   const exportNames =
-    routeChunkInfo?.exportNames ?? (await getExportNames(code));
+    routeChunkInfo?.exportNames ?? (await getExportNames(code, resourcePath));
   const chunkedExports = routeChunkInfo?.chunkedExports ?? [];
   return {
     code: buildRouteClientEntryCode({
@@ -140,7 +140,7 @@ export const createRouteChunkArtifact = async ({
   );
 
   if (splitRouteModules === 'enforce' && chunkName === 'main' && chunk) {
-    const exportNames = await getExportNames(chunk);
+    const exportNames = await getExportNames(chunk, resourcePath);
     validateRouteChunks({
       config: routeChunkConfig,
       id: resourcePath,

package/src/route-export-resolution.ts

@@ -264,9 +264,9 @@ export type RouteModuleResolver = (
 export const createBundlerRouteExportResolver =
   (resolveModule: RouteModuleResolver): RouteExportResolver =>
   (specifier, importerPath) =>
-    new Promise<string | null>(resolveResolvedPath => {
+    new Promise<string | null>(resolvePromise => {
       resolveModule(dirname(importerPath), specifier, (error, resolved) => {
-        resolveResolvedPath(error || !resolved ? null : resolved);
+        resolvePromise(error || !resolved ? null : resolved);
       });
     });
 
@@ -276,7 +276,7 @@ export const collectClientOnlyStubExportNames = async (
   resolveModule: RouteExportResolver = resolveExportAllModule
 ): Promise<Set<string>> => {
   const { exportNames: directExportNames, exportAllModules } =
-    await getExportNamesAndExportAll(code);
+    await getExportNamesAndExportAll(code, resourcePath);
   const exportNames = new Set(directExportNames);
   const unresolvedExportAll = new Set<string>();
   const visitedModules = new Set<string>();

package/src/route-watch.ts

@@ -1,11 +1,20 @@
 import { watch, type FSWatcher } from 'node:fs';
 import { access, mkdir, readdir, writeFile } from 'node:fs/promises';
 import type { RsbuildConfig } from '@rsbuild/core';
+import * as Effect from 'effect/Effect';
 import { dirname, resolve } from 'pathe';
+import { getCappedPluginConcurrency } from './concurrency.js';
+import {
+  createDelayedPluginTask,
+  runPluginEffect,
+  tryPluginPromise,
+} from './effect-runtime.js';
 import type { Route } from './types.js';
 
 const ROUTE_RESTART_MARKER_ASSET = '.react-router/route-watch';
 const INITIAL_RESTART_MARKER_CONTENT = 'react-router-route-watch';
+const ROUTE_TOPOLOGY_RESCAN_DEBOUNCE_MS = 100;
+const ROUTE_DIRECTORY_SCAN_CONCURRENCY = getCappedPluginConcurrency();
 
 type RouteManifestSnapshotEntry = Pick<
   Route,
@@ -111,32 +120,32 @@ const areSetsEqual = <T>(left: Set<T>, right: Set<T>): boolean => {
   return true;
 };
 
-const readRouteDirectories = async (
+const readRouteDirectories = (watchDirectory: string): Promise<Set<string>> => {
+  return runPluginEffect(readRouteDirectoriesEffect(watchDirectory));
+};
+
+const readRouteDirectoriesEffect = (
   watchDirectory: string
-): Promise<Set<string>> => {
+): Effect.Effect<Set<string>, Error, never> => {
   const directories = new Set<string>();
-
-  const walkDirectory = async (directory: string): Promise<void> => {
-    let entries;
-    try {
-      entries = await readdir(directory, { withFileTypes: true });
-    } catch {
-      return;
-    }
-
-    directories.add(directory);
-    await Promise.all(
-      entries.map(async entry => {
-        const entryPath = resolve(directory, entry.name);
-        if (entry.isDirectory()) {
-          await walkDirectory(entryPath);
-        }
-      })
+  const walkDirectory = (directory: string): Effect.Effect<void> =>
+    tryPluginPromise(() => readdir(directory, { withFileTypes: true })).pipe(
+      Effect.catchAll(() => Effect.succeed([])),
+      Effect.map(entries => {
+        directories.add(directory);
+        return entries
+          .filter(entry => entry.isDirectory())
+          .map(entry => resolve(directory, entry.name));
+      }),
+      Effect.flatMap(childDirectories =>
+        Effect.forEach(childDirectories, walkDirectory, {
+          concurrency: ROUTE_DIRECTORY_SCAN_CONCURRENCY,
+          discard: true,
+        })
+      )
     );
-  };
 
-  await walkDirectory(watchDirectory);
-  return directories;
+  return walkDirectory(watchDirectory).pipe(Effect.as(directories));
 };
 
 export const createRouteTopologyWatcher = async ({
@@ -178,14 +187,17 @@ export const createRouteTopologyWatcher = async ({
     routeTopology: initialRouteTopology ?? discoveredState.routeTopology,
   };
   let closed = false;
-  let rescanTimer: ReturnType<typeof setTimeout> | undefined;
   let rescanQueue = Promise.resolve();
   const directoryWatchers = new Map<string, DirectoryWatcher>();
 
-  const touchRestartMarker = async (): Promise<void> => {
-    await mkdir(dirname(restartMarkerPath), { recursive: true });
-    await writeFile(restartMarkerPath, String(Date.now()));
-  };
+  const touchRestartMarkerEffect = (): Effect.Effect<void, Error, never> =>
+    tryPluginPromise(() =>
+      mkdir(dirname(restartMarkerPath), { recursive: true })
+    ).pipe(
+      Effect.zipRight(
+        tryPluginPromise(() => writeFile(restartMarkerPath, String(Date.now())))
+      )
+    );
 
   const closeRemovedDirectoryWatchers = (
     nextDirectories: Set<string>
@@ -205,13 +217,17 @@ export const createRouteTopologyWatcher = async ({
       }
       try {
         let watcher: DirectoryWatcher;
-        watcher = watchDirectoryOverride(directory, scheduleRescan, error => {
-          if (directoryWatchers.get(directory) === watcher) {
-            watcher.close();
-            directoryWatchers.delete(directory);
+        watcher = watchDirectoryOverride(
+          directory,
+          () => rescanTask.reschedule(),
+          error => {
+            if (directoryWatchers.get(directory) === watcher) {
+              watcher.close();
+              directoryWatchers.delete(directory);
+            }
+            onError(error);
           }
-          onError(error);
-        });
+        );
         directoryWatchers.set(directory, watcher);
       } catch (error) {
         onError(error);
@@ -224,74 +240,94 @@ export const createRouteTopologyWatcher = async ({
     watchNewDirectories(nextDirectories);
   };
 
-  const applyNextState = async (nextState: RouteDirectoryState) => {
-    if (closed) {
-      return;
-    }
-    syncDirectoryWatchers(nextState.directories);
-    if (!areSetsEqual(state.routeTopology, nextState.routeTopology)) {
-      if (onRouteTopologyChange) {
-        // This is a notification boundary, not part of the rescan
-        // transaction. A custom-server callback may close this watcher while
-        // replacing its compiler, so awaiting it here would deadlock close().
-        state = nextState;
-        try {
-          void Promise.resolve(onRouteTopologyChange()).catch(onError);
-        } catch (error) {
-          onError(error);
-        }
-        return;
-      } else {
-        await touchRestartMarker();
-      }
+  const applyNextStateEffect = (
+    nextState: RouteDirectoryState
+  ): Effect.Effect<void, Error, never> =>
+    Effect.suspend(() => {
       if (closed) {
-        return;
+        return Effect.void;
+      }
+      syncDirectoryWatchers(nextState.directories);
+      if (!areSetsEqual(state.routeTopology, nextState.routeTopology)) {
+        if (onRouteTopologyChange) {
+          // This is a notification boundary, not part of the rescan
+          // transaction. A custom-server callback may close this watcher while
+          // replacing its compiler, so awaiting it here would deadlock close().
+          state = nextState;
+          return Effect.sync(() => {
+            try {
+              void Promise.resolve(onRouteTopologyChange()).catch(onError);
+            } catch (error) {
+              onError(error);
+            }
+          });
+        }
+        return touchRestartMarkerEffect().pipe(
+          Effect.zipRight(
+            Effect.sync(() => {
+              if (!closed) {
+                state = nextState;
+              }
+            })
+          )
+        );
       }
       state = nextState;
-      return;
-    }
-    state = nextState;
-  };
+      return Effect.void;
+    });
 
-  const runRescan = async (): Promise<void> => {
-    if (closed) {
-      return;
-    }
+  const runRescanEffect = (): Effect.Effect<void, never, never> => {
     let nextDirectories: Set<string> | undefined;
-    try {
-      nextDirectories = await readRouteDirectories(watchDirectory);
+    return Effect.gen(function* () {
+      if (closed) {
+        return;
+      }
+      nextDirectories = yield* readRouteDirectoriesEffect(watchDirectory);
       if (closed) {
         return;
       }
       const nextState = {
         directories: nextDirectories,
-        routeTopology: await getRouteTopology(),
+        routeTopology: yield* tryPluginPromise(getRouteTopology),
       };
       if (closed) {
         return;
       }
-      await applyNextState(nextState);
-    } catch (error) {
-      if (nextDirectories && !closed) {
-        syncDirectoryWatchers(nextDirectories);
-      }
-      onError(error);
-    }
+      yield* applyNextStateEffect(nextState);
+    }).pipe(
+      Effect.catchAll(error =>
+        Effect.sync(() => {
+          if (nextDirectories && !closed) {
+            syncDirectoryWatchers(nextDirectories);
+          }
+          onError(error);
+        })
+      )
+    );
   };
 
   const rescan = (): Promise<void> => {
-    rescanQueue = rescanQueue.then(runRescan, runRescan);
+    rescanQueue = rescanQueue.then(
+      () => runPluginEffect(runRescanEffect()),
+      () => runPluginEffect(runRescanEffect())
+    );
     return rescanQueue;
   };
 
-  const scheduleRescan = (): void => {
-    if (rescanTimer) {
-      clearTimeout(rescanTimer);
-    }
-    rescanTimer = setTimeout(() => {
-      rescanTimer = undefined;
-      void rescan();
-    }, 100);
+  const rescanTask = createDelayedPluginTask({
+    delayMs: ROUTE_TOPOLOGY_RESCAN_DEBOUNCE_MS,
+    run: () =>
+      Effect.suspend(() =>
+        closed ? Effect.void : tryPluginPromise(rescan).pipe(Effect.asVoid)
+      ),
+    onError,
+  });
+
+  const cancelScheduledRescan = (): Promise<void> =>
+    runPluginEffect(rescanTask.cancelEffect());
+
+  const applyNextState = async (nextState: RouteDirectoryState) => {
+    await runPluginEffect(applyNextStateEffect(nextState));
   };
 
   try {
@@ -302,13 +338,12 @@ export const createRouteTopologyWatcher = async ({
 
   return async () => {
     if (closed) {
+      await cancelScheduledRescan();
       await rescanQueue;
       return;
     }
     closed = true;
-    if (rescanTimer) {
-      clearTimeout(rescanTimer);
-    }
+    await cancelScheduledRescan();
     for (const watcher of directoryWatchers.values()) {
       watcher.close();
     }

package/src/server-build-resolution.ts

@@ -0,0 +1,131 @@
+// Internal module: exposes the Effect-based ServerBuild resolution used by
+// dev-runtime code. Not re-exported from the package entry so the public
+// declaration graph stays free of `effect` types; external callers go through
+// the Promise wrappers in server-utils.ts.
+import * as Effect from 'effect/Effect';
+import type { ServerBuild } from 'react-router';
+import { tryPluginPromise, tryPluginSync } from './effect-runtime.js';
+
+const RESOLVABLE_BUILD_EXPORTS = new Set([
+  'allowedActionOrigins',
+  'assets',
+  'assetsBuildDirectory',
+  'basename',
+  'entry',
+  'future',
+  'isSpaMode',
+  'prerender',
+  'publicPath',
+  'routeDiscovery',
+  'routes',
+  'ssr',
+]);
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function isPromiseLike(value: unknown): value is PromiseLike<unknown> {
+  return isRecord(value) && typeof value.then === 'function';
+}
+
+function isRouteDiscovery(value: unknown): boolean {
+  return (
+    value === undefined ||
+    (isRecord(value) &&
+      (value.mode === 'initial' ||
+        (value.mode === 'lazy' &&
+          (value.manifestPath === undefined ||
+            typeof value.manifestPath === 'string'))))
+  );
+}
+
+function resolveBuildExportsEffect(
+  build: Record<string, unknown>
+): Effect.Effect<Record<string, unknown>, Error, never> {
+  const resolved = { ...build };
+  return Effect.forEach(
+    Object.keys(build),
+    key =>
+      Effect.gen(function* () {
+        if (!RESOLVABLE_BUILD_EXPORTS.has(key)) {
+          return;
+        }
+        const value = build[key];
+        if (typeof value === 'function' && value.length === 0) {
+          const result = yield* tryPluginSync(() => value());
+          resolved[key] = isPromiseLike(result)
+            ? yield* tryPluginPromise(() => result)
+            : result;
+          return;
+        }
+        if (isPromiseLike(value)) {
+          resolved[key] = yield* tryPluginPromise(() => value);
+        }
+      }),
+    { discard: true }
+  ).pipe(Effect.as(resolved));
+}
+
+function isServerBuild(value: unknown): value is ServerBuild {
+  return Boolean(
+    isRecord(value) &&
+    isRecord(value.entry) &&
+    isRecord(value.entry.module) &&
+    typeof value.entry.module.default === 'function' &&
+    isRecord(value.routes) &&
+    isRecord(value.assets) &&
+    typeof value.assetsBuildDirectory === 'string' &&
+    (value.basename === undefined || typeof value.basename === 'string') &&
+    isRecord(value.future) &&
+    typeof value.isSpaMode === 'boolean' &&
+    Array.isArray(value.prerender) &&
+    typeof value.publicPath === 'string' &&
+    isRouteDiscovery(value.routeDiscovery) &&
+    typeof value.ssr === 'boolean'
+  );
+}
+
+function resolveServerBuildCandidateEffect(
+  candidate: unknown
+): Effect.Effect<ServerBuild | undefined, Error, never> {
+  if (!isRecord(candidate)) {
+    return Effect.succeed(undefined);
+  }
+  return resolveBuildExportsEffect(candidate).pipe(
+    Effect.map(resolved => (isServerBuild(resolved) ? resolved : undefined))
+  );
+}
+
+export function resolveServerBuildModuleEffect(
+  buildModule: unknown,
+  source: string
+): Effect.Effect<ServerBuild, Error, never> {
+  return Effect.gen(function* () {
+    const moduleValue = isPromiseLike(buildModule)
+      ? yield* tryPluginPromise(() => buildModule)
+      : buildModule;
+    const candidates = [() => moduleValue];
+    if (isRecord(moduleValue)) {
+      if ('default' in moduleValue) {
+        candidates.push(() => moduleValue.default);
+      }
+      if ('module.exports' in moduleValue) {
+        candidates.push(() => moduleValue['module.exports']);
+      }
+    }
+
+    for (const getCandidate of candidates) {
+      const candidate = yield* tryPluginPromise(() => getCandidate());
+      const serverBuild = yield* resolveServerBuildCandidateEffect(candidate);
+      if (serverBuild) {
+        return serverBuild;
+      }
+    }
+    return yield* Effect.fail(
+      new Error(
+        `[rsbuild-plugin-react-router] ${source} did not contain a valid React Router ServerBuild.`
+      )
+    );
+  });
+}