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

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

package/plugin/react-client/types.ts

@@ -0,0 +1,95 @@
+import type { ConfigEnv, Logger, Manifest, ResolvedConfig, ViteDevServer } from "vite";
+import type {
+  AutoDiscoveredFiles,
+  MessageHandler,
+  PanicThreshold,
+  ResolvedUserOptions,
+  SerializedUserOptions,
+} from "../../types.js";
+import type { MessageChannel, Worker } from "node:worker_threads";
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type {
+  RscChunkOutputMessage,
+  RscWorkerOutputMessage,
+} from "../worker/rsc/types.js";
+import type { StreamHandlers } from "../worker/types.js";
+import type { PassThrough } from "node:stream";
+
+export type RestartWorkerFn = (props: {
+  server: ViteDevServer;
+  autoDiscoveredFiles: AutoDiscoveredFiles;
+  userOptions: SerializedUserOptions;
+  configEnv: ConfigEnv;
+  hmrChannel: MessageChannel;
+}) => Promise<Worker | null>;
+
+export type HandleWorkerServerActionFn = (
+  req: IncomingMessage,
+  res: ServerResponse,
+  worker: Worker,
+  logger: ViteDevServer["config"]["logger"]
+) => Promise<void>;
+
+export type CreateWorkerStreamFn = (props: {
+  route: string;
+  url: string;
+  projectRoot: string;
+  moduleBasePath: string;
+  moduleBaseURL: string;
+  moduleRootPath: string;
+  cssFiles: Map<string, any>;
+  globalCss: Map<string, any>;
+  manifest: any;
+  serverPipeableStreamOptions?: any;
+  clientPipeableStreamOptions?: any;
+  verbose?: boolean;
+  panicThreshold?: PanicThreshold;
+  logger?: any;
+  rscWorkerPath?: string;
+  onEvent?: (event: any) => void;
+  moduleBase: string;
+  HtmlComponent: any;
+  PageComponent: any;
+  RootComponent: any;
+  pageProps: any;
+  as: any;
+}) => {
+  abort: (reason?: unknown) => void;
+  pipe: <Writable extends NodeJS.WritableStream>(destination: Writable) => Writable;
+};
+
+
+// Removed GenerateWorkerStreamFn - using CreateWorkerStreamFn from helpers instead
+
+export type CreateMessageHandlerFn = (props: {
+  handlers: StreamHandlers;
+  logger: Logger;
+  verbose?: boolean;
+}) => (message: RscWorkerOutputMessage | undefined) => void;
+
+export type ConfigureWorkerRequestHandlerFn = (props: {
+  server: ViteDevServer;
+  autoDiscoveredFiles: AutoDiscoveredFiles;
+  userOptions: ResolvedUserOptions;
+  configEnv: ConfigEnv;
+  serverManifest: Manifest;
+  resolvedConfig: ResolvedConfig;
+  hmrChannel: MessageChannel;
+  onWorkerCreated?: (worker: Worker, restart?: () => Promise<void>) => void;
+}) => void;
+
+export type ConfigureRequestHandlerFn = (
+  req: IncomingMessage,
+  res: ServerResponse,
+  worker: Worker,
+  logger: ViteDevServer["config"]["logger"]
+) => Promise<void>;
+
+export type CleanupWorkerServerActionFn = (
+  passThrough: PassThrough,
+  worker: Worker,
+  messageHandler: MessageHandler<RscChunkOutputMessage>,
+  res: ServerResponse,
+  error?: unknown,
+  logger?: Logger
+) => void;

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

@@ -0,0 +1 @@
+export { reactServerPlugin } from "./plugin.client.js";

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

@@ -0,0 +1 @@
+export { reactServerPlugin } from "./plugin.server.js";

package/plugin/react-server/index.ts

@@ -1 +1,13 @@
-export { reactServerPlugin } from "./plugin.js";
+import type { VitePluginFn } from "../types.js";
+import { getCondition } from "../config/getCondition.js";
+import type { ConfigureReactServerFn, HandleServerActionFn } from "./types.js";
+
+const condition = getCondition("");
+const dir = new URL("./", import.meta.url).pathname.replace(/\/$/, "");
+
+export const { reactServerPlugin, handleServerAction, configureReactServer } =
+  (await import(`${dir}/index.${condition}.js`)) as {
+    reactServerPlugin: VitePluginFn;
+    handleServerAction: HandleServerActionFn;
+    configureReactServer: ConfigureReactServerFn;
+  };

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

