rsbuild-plugin-react-router 0.3.0 → 0.4.0

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.`
+      )
+    );
+  });
+}

package/src/server-utils.ts

@@ -1,5 +1,7 @@
 import { resolve } from 'pathe';
 import type { ServerBuild } from 'react-router';
+import { runPluginEffect } from './effect-runtime.js';
+import { resolveServerBuildModuleEffect } from './server-build-resolution.js';
 import type { Route } from './types.js';
 
 /**
@@ -91,120 +93,19 @@ function generateServerBuild(
   return generateStaticTemplate(routes, options);
 }
 
-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 (
-    isRecord(value) &&
-    (value.mode === 'initial' ||
-      (value.mode === 'lazy' &&
-        (value.manifestPath === undefined ||
-          typeof value.manifestPath === 'string')))
-  );
-}
-
-async function resolveBuildExports(
-  build: Record<string, unknown>
-): Promise<Record<string, unknown>> {
-  const resolved = { ...build };
-  for (const key of Object.keys(build)) {
-    if (!RESOLVABLE_BUILD_EXPORTS.has(key)) {
-      continue;
-    }
-    const value = build[key];
-    if (typeof value === 'function' && value.length === 0) {
-      const result = value();
-      resolved[key] = isPromiseLike(result) ? await result : result;
-      continue;
-    }
-    if (isPromiseLike(value)) {
-      resolved[key] = await value;
-    }
-  }
-  return 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'
-  );
-}
-
-async function resolveServerBuildCandidate(
-  candidate: unknown
-): Promise<ServerBuild | undefined> {
-  if (!isRecord(candidate)) {
-    return undefined;
-  }
-  const resolved = await resolveBuildExports(candidate);
-  return isServerBuild(resolved) ? resolved : undefined;
-}
-
-export async function resolveServerBuildModule(
+export function resolveServerBuildModule(
   buildModule: unknown,
   source: string
 ): Promise<ServerBuild> {
-  const moduleValue = await 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 = await getCandidate();
-    const serverBuild = await resolveServerBuildCandidate(candidate);
-    if (serverBuild) {
-      return serverBuild;
-    }
-  }
-  throw new Error(
-    `[rsbuild-plugin-react-router] ${source} did not contain a valid React Router ServerBuild.`
-  );
+  return runPluginEffect(resolveServerBuildModuleEffect(buildModule, source));
 }
 
 export function resolveReactRouterServerBuild(
   buildModule: unknown
 ): Promise<ServerBuild> {
-  return resolveServerBuildModule(buildModule, 'Imported module');
+  return runPluginEffect(
+    resolveServerBuildModuleEffect(buildModule, 'Imported module')
+  );
 }
 
 export { generateServerBuild };

package/src/ssr-externals.ts

@@ -15,7 +15,7 @@ const REACT_ROUTER_EXTERNALS = [
 
 const requireFromHere = createRequire(import.meta.url);
 
-function resolvePackageJson(
+export function resolvePackageJson(
   name: string,
   rootDirectory: string
 ): string | null {