vite-plugin-react-server 1.2.0-alpha.1 → 1.2.1

package/plugin/plugin.server.ts

@@ -1,51 +1,45 @@
-import { reactStaticPlugin } from "./react-static/plugin.js";
-import { reactTransformPlugin } from "./transformer/plugin.server.js";
-import type {
-  StreamPluginOptions,
-} from "./types.js";
-import { reactServerPlugin } from "./react-server/plugin.js";
-import { envPlugin } from "./env/plugin.js";
-import type { Plugin } from "vite";
+import type { VitePluginMainFn } from "./types.js";
+import type { UserOptions, Strategy } from "./orchestrator/types.js";
 
-export type VitePluginReactServerFn = <
-  Opt extends StreamPluginOptions = StreamPluginOptions
->(
-  options: Opt
-) => Plugin[];
+import { assertReactServer } from "./config/getCondition.js";
+import { createPluginOrchestrator } from "./orchestrator/createPluginOrchestrator.js";
+
+assertReactServer();
 
 /**
- * Vite plugin for the React server, use same name to support dynamic import.
- * Includes:
- * - envPlugin
- * - reactTransformPlugin
- * - reactServerPlugin
- * - reactStaticPlugin (if build.pages is not empty)
- * - reactPreservePlugin (handles directive removal/preservation)
+ * Main entrypoint for React Server Components.
+ *
+ * This plugin uses the intelligent orchestrator to adapt its behavior based on the build context:
+ * - In Environment API builds: leverages full RSC capabilities
+ * - With static pages: adds static generation plugin when appropriate
+ *
+ * Use this for server-side rendering and static generation with full RSC support.
+ * Configure the build target through the strategy parameter.
+ * @param options
+ * @param strategy
+ * @returns
  */
