vite-plugin-react-server 1.2.0-alpha.0 → 1.2.0

package/plugin/plugin.client.ts

@@ -1,43 +1,41 @@
-import { reactPreservePlugin } from "./preserver/plugin.js";
-import type { StreamPluginOptions } from "../types.js";
-import { reactClientPlugin } from "./react-client/plugin.js";
-import { envPlugin } from "./env/plugin.js";
-import type { Plugin } from "vite";
+import type { VitePluginMainFn } from "./types.js";
+import { createPluginOrchestrator } from "./orchestrator/createPluginOrchestrator.js";
+import type { UserOptions, Strategy } from "./orchestrator/types.js";
+import { assertNonReactServer } from "./config/getCondition.js";
 
-export type VitePluginReactClientFn = <
-  Opt extends StreamPluginOptions = StreamPluginOptions
->(
-  options: Opt
-) => Plugin[];
+assertNonReactServer();
 
 /**
- * Vite plugin for the React client, use same name to support dynamic import.
- * Includes:
- * - envPlugin
- * - reactClientPlugin
- * - reactPreservePlugin
+ * 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: VitePluginReactClientFn =
-  function _vitePluginReactClient(options) {
+export const vitePluginReactServer: VitePluginMainFn =
+  function _vitePluginReactServer(options, strategy?: Strategy) {
     if (options == null) {
       throw new Error("options is required");
     }
-    return [
-      envPlugin(),
-      reactClientPlugin(options),
-      reactPreservePlugin(options),
-    ];
+    
+    // Use the intelligent orchestrator for plugin composition with client context
+    const userStrategy = (options as UserOptions).strategy || {};
+    const finalStrategy: Strategy = {
+      mode: "auto", // All builds
+      importContext: "react-client", // Indicate this came from client context
+      environmentTargets: new Map([["client", "client"], ["ssr", "ssr"], ["server", "server"]]), 
+      ...userStrategy,
+      ...strategy
+    };
+    return createPluginOrchestrator({
+      ...options,
+      strategy: finalStrategy
+    });
   };
 
-/**
- * Vite plugin for the React client, use specific name to support static import (that doesn't conflict with vitePluginReactServer)
- * Includes:
- * - envPlugin
- * - reactClientPlugin
- * - reactPreservePlugin
- * @param options
- * @returns
- */
-export const vitePluginReactClient = vitePluginReactServer;

package/plugin/plugin.server.ts

@@ -1,52 +1,45 @@
-import { reactPreservePlugin } from "./preserver/plugin.js";
-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 
+ * 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");
     }
-    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 [
-        envPlugin(),
-        reactTransformPlugin(options),
-        reactServerPlugin(options),
-        reactPreservePlugin(options),
-      ];
-    }
-    return [
-      envPlugin(),
-      reactTransformPlugin(options),
-      reactServerPlugin(options),
-      reactStaticPlugin(options),
-      reactPreservePlugin(options),
-    ];
+
+
+    // 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
+    };
+    
+
+    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

@@ -1,13 +1,37 @@
+import { DEFAULT_CONFIG } from "./config/defaults.js";
+import { getEnvKey } from "./env/getEnvKey.js";
+
 declare global {
   namespace NodeJS {
     interface ProcessEnv {
-      VITE_BASE_URL: string;
-      VITE_DEV: string;
-      VITE_PROD: string;
-      VITE_SSR: string;
-      VITE_MODE: string;
-      VITE_PUBLIC_ORIGIN: string;
+      // Base environment variables (these use the configured prefix)
+      [key: string]: string | undefined;
+      
+      // React Server Components conditions
+      NODE_OPTIONS?: string;
     }
   }
 }
+
+/**
+ * Creates a type-safe environment variable accessor for a specific prefix
+ * @param prefix The environment prefix (e.g., "VITE_", "CUSTOM_")
+ * @returns Object with typed environment variable accessors
+ */
+export function createEnvAccessor(prefix: string = DEFAULT_CONFIG.ENV_PREFIX) {
+  return {
+    MODE: process.env[getEnvKey("MODE", prefix)],
+    DEV: process.env[getEnvKey("DEV", prefix)],
+    PROD: process.env[getEnvKey("PROD", prefix)],
+    SSR: process.env[getEnvKey("SSR", prefix)],
+    BASE_URL: process.env[getEnvKey("BASE_URL", prefix)],
+    PUBLIC_ORIGIN: process.env[getEnvKey("PUBLIC_ORIGIN", prefix)]
+  };
+}
+
+/**
+ * Type definition for environment variables with a specific prefix
+ */
+export type PrefixedEnv = ReturnType<typeof createEnvAccessor>;
+
 export {};

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 { reactClientPlugin as vitePluginReactClient } 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;
+    },
+  };
+}