@@ -0,0 +1,54 @@
+import { performance } from "node:perf_hooks";
+
+import { resolveOptions } from "../config/resolveOptions.js";
+import type {
+  BuildTiming,
+  VitePluginFn,
+} from "../types.js";
+import { createDefaultModuleID } from "../config/createModuleID.js";
+import { assertNonReactServer } from "../config/getCondition.js";
+assertNonReactServer();
+
+export const reactServerPlugin: VitePluginFn =
+  function _reactServerPluginForClient(options) {
+    const timing: BuildTiming = {
+      start: performance.now(),
+    };
+
+
+    const resolvedOptions = resolveOptions(options);
+    if (resolvedOptions.type === "error") {
+      if (resolvedOptions.error != null) {
+        throw resolvedOptions.error;
+      }
+      throw new Error("Failed to resolve options");
+    }
+    let currentUserOptions = resolvedOptions.userOptions;
+    return {
+      name: "vite:plugin-react-server/rsc-worker-server",
+      enforce: "post",
+      api: {
+        meta: { timing },
+      },
+      applyToEnvironment(partialEnvironment) {
+        if (['server', 'client', 'ssr'].includes(partialEnvironment.name)) {
+          return true;
+        }
+        return false;
+      },
+      config(config, viteConfigEnv) {
+        // Set up moduleID function if not already set
+        if (typeof currentUserOptions.moduleID !== "function") {
+          currentUserOptions.moduleID = createDefaultModuleID(
+            currentUserOptions,
+            viteConfigEnv,
+            currentUserOptions.loader?.mode
+          );
+        }
+        
+        // The environment plugin handles auto-discovery and input configuration
+        // This plugin now focuses on server-specific functionality
+        return config; 
+      },
+  };
+};

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

@@ -0,0 +1,27 @@
+import { performance } from "node:perf_hooks";
+import type {
+  BuildTiming,
+  VitePluginFn,
+} from "../types.js";
+import { assertReactServer } from "../config/getCondition.js";
+
+assertReactServer()
+
+export const reactServerPlugin: VitePluginFn = function _reactServerPlugin(
+  _options
+) {
+  const timing: BuildTiming = {
+    start: performance.now(),
+  };
+
+  return {
+    name: "vite:plugin-react-server/server",
+    enforce: "post",
+    api: {
+      meta: { timing },
+    },
+    configResolved(_resolvedConfig) {
+      timing.configResolved = performance.now();
+    },
+  };
+};

package/plugin/react-server/plugin.ts

@@ -1,185 +1,10 @@
-import { performance } from "node:perf_hooks";
-import {
-  type ResolvedConfig,
-  type UserConfig,
-  type ViteDevServer,
-  type Manifest,
-} from "vite";
-import { resolveOptions } from "../config/resolveOptions.js";
-import { resolveUserConfig } from "../config/resolveUserConfig.js";
-import type {
-  AutoDiscoveredFiles,
-  BuildTiming,
-  ReactStreamPluginFn,
-  ReactStreamPluginMeta,
-} from "../types.js";
-import {
-  resolveAutoDiscover
-} from "../config/autoDiscover/resolveAutoDiscover.js";
-import { configureReactServer } from "./configureReactServer.js";
-import { configurePreviewServer } from "../react-static/configurePreviewServer.js";
-import { getBundleManifest } from "../helpers/getBundleManifest.js";
-import { createDefaultModuleID } from "../config/createModuleID.js";
+import type { VitePluginMainFn } from "../types.js";
+import { getCondition } from "../config/getCondition.js";
 
-let resolvedConfig: ResolvedConfig | null = null;
+const condition = getCondition("");
+const dir = new URL(".", import.meta.url)
+  .pathname;
 