-export const vitePluginReactServer: VitePluginReactServerFn =
-  function _vitePluginReactServer(
-    options
-  ) {
-    if(options == null) {
+export const vitePluginReactServer: VitePluginMainFn =
+  function _vitePluginReactServer(options, strategy?: Strategy) {
+    if (options == null) {
       throw new Error("options is required");
     }
-    const basePlugins = [
-      envPlugin(),
-      reactTransformPlugin(options),
-      reactServerPlugin(options),
-    ];
 
-    if (
-      !options.build?.pages ||
-      (Array.isArray(options.build.pages) && options.build.pages.length === 0)
-    ) {
-      // in this case we do not need the static plugin at all
-      return basePlugins;
-    }
+
+    // Use the intelligent orchestrator for plugin composition with server context
+    const userStrategy = (options as UserOptions).strategy || {};
+    const finalStrategy: Strategy = {
+      mode: "auto", // Server builds
+      importContext: "react-server", // Indicate this came from server context
+      environmentTargets: new Map([["client", "client"], ["ssr", "ssr"], ["server", "server"]]), 
+      ...userStrategy,
+      ...strategy
+    };
     
-    // Add static plugin for static builds
-    return [
-      ...basePlugins,
-      reactStaticPlugin(options),
-    ];
+
+    return createPluginOrchestrator({
+      ...options,
+      strategy: finalStrategy
+    });
   };
+

package/plugin/plugin.ts

@@ -1,3 +1,9 @@
-import { getCondition } from './config/getCondition.js';
+import { getCondition } from "./config/getCondition.js";
+import type { VitePluginMainFn } from "./types.js";
 
-export const { vitePluginReactServer } = await import(`./plugin.${getCondition('')}.js`);
+const dir = new URL("./", import.meta.url).pathname.replace(/\/$/, "");
+const condition = getCondition("");
+
+export const { vitePluginReactServer } = (await import(`${dir}/plugin.${condition}.js`)) as {
+  vitePluginReactServer: VitePluginMainFn;
+};

package/plugin/process-env.ts

@@ -6,6 +6,9 @@ declare global {
     interface ProcessEnv {
       // Base environment variables (these use the configured prefix)
       [key: string]: string | undefined;
+      
+      // React Server Components conditions
+      NODE_OPTIONS?: string;
     }
   }
 }

package/plugin/react-client/createMessageHandlers.ts

@@ -1,43 +1,27 @@
 import type { RscWorkerOutputMessage } from "../worker/rsc/types.js";
-import type { Logger } from "vite";
-import type { StreamHandlers } from "../worker/types.js";
+import type { CreateMessageHandlerFn } from "./types.js";
 
-type MessageHandlerContext = {
-  handlers: StreamHandlers;
-  logger: Logger;
-  verbose?: boolean;
-};
 
-export function createMessageHandler({
+export const createMessageHandler: CreateMessageHandlerFn = function _createMessageHandler({
   handlers,
   logger,
   verbose = false,
-}: MessageHandlerContext) {
+}) {
   return (message: RscWorkerOutputMessage | undefined) => {
     if (!message) {
       logger.warn("Received undefined message");
       return;
     }
-
     switch (message.type) {
       case "READY":
         if(verbose) logger.info("[react-client] Worker is ready");
         break;
       case "ERROR": {
-        const error = typeof message.error === 'string' 
-          ? { 
-              message: message.error,
-              reason: message.error,
-              stack: undefined,
-              name: 'Error'
-            }
-          : { 
-              ...message.error,
-              message: message.error?.message || 'Unknown error',
-              name: message.error?.name || 'Error',
-              stack: message.error?.stack
-            };
-        handlers.onError(message.id, error, message.errorInfo);
+        handlers.onError(message.id, message.error);
+        break;
+      }
+      case "SHELL_ERROR": {
+        handlers.onShellError(message.id, message.error);
         break;
       }
       case "RSC_CHUNK":
@@ -47,7 +31,7 @@ export function createMessageHandler({
         handlers.onEnd(message.id);
         break;
       case "RSC_METRICS":
-        handlers.onMetrics(message.id, message.metrics);
+        handlers.onMetrics(message.id, message.metrics as any);
         break;
       case "HMR_ACCEPT":
         handlers.onHmrAccept(message.id, message.routes);
@@ -55,15 +39,6 @@ export function createMessageHandler({
       case "HMR_UPDATE":
         handlers.onHmrUpdate(message.id, message.routes);
         break;
-      case "SERVER_ACTION":
-        handlers.onServerAction?.(message.id, message.args);
-        break;
-      case "SERVER_ACTION_RESPONSE":
-        handlers.onServerActionResponse?.(message.id, message.result, message.error);
-        break;
-      case "SERVER_MODULE":
-        handlers.onServerModule?.(message.id, message.url, message.source);
-        break;
       case "CSS_FILE":
         handlers.onCssFile?.(message.id, message.content);
         break;

package/plugin/react-client/index.client.ts

@@ -0,0 +1 @@
+export * from "./plugin.client.js";

package/plugin/react-client/index.server.ts

@@ -0,0 +1 @@
+export * from "./plugin.server.js";

package/plugin/react-client/index.ts

@@ -1,4 +1,13 @@
-export * from "./createWorkerStream.js";
-export * from "./handleWorkerRscStream.js";
-export * from "./handleWorkerServerAction.js";
-export * from "./plugin.js";
+import { getCondition } from "../config/getCondition.js";
+import type { VitePluginFn } from "../types.js";
+
+export * from "./types.js";
+
+const dir = new URL("./", import.meta.url).pathname.replace(/\/$/, "");
+const condition = getCondition("");
+
+export const {
+  reactClientPlugin,
+} = (await import(`${dir}/index.${condition}.js`)) as {
+  reactClientPlugin: VitePluginFn;
+};

package/plugin/react-client/plugin.client.ts

@@ -0,0 +1,124 @@
+import {
+  createLogger,
+  type ConfigEnv,
+  type ResolvedConfig,
+  type Logger,
+} from "vite";
+import type {
+  AutoDiscoveredFiles,
+  ResolvedUserConfig,
+  VitePluginFn,
+} from "../types.js";
+import { resolveOptions } from "../config/resolveOptions.js";
+import { resolveUserConfig } from "../config/resolveUserConfig.js";
+import { resolveAutoDiscover } from "../config/autoDiscover/resolveAutoDiscover.js";
+import { handleError } from "../error/handleError.js";
+import { assertNonReactServer } from "../config/getCondition.js";
+
+assertNonReactServer();
+
+/**
+ * Main entry for `react-client` behavior. This plugin is imported when the plugin is imported from the main
+ * entrypoint and the condition is not `react-server`.
+ *
+ * This plugin is responsible for:
+ *  Dev mode under non-react-server conditions:
+ * - Disabled, user react-server/plugin.client.ts instead
+ * Build mode under non-react-server conditions:
+ * - Configure the config for the client boundary build
+ * @param options
+ * @returns
+ */
+export const reactClientPlugin: VitePluginFn = function _reactClientPlugin(
+  options
+) {
+  let userConfig: ResolvedUserConfig;
+  let configEnv: ConfigEnv;
+  let autoDiscoveredFiles: AutoDiscoveredFiles;
+
+  let resolvedConfig: ResolvedConfig | null = null;
+  let logger: Logger;
+  let implicitSsr: boolean | undefined = undefined;
+
+  // Initial options resolution
+  const resolvedOptions = resolveOptions(options);
+  if (resolvedOptions.type === "error") {
+    if (resolvedOptions.error != null) {
+      throw resolvedOptions.error;
+    }
+    throw new Error("Failed to resolve options");
+  }
+  const currentUserOptions = resolvedOptions.userOptions;
+
+  return {
+    name: "vite:plugin-react-server/client",
+    enforce: "post",
+    async config(config, viteConfigEnv) {
+      
+      configEnv = viteConfigEnv;
+      if (configEnv.command !== "build") {
+        return;
+      }
+      
+      
+      
+      if(typeof config?.build?.ssr === "boolean" || typeof config?.build?.ssr === "string") {
+        implicitSsr = Boolean(config?.build?.ssr);
+        
+      } else if(implicitSsr === undefined) {
+        implicitSsr = configEnv.isSsrBuild;
+      }
+      
+      
+      const logger = config.customLogger || createLogger();
+      const autoDiscoverResult = await resolveAutoDiscover({
+        config,
+        configEnv,
+        userOptions: currentUserOptions,
+        logger,
+      });
+      if (autoDiscoverResult.type === "error") {
+        const panicError = handleError({
+          error: autoDiscoverResult.error,
+          logger,
+          panicThreshold: currentUserOptions.panicThreshold,
+          context: "config(autoDiscover)",
+        });
+        if (panicError != null) {
+          throw panicError;
+        }
+        return;
+      }
+      autoDiscoveredFiles = autoDiscoverResult.autoDiscoveredFiles;
+      if (!autoDiscoveredFiles) {
+        throw new Error("Failed to find autoDiscoveredFiles");
+      }
+
+      const resolvedConfig = resolveUserConfig({
+        condition: "react-client",
+        config,
+        configEnv,
+        userOptions: currentUserOptions,
+        autoDiscoveredFiles,
+        ssr: implicitSsr,
+      });
+
+      if (resolvedConfig.type === "error") {
+        if (resolvedConfig.error != null) {
+          throw resolvedConfig.error;
+        }
+        throw new Error("Failed to resolve config");
+      }
+
+      userConfig = resolvedConfig.userConfig;
+      return userConfig;
+    },
+    configResolved(viteResolvedConfig) {
+      if (currentUserOptions.verbose) {
+        logger?.info("configResolved");
+      }
+      resolvedConfig = viteResolvedConfig;
+      logger = resolvedConfig.customLogger || resolvedConfig.logger;
+    },
+  };
+};

package/plugin/react-client/plugin.server.ts

@@ -0,0 +1,108 @@
+import { createLogger, type ConfigEnv } from "vite";
+import type {
+  AutoDiscoveredFiles,
+  ResolvedUserConfig,
+  VitePluginFn,
+} from "../types.js";
+import { resolveOptions } from "../config/resolveOptions.js";
+import { resolveUserConfig } from "../config/resolveUserConfig.js";
+import { resolveAutoDiscover } from "../config/autoDiscover/resolveAutoDiscover.js";
+import { handleError } from "../error/handleError.js";
+import { assertReactServer } from "../config/getCondition.js";
+
+assertReactServer();  
+
+/**
+ * Semantic entry for `react-client` build behavior under the `react-server`  condition.
+ * - Only used whe imported directly and under the `react-server` condition.
+ * 
+ * This plugin is responsible for:
+ *  Dev mode under non-react-server conditions:
+ *   - Disabled, use /server/plugin.server.ts instead
+ *  Build:
+ *  - Configure the config for the client boundary build
+ * @param options 
+ * @returns 
+ */
+export const reactClientPlugin: VitePluginFn = function _reactClientPlugin(
+  options
+) {
+  let userConfig: ResolvedUserConfig;
+  let configEnv: ConfigEnv;
+  let autoDiscoveredFiles: AutoDiscoveredFiles;
+  let implicitSsr: boolean | undefined = undefined;
+  // Initial options resolution
+  const resolvedOptions = resolveOptions(options);
+  if (resolvedOptions.type === "error") {
+    if(resolvedOptions.error != null) {
+      throw resolvedOptions.error;
+    }
+    throw new Error("React client plugin failed to resolve options");
+  }
+  const { userOptions } = resolvedOptions;
+
+  return {
+    name: "vite:plugin-react-server/client",
+    applyToEnvironment(env) {
+      // Only apply this plugin in the client environment
+      const envName = (env?.name || "").toLowerCase();
+      if(envName === "client" || envName === "ssr") {
+        return true;
+      }
+      return false;
+    },
+    async config(config, viteConfigEnv) {
+      configEnv = viteConfigEnv;
+      if(configEnv.command !== "build") {
+        return;
+      }
+      if(typeof config?.build?.ssr === "boolean" || typeof config?.build?.ssr === "string") {
+        implicitSsr = config?.build?.ssr === "true" || config?.build?.ssr === true;
+      } else if(implicitSsr === undefined) {
+        implicitSsr = configEnv.isSsrBuild;
+      }
+    
+      const logger = config.customLogger || createLogger();
+      const autoDiscoverResult = await resolveAutoDiscover({
+        config,
+        configEnv,
+        userOptions: userOptions,
+        logger,
+      });
+      if (autoDiscoverResult.type === "error") {
+        const panicError = handleError({
+          error: autoDiscoverResult.error,
+          logger,
+          panicThreshold: userOptions.panicThreshold,
+          context: "config(autoDiscover)",
+        });
+        if (panicError != null) {
+          throw panicError;
+        }
+        throw new Error("Failed to resolve autoDiscoveredFiles");
+      }
+      autoDiscoveredFiles = autoDiscoverResult.autoDiscoveredFiles;
+      
+
+      const resolvedConfig = resolveUserConfig({
+        condition: "react-client",
+        config,
+        configEnv,
+        userOptions: userOptions,
+        autoDiscoveredFiles,
+        ssr: implicitSsr,
+      });
+
+      if (resolvedConfig.type === "error") {
+        if(resolvedConfig.error != null) {
+          throw resolvedConfig.error;
+        }
+        throw new Error("Failed to resolve config");
+      }
+
+
+      userConfig = resolvedConfig.userConfig;
+      return userConfig;
+    },
+  };
+}

package/plugin/react-client/plugin.ts

@@ -1,152 +1,13 @@
-import { type ConfigEnv } from "vite";
-import type {
-  AutoDiscoveredFiles,
-  ReactStreamPluginFn,
-  ReactStreamPluginMeta,
-  ResolvedUserConfig,
-} from "../types.js";
-import { resolveOptions } from "../config/resolveOptions.js";
-import { resolveUserConfig } from "../config/resolveUserConfig.js";
-import { resolveAutoDiscover } from "../config/autoDiscover/resolveAutoDiscover.js";
-import { configureWorkerRequestHandler } from "./configureWorkerRequestHandler.js";
-import { configurePreviewServer } from "../react-static/configurePreviewServer.js";
-import { MessageChannel } from "node:worker_threads";
-
-export type ReactClientPluginFn = ReactStreamPluginFn<{
-  meta: ReactStreamPluginMeta;
-}>;
-
-export const reactClientPlugin: ReactClientPluginFn = function _reactClientPlugin(
-  options
-) {
-  let userConfig: ResolvedUserConfig;
-  let configEnv: ConfigEnv;
-  let root: string;
-  let autoDiscoveredFiles: AutoDiscoveredFiles;
-  let hmrChannel: MessageChannel | null = null;
-
-  const resolvedOptions = resolveOptions(options);
-  if (resolvedOptions.type === "error") {
-    throw resolvedOptions.error;
-  }
-  const userOptions = resolvedOptions.userOptions;
-  root = userOptions.projectRoot;
-
-  return {
-    name: "vite:react-client",
-
-    async config(config, viteConfigEnv) {
-      configEnv = viteConfigEnv;
-      if (
-        typeof config.root === "string" &&
-        config.root !== root &&
-        config.root !== process.cwd() &&
-        config.root !== ""
-      ) {
-        root = config.root;
-        userOptions.projectRoot = root;
-      }
-
-      const autoDiscoverResult = await resolveAutoDiscover({
-        config,
-        configEnv,
-        userOptions,
-        condition: "react-client",
-      });
-      if (autoDiscoverResult.type === "error") {
-        throw autoDiscoverResult.error;
-      }
-      autoDiscoveredFiles = autoDiscoverResult.autoDiscoveredFiles;
-
-      const resolvedConfig = resolveUserConfig({
-        condition: "react-client",
-        config,
-        configEnv,
-        userOptions,
-        autoDiscoveredFiles,
-      });
-
-      if (resolvedConfig.type === "error") {
-        throw resolvedConfig.error;
-      }
-
-      userConfig = resolvedConfig.userConfig;
-      return userConfig;
-    },
-    async configurePreviewServer(server) {
-      await configurePreviewServer({
-        server,
-        userOptions,
-      });
-    },
-    async writeBundle(options, bundle) {
-      if (userOptions.onEvent) {
-        userOptions.onEvent({
-          type: `build.writeBundle.${
-            userConfig.build.ssr ? "client" : "static-client"
-          }`,
-          data: {
-            pages: [...autoDiscoveredFiles.routeMap.keys()],
-            options,
-            bundle,
-          },
-        });
-      }
-    },
-    // setup dev server
-    configureServer(server) {
-      // Create HMR message channel
-      hmrChannel = new MessageChannel();
-      configureWorkerRequestHandler({
-        server,
-        autoDiscoveredFiles,
-        userOptions,
-        hmrChannel,
-      });
-    },
-
-    async handleHotUpdate({ file, server, timestamp, ...ctx }) {
-      try {
-        // Check if the file is a page or props file
-        const isPageFile = userOptions.autoDiscover.modulePattern.test(file);
-        if (!isPageFile) return;
-
-        // Get the route for this file
-        const [, value] = userOptions.normalizer(file);
-
-        // Find all routes affected by this file change
-        const affectedRoutes = autoDiscoveredFiles.routeMap.get(value) || [];
-
-        // Send HMR update directly to worker through MessageChannel
-        if (hmrChannel?.port1) {
-          hmrChannel.port1.postMessage({
-            type: "HMR_UPDATE",
-            path: file,
-            timestamp,
-            routes: affectedRoutes,
-          });
-
-          // Trigger a full page refresh for affected routes
-          for (const route of affectedRoutes) {
-            server.ws.send({
-              type: "full-reload",
-              path: route,
-            });
-          }
-        }
-
-        // Let Vite handle the HMR update
-        return ctx.modules;
-      } catch (error) {
-        if (hmrChannel?.port1) {
-          hmrChannel.port1.postMessage({
-            type: "HMR_ERROR",
-            path: file,
-            error: error instanceof Error ? error.message : String(error),
-          });
-        }
-        return ctx.modules;
-      }
-    },
-  };
-}
+import { fileURLToPath } from "node:url";
+import { dirname } from "node:path";
+import { getCondition } from "../config/getCondition.js";
+import type { VitePluginFn } from "../types.js";
+
+const dir = dirname(fileURLToPath(import.meta.url));
+const condition = getCondition("");
+
+export const { reactClientPlugin } = (await import(
+  `${dir}/plugin.${condition}.js`
+)) as {
+  reactClientPlugin: VitePluginFn
+};