-export type ReactServerPluginFn = ReactStreamPluginFn<{
-  meta: ReactStreamPluginMeta;
-}>
-
-export const reactServerPlugin:ReactServerPluginFn = function _reactServerPlugin(options) {
-  const timing: BuildTiming = {
-    start: performance.now(),
-  };
-
-  let autoDiscoveredFiles: AutoDiscoveredFiles;
-  let serverManifest: Manifest = {};
-
-  const resolvedOptions = resolveOptions(options);
-  if (resolvedOptions.type === "error") {
-    throw resolvedOptions.error;
-  }
-  const userOptions = resolvedOptions.userOptions;
-  
-
-  return {
-    name: "vite:react-stream-server",
-    enforce: "post",
-    api: {
-      meta: { timing },
-    },  
-    configResolved(_resolvedConfig) {
-      resolvedConfig = _resolvedConfig;
-      if (
-        userOptions.projectRoot != resolvedConfig.root &&
-        typeof userOptions.projectRoot === "string" &&
-        userOptions.projectRoot !== ""
-      ) {
-        throw new Error(
-          "[RSC] Project root is not the current working directory, please set projectRoot in your config.\n" +
-            " projectRoot: " + userOptions.projectRoot + "\n" +
-            " resolvedConfig.root: " + resolvedConfig.root
-        );
-      }
-      timing.configResolved = performance.now();
-
-      // Verify transformer runs first, preserver runs last
-      const plugins = resolvedConfig.plugins;
-      const transformerIndex = plugins.findIndex(
-        (p) => p.name.includes("vite-plugin-react-server:transform")
-      );
-      const preserverIndex = plugins.findIndex(
-        (p) => p.name.includes("vite-plugin-react-server:preserve-directives")
-      );
-
-      if (transformerIndex === -1) {
-        throw new Error("Transformer plugin not installed");
-      }
-      if (preserverIndex < transformerIndex) {
-        console.warn(
-          "Transformer plugin isn't installed or isn't running before preserver"
-        );
-      }
-    },
-
-    async configurePreviewServer(server) {
-      await configurePreviewServer({
-        server,
-        userOptions,
-      });
-    },
-    async configureServer(server: ViteDevServer) {
-      configureReactServer({
-        server,
-        autoDiscoveredFiles,
-        userOptions,
-        serverManifest,
-      });
-    },
-    async config(config, configEnv): Promise<UserConfig> {
-      // Create the proper moduleID function now that we have ConfigEnv
-      if (typeof userOptions.moduleID !== "function") {
-        userOptions.moduleID = createDefaultModuleID(userOptions, configEnv, userOptions.loader.mode);
-      }
-
-      const autoDiscoverResult = await resolveAutoDiscover({
-        config,
-        configEnv,
-        userOptions,
-        condition: "react-server",
-      });
-      if (autoDiscoverResult.type === "error") {
-        throw autoDiscoverResult.error;
-      }
-      autoDiscoveredFiles = autoDiscoverResult.autoDiscoveredFiles;
-
-      const resolvedConfig = resolveUserConfig({
-        condition: "react-server",
-        config,
-        configEnv,
-        userOptions,
-        autoDiscoveredFiles,
-      });
-
-      if (resolvedConfig.type === "error") {
-        console.error(
-          "[react-server-plugin] Failed to resolve config:",
-          resolvedConfig.error
-        );
-        throw resolvedConfig.error;
-      }
-
-      return resolvedConfig.userConfig;
-    },
-    async writeBundle(options, bundle) {
-      if (userOptions.onEvent) {
-        userOptions.onEvent({
-          type: "build.writeBundle.server",
-          data: {
-            pages: Array.from(autoDiscoveredFiles?.urlMap.keys() ?? []),
-            options,
-            bundle,
-          },
-        });
-      }
-    },
-    async buildStart() {
-      if (!timing.buildStart) {
-        timing.buildStart = performance.now();
-      } else {
-        console.log("Build already started");
-      }
-    },
-    async generateBundle(_options, bundle) {
-      // Create manifest entries for each chunk
-      serverManifest = getBundleManifest<false>({
-        bundle,
-        normalizer: userOptions.normalizer,
-      });
-    },
-    async handleHotUpdate({ file, server, timestamp, ...ctx }) {
-      try {
-        // Invalidate the module in Vite's cache for both client and SSR
-        if (server.moduleGraph) {
-          const mod = server.moduleGraph.getModuleById(file);
-          if (mod) {
-            // Invalidate the parent module which will handle both client and SSR
-            server.moduleGraph.invalidateModule(mod, undefined, timestamp, true);
-            
-            // Force a reload of the module
-            const newMod = await server.moduleGraph.ensureEntryFromUrl(file, false);
-            if (newMod) {
-              server.moduleGraph.invalidateModule(newMod, undefined, timestamp, true);
-            }
-          }
-        }
-        
-        // Let Vite handle the HMR update
-        return ctx.modules;
-      } catch (error) {
-        console.error("[react-server] HMR Error:", error);
-        return ctx.modules;
-      }
-    },
-  };
-}
+export const { reactServerPlugin } = (await import(
+  `${dir}/plugin.${condition}.js`   
+)) as { reactServerPlugin: VitePluginMainFn };

package/plugin/react-server/types.ts

@@ -0,0 +1,24 @@
+import type { Manifest, ViteDevServer } from "vite";
+import type {
+  AutoDiscoveredFiles,
+  CreateHandlerOptions,
+  ResolvedUserOptions,
+} from "../types.js";
+import type { IncomingMessage, ServerResponse } from "http";
+
+export type HandleServerActionFn = (
+  req: IncomingMessage,
+  res: ServerResponse,
+  server: ViteDevServer,
+  handlerOptions: Pick<
+    CreateHandlerOptions,
+    "verbose" | "moduleBasePath" | "projectRoot" | "loader"
+  >
+) => Promise<void>;
+
+export type ConfigureReactServerFn = (options: {
+  server: ViteDevServer;
+  autoDiscoveredFiles: AutoDiscoveredFiles;
+  userOptions: ResolvedUserOptions;
+  serverManifest: Manifest;
+}) => void;