vite-plugin-react-server 0.3.3 → 0.3.5

package/plugin/config/defaults.ts

@@ -0,0 +1,44 @@
+import { moduleIdDefault } from "./moduleIdDefault.js";
+
+export const DEFAULT_CONFIG = {
+  FILE_REGEX: /\.(m|c)?(j|t)sx?$/,
+  CLIENT_ASSETS_DIR: "assets",
+  RSC_DIR: "rsc",
+  MODULE_BASE: "src",
+  MODULE_BASE_PATH: "/src",
+  MODULE_BASE_URL: "/src",
+  PAGE: "src/page/page.tsx",
+  PROPS: "src/page/props.ts",
+  CLIENT_ENTRY: "/src/client.tsx",
+  SERVER_ENTRY: "/src/server.tsx",
+  PAGE_EXPORT: "Page",
+  PROPS_EXPORT: "props",
+  HTML_WORKER_PATH: 'worker/html/index.js',
+  RSC_WORKER_PATH: 'worker/rsc/index.js',
+  LOADER_PATH: 'worker/loader.js',
+  RSC_EXTENSION: ".rsc",
+  HTML: ({ children }: { children: any }) => children,
+  COLLECT_CSS: true,
+  COLLECT_ASSETS: true,
+  PAGE_PATTERN: "/src/page/**/*.page.tsx",
+  PROPS_PATTERN: "/src/page/**/*.props.ts",
+  DEV_PORT: 5173,
+  PREVIEW_PORT: 4173,
+  DEV_HOST: "localhost",
+  PREVIEW_HOST: "localhost",
+  ENV_PREFIX: "VITE_",
+  BUILD: {
+    pages: () => ["/"],
+    client: "dist/client",
+    server: "dist/server",
+    static: "dist/static",
+  },
+  MODULE_BASE_EXCEPTIONS: [] as string[],
+  AUTO_DISCOVER: {
+    pagePattern: /page\.(m|c)?(j|t)sx?/,
+    propsPattern: /props\.(m|c)?(j|t)sx?/,
+    clientComponents: /client\.(m|c)?(j|t)sx?/,
+    serverFunctions: /server\.(m|c)?(j|t)sx?/,
+  },
+  MODULE_ID: moduleIdDefault
+} as const; 

package/plugin/config/getCondition.ts

@@ -0,0 +1,3 @@
+export const getCondition = (): 'react-client' | 'react-server' => {
+  return process.env['NODE_OPTIONS']?.match(/--condition[= ]react-server/) ? 'react-server' : 'react-client';
+} 

package/plugin/config/getPaths.ts

@@ -0,0 +1,25 @@
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const getNodePath = (root: string = process.cwd()): string => {
+  return process.env['module_root'] ?? join(root, "node_modules");
+}
+
+export const getPluginRoot = (): string => {
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  return join(__dirname, '..');
+}
+
+export const getMode = (): "production" | "development" | "test" => {
+  return process.env['NODE_ENV'] === "development" 
+    ? "development" 
+    : process.env['NODE_ENV'] === "test" 
+      ? "test" 
+      : "production";
+}
+
+export const getDistDir = (mode: "production" | "development" | "test"): string => {
+  return mode === 'production' 
+    ? join(process.cwd(), 'dist') 
+    : join(process.cwd(), 'test/fixtures/dist');
+} 

package/plugin/config/getWorkerPath.ts

@@ -0,0 +1,5 @@
+import { DEFAULT_CONFIG } from './defaults.js';
+
+export const getWorkerPath = (condition: 'react-client' | 'react-server'): string => {
+  return condition === 'react-server' ? DEFAULT_CONFIG.HTML_WORKER_PATH : DEFAULT_CONFIG.RSC_WORKER_PATH;
+} 

package/plugin/config/index.ts

@@ -0,0 +1,8 @@
+export * from './getCondition.js';
+export * from './getWorkerPath.js';
+export * from './getPaths.js';
+export * from './defaults.js';
+export * from './resolveUserConfig.js';
+export * from './resolveOptions.js';
+export * from './resolvePages.js';
+

package/plugin/config/moduleIdDefault.ts

@@ -0,0 +1,23 @@
+import { normalizePath } from "vite";
+import { DEFAULT_CONFIG } from "./defaults.js";
+
+export const moduleIdDefault =
+  ({
+    projectRoot,
+    output: _,
+    isProduction,
+  }: {
+    isProduction: boolean;
+    projectRoot: string;
+    output: { dir: string };
+  }) =>
+  (moduleId: string) => {
+    const normalized = normalizePath(moduleId);
+    const noRoot = normalized.startsWith(projectRoot)
+      ? normalized.slice(projectRoot.length)
+      : normalized;
+    if (!isProduction) {
+      return noRoot;
+    }
+    return noRoot.replace(DEFAULT_CONFIG.FILE_REGEX, ".js");
+  };

package/plugin/config/resolveOptions.ts

@@ -0,0 +1,53 @@
+import type { StreamPluginOptions, ResolvedUserOptions } from "../types.js";
+import { DEFAULT_CONFIG } from "./defaults.js";
+
+export const resolveOptions = (
+  options: StreamPluginOptions
+): { type: "success"; userOptions: ResolvedUserOptions } | { type: "error"; error: Error } => {
+  const projectRoot = options.projectRoot ?? process.cwd();
+
+  const build = options.build ?? DEFAULT_CONFIG.BUILD;
+
+  try {
+    return {
+      type: "success",
+      userOptions: {
+        projectRoot,
+        moduleBase: options.moduleBase ?? DEFAULT_CONFIG.MODULE_BASE,
+        moduleBasePath: options.moduleBasePath ?? DEFAULT_CONFIG.MODULE_BASE_PATH,
+        moduleBaseURL: options.moduleBaseURL ?? DEFAULT_CONFIG.MODULE_BASE_URL,
+        build: {
+          pages: build.pages ?? DEFAULT_CONFIG.BUILD.pages,
+          client: build.client ?? DEFAULT_CONFIG.BUILD.client,
+          server: build.server ?? DEFAULT_CONFIG.BUILD.server,
+          static: build.static ?? DEFAULT_CONFIG.BUILD.static,
+        },
+        Page: options.Page ?? DEFAULT_CONFIG.PAGE,
+        props: options.props ?? DEFAULT_CONFIG.PROPS,
+        Html: options.Html ?? DEFAULT_CONFIG.HTML,
+        pageExportName: options.pageExportName ?? DEFAULT_CONFIG.PAGE_EXPORT,
+        propsExportName: options.propsExportName ?? DEFAULT_CONFIG.PROPS_EXPORT,
+        collectCss: options.collectCss ?? DEFAULT_CONFIG.COLLECT_CSS,
+        collectAssets: options.collectAssets ?? DEFAULT_CONFIG.COLLECT_ASSETS,
+        assetsDir: options.assetsDir ?? DEFAULT_CONFIG.CLIENT_ASSETS_DIR,
+        htmlWorkerPath: options.htmlWorkerPath ?? DEFAULT_CONFIG.HTML_WORKER_PATH,
+        rscWorkerPath: options.rscWorkerPath ?? DEFAULT_CONFIG.RSC_WORKER_PATH,
+        loaderPath: options.loaderPath ?? DEFAULT_CONFIG.LOADER_PATH,
+        clientEntry: options.clientEntry ?? DEFAULT_CONFIG.CLIENT_ENTRY,
+        serverEntry: options.serverEntry ?? DEFAULT_CONFIG.SERVER_ENTRY,
+        moduleBaseExceptions: options.moduleBaseExceptions ?? [],
+        autoDiscover: {
+            pagePattern: options.autoDiscover?.pagePattern ?? DEFAULT_CONFIG.AUTO_DISCOVER.pagePattern,
+            propsPattern: options.autoDiscover?.propsPattern ?? DEFAULT_CONFIG.AUTO_DISCOVER.propsPattern,
+            clientComponents: options.autoDiscover?.clientComponents ?? DEFAULT_CONFIG.AUTO_DISCOVER.clientComponents,
+            serverFunctions: options.autoDiscover?.serverFunctions ?? DEFAULT_CONFIG.AUTO_DISCOVER.serverFunctions,
+        },
+      }
+    };
+  } catch (error) {
+    return {
+      type: "error",
+      error: error instanceof Error ? error : new Error('Failed to resolve options')
+    };
+  }
+}; 

package/plugin/config/resolvePages.ts

@@ -0,0 +1,43 @@
+import type { ResolvedUserOptions } from '../types.js';
+
+export async function resolvePages(
+  pages: ResolvedUserOptions["build"]["pages"]
+): Promise<{ type: "success"; pages: string[] } | { type: "error"; error: Error }> {
+  if (!pages) {
+    return { type: "success", pages: [] };
+  }
+
+  try {
+    // Handle function
+    if (typeof pages === "function") {
+      const result = await Promise.resolve(pages());
+      return resolvePages(result);
+    }
+
+    // Handle Promise
+    if (pages instanceof Promise) {
+      const result = await pages;
+      return resolvePages(result);
+    }
+
+    // Handle string
+    if (typeof pages === "string") {
+      return { type: "success", pages: [pages] };
+    }
+
+    // Handle array
+    if (Array.isArray(pages)) {
+      if (pages.every(page => typeof page === "string")) {
+        return { type: "success", pages };
+      }
+      throw new Error('All pages must be strings');
+    }
+
+    throw new Error('Invalid pages format');
+  } catch (error) {
+    return {
+      type: "error",
+      error: error instanceof Error ? error : new Error('Failed to resolve pages')
+    };
+  }
+} 

package/plugin/config/resolveUserConfig.ts

@@ -0,0 +1,97 @@
+import type { ConfigEnv, UserConfig } from "vite";
+import type { CheckFilesExistReturn, ResolvedUserConfig, ResolvedUserOptions } from "../types.js";
+import { DEFAULT_CONFIG } from "./defaults.js";
+import { createInputNormalizer } from "../helpers/inputNormalizer.js";
+
+export type ResolveUserConfigProps = {
+  condition: "react-client" | "react-server" | "";
+  config: UserConfig;
+  configEnv: ConfigEnv;
+  userOptions: ResolvedUserOptions;
+  files?: CheckFilesExistReturn;
+};
+
+export type ResolveUserConfigReturn = 
+  | { type: "success"; userConfig: ResolvedUserConfig }
+  | { type: "error"; error: Error };
+
+export function resolveUserConfig({
+  condition,
+  config,
+  configEnv,
+  userOptions,
+  files
+}: ResolveUserConfigProps): ResolveUserConfigReturn {
+
+
+  try {
+    // Get existing inputs
+    const root = config.root ?? userOptions.projectRoot ?? process.cwd();
+    const existingInput = config.build?.rollupOptions?.input || {};
+    const currentInputs = typeof existingInput === 'string' ? { default: existingInput } : existingInput;
+    const normalizer = createInputNormalizer(root);
+
+    const serverEntry = userOptions.serverEntry ? [userOptions.serverEntry, userOptions.serverEntry] : [];
+    // Add inputs based on condition
+    const inputs = {
+      ...currentInputs,
+      ...(condition === 'react-server' && files ? {
+        'index.html': '/index.html',
+        ...Object.fromEntries([
+          ...serverEntry,
+          ...Array.from(files.pageMap.entries()),
+          ...Array.from(files.propsMap.entries())
+        ].map(normalizer))
+      } : {
+        client: userOptions.clientEntry
+      })
+    };
+
+    const userConfig = {
+      ...config,
+      root: root,
+      mode: configEnv.command === 'build' ? 'production' : 'development',
+      build: {
+        ...config.build,
+        outDir: condition === 'react-server' ? userOptions.build.server : userOptions.build.client,
+        assetsDir: condition === 'react-server' ? "" : DEFAULT_CONFIG.CLIENT_ASSETS_DIR,
+        ssr: condition === 'react-server',
+        target: condition === 'react-server' ? 'node18' : 'es2020',
+        minify: condition === 'react-server' ? false : true,
+        manifest: true,
+        ssrManifest: false,
+        ssrEmitAssets: true,
+        rollupOptions: {
+          ...config.build?.rollupOptions,
+          input: inputs,
+          preserveEntrySignatures: 'strict',
+          output: condition === 'react-server' ? {
+            preserveModules: true,
+            entryFileNames: '[name].js',
+            assetFileNames: '[name].[ext]',
+            chunkFileNames: '[name].[ext]',
+            format: 'esm',
+            exports: 'named',
+            preserveModulesRoot: userOptions.moduleBase,
+            hoistTransitiveImports: false,
+            generatedCode: {
+              constBindings: true,
+              objectShorthand: true
+            },
+            interop: 'auto'
+          } : undefined
+        }
+      }
+    };
+
+    return {
+      type: "success",
+      userConfig: userConfig as ResolvedUserConfig
+    };
+  } catch (error) {
+    return {
+      type: "error",
+      error: error instanceof Error ? error : new Error("Failed to resolve config")
+    };
+  }
+} 

package/{src → plugin}/getEnv.ts

@@ -2,7 +2,7 @@ import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import type { ConfigEnv, UserConfig } from "vite";
 import { loadEnv } from "vite";
-import { DEFAULT_CONFIG } from "./options.js";
+import { DEFAULT_CONFIG } from "./config/defaults.js";
 
 /**
  * Get environment variables for Vite, sets defaults to ensure the server can start with BASE_URL and PUBLIC_URL

package/plugin/helpers/createClientInputNormalizer.ts

@@ -0,0 +1,48 @@
+import type { Worker } from 'worker_threads';
+import type { InputNormalizerWorker } from '../types.js';
+
+type ClientNormalizerOptions = {
+  rscWorker: Worker;
+};
+
+export const createClientInputNormalizer = ({
+  rscWorker
+}: ClientNormalizerOptions): InputNormalizerWorker => {
+  return async (input): Promise<[string, string]> => {
+    // Handle string
+    if(typeof input === "string") {
+      return [input, input];
+    }
+
+    // Handle React component
+    if(typeof input === "function") {
+      return new Promise((resolve, reject) => {
+        const handler = (message: any) => {
+          if (message.type === "CLIENT_REFERENCE") {
+            rscWorker.off('message', handler);
+            resolve([message.ref.$$id, message.ref.$$location]);
+          }
+          if (message.type === "ERROR") {
+            rscWorker.off('message', handler);
+            reject(new Error(message.error));
+          }
+        };
+
+        rscWorker.on('message', handler);
+        rscWorker.postMessage({
+          type: "CLIENT_REFERENCE",
+          id: input.name || 'AnonymousComponent',
+          location: input.toString(),
+          key: input.name
+        });
+      });
+    }
+
+    // Handle arrays
+    if(Array.isArray(input)) {
+      return [input[0], input[0]];
+    }
+
+    throw new Error('Invalid client input type');
+  };
+}; 

package/plugin/helpers/createServerInputNormalizer.ts

@@ -0,0 +1,52 @@
+import { join } from "node:path";
+import type { Worker } from "node:worker_threads";
+import type { InputNormalizerWorker } from "../types.js";
+
+interface ServerNormalizerOptions {
+  root: string;
+  htmlWorker: Worker;
+}
+
+export function createServerInputNormalizer({
+  root,
+  htmlWorker
+}: ServerNormalizerOptions): InputNormalizerWorker {
+  return async (input) => {
+    // Handle React components with worker
+    if (typeof input === "function") {
+      return new Promise((resolve, reject) => {
+        const handler = (message: any) => {
+          if (message.type === "CLIENT_REFERENCE") {
+            htmlWorker.off('message', handler);
+            resolve([message.ref.$$id, message.ref.$$location]);
+          }
+          if (message.type === "ERROR") {
+            htmlWorker.off('message', handler);
+            reject(new Error(message.error));
+          }
+        };
+
+        htmlWorker.on('message', handler);
+        htmlWorker.postMessage({
+          type: "CLIENT_REFERENCE",
+          id: input.name || 'AnonymousComponent',
+          location: input.toString(),
+          key: input.name
+        });
+      });
+    }
+
+    // Handle tuple input [key, path]
+    if (Array.isArray(input)) {
+      const [key, path] = input;
+      return [key, join(root, path)];
+    }
+
+    // Handle string input
+    if (typeof input === "string") {
+      return [input, join(root, input)];
+    }
+
+    throw new Error(`Invalid input type: ${typeof input}`);
+  };
+} 

package/plugin/helpers/createStaticInputNormalizer.ts

@@ -0,0 +1,26 @@
+import { join } from "node:path";
+import type { InputNormalizer } from "../types.js";
+
+interface StaticNormalizerOptions {
+  root: string;
+}
+
+export function createStaticInputNormalizer({ root }: StaticNormalizerOptions): InputNormalizer {
+  return (input) => {
+    // Handle tuple input [key, path]
+    if (Array.isArray(input)) {
+      const [key, path] = input;
+      // Keep the key as-is for Rollup entry point naming
+      // Just resolve the path relative to root
+      return [key, join(root, path)];
+    }
+
+    // Handle string input
+    if (typeof input === "string") {
+      // For single string inputs, let Rollup handle the naming
+      return [input, join(root, input)];
+    }
+
+    throw new Error(`Invalid input type: ${typeof input}`);
+  };
+} 

package/plugin/helpers/getModuleManifest.ts

@@ -0,0 +1,31 @@
+import type { ModuleInfo, PluginContext } from 'rollup';
+
+interface ModuleManifestEntry {
+  file: string;
+  name: string;
+  src?: string;
+  isEntry?: boolean;
+  imports?: string[];
+  dynamicImports?: string[];
+}
+
+export function getModuleManifest(this: PluginContext): Record<string, ModuleManifestEntry> {
+  const manifest: Record<string, ModuleManifestEntry> = {};
+
+  // Build module graph from plugin context
+  for (const id of this.getModuleIds()) {
+    const info: ModuleInfo | null = this.getModuleInfo(id);
+    if (!info) continue;
+    
+    manifest[id] = {
+      file: info.id,
+      src: info.id,
+      name: id,
+      isEntry: info.isEntry,
+      imports: Array.from(info.importedIds),
+      dynamicImports: Array.from(info.dynamicallyImportedIds)
+    };
+  }
+
+  return manifest;
+}

package/plugin/helpers/inputNormalizer.ts

@@ -0,0 +1,39 @@
+import type { InputNormalizer, NormalizerInput } from "../types.js";
+import { DEFAULT_CONFIG } from "../config/defaults.js";
+import { normalizePath } from "vite";
+import { join } from "path";
+
+export function createInputNormalizer(root: string): InputNormalizer {
+
+  // Normalize a key by removing file extensions and leading slashes
+  const normalizeKey = (key: string): string => {
+    return key
+      .replace(DEFAULT_CONFIG.FILE_REGEX, "") // Remove TypeScript/JavaScript extensions
+      .replace(/^\/+/, ""); // Remove leading slashes
+  };
+
+  // Main normalize function
+  return (input: NormalizerInput): [string, string] => {
+    
+    // Handle tuple input [key, path]
+    if (Array.isArray(input)) {
+      const [key, path] = input;
+      const normalized: [string, string] = [
+        normalizeKey(key),
+        normalizePath(join(root, path))
+      ] 
+      console.log("[inputNormalizer] Normalized input:", normalized, input);
+      return normalized;
+    }
+
+    // Handle string input
+    if (typeof input === "string") {
+      const key = normalizeKey(input);
+      const path = normalizePath( join(root, input));
+      console.log("[inputNormalizer] Normalized input:", [key, path], input);
+      return [key, path];
+    }
+
+    throw new Error(`Invalid input type: ${typeof input}`);
+  };
+}

package/plugin/helpers/inputNormalizerWorker.ts

@@ -0,0 +1,47 @@
+import type { Worker } from "node:worker_threads";
+import type { InputNormalizerWorker, NormalizerInput } from "../types.js";
+import { createInputNormalizer } from "./inputNormalizer.js";
+
+interface WorkerNormalizerOptions {
+  root: string;
+  moduleBase: string;
+  worker: Worker;
+  moduleBaseExceptions?: string[];
+}
+
+export function createInputNormalizerWorker({
+  root,
+  worker,
+}: WorkerNormalizerOptions): InputNormalizerWorker {
+  
+  const baseNormalizer = createInputNormalizer(root);
+
+  return async (input: NormalizerInput): Promise<[string, string]> => {
+    // Handle React components specially with worker
+    if (typeof input === "function") {
+      return new Promise((resolve, reject) => {
+        const handler = (message: any) => {
+          if (message.type === "CLIENT_REFERENCE") {
+            worker.off('message', handler);
+            resolve([message.ref.$$id, message.ref.$$location]);
+          }
+          if (message.type === "ERROR") {
+            worker.off('message', handler);
+            reject(new Error(message.error));
+          }
+        };
+
+        worker.on('message', handler);
+        worker.postMessage({
+          type: "CLIENT_REFERENCE",
+          id: input.name || 'AnonymousComponent',
+          location: input.toString(),
+          key: input.name
+        });
+      });
+    }
+
+    // For all other types, use the base normalizer
+    return baseNormalizer(input);
+  };
+} 

package/plugin/helpers/resolveFilePath.ts

@@ -0,0 +1,108 @@
+import { join, basename } from "node:path";
+import { access, realpath } from "node:fs/promises";
+import { normalizePath } from "vite";
+import { getDistDir, getMode, getNodePath, getPluginRoot } from "../config/getPaths.js";
+import pkg from "../../package.json" with { type: 'json' };
+
+type ResolveOptions = {
+  projectRoot?: string;
+  nodePath?: string;
+  pluginRoot?: string;
+  filePath: string;
+  subDir?: string;
+  normalize?: boolean;
+  distDir?: string;
+  mode?: "production" | "development" | "test";
+};
+
+export async function resolveFilePath({ 
+  projectRoot = process.cwd(),
+  nodePath = getNodePath(projectRoot),
+  mode = getMode(),
+  pluginRoot = getPluginRoot(),
+  distDir = getDistDir(mode),
+  filePath,
+  subDir,
+  normalize = false,
+}: ResolveOptions) {
+  try {
+    let resolvedPath: string | undefined;
+
+    // Helper to check if file exists
+    const exists = async (path: string) => {
+      try {
+        await access(path);
+        return true;
+      } catch {
+        return false;
+      }
+    };
+
+    // If it's a plugin export (like '/rsc-worker'), use exports map
+    if (filePath.startsWith('/') && filePath.slice(1) in pkg.exports) {
+      const exportPath = filePath.slice(1);
+      const pluginPath = pkg.exports[exportPath as keyof typeof pkg.exports];
+      return join(process.cwd(), pluginRoot, pluginPath); // Make absolute
+    }
+
+    // In test mode, preserve relative paths
+    if (mode === 'test' && !filePath.startsWith('/')) {
+      return filePath;
+    }
+
+    // For all other paths, try relative to project root first
+    const projectPath = join(projectRoot, filePath);
+    if (await exists(projectPath)) {
+      return normalize ? normalizePath(projectPath) : projectPath;
+    }
+
+    // 1. Try dist folder
+    const distPath = join(distDir, subDir ?? '', basename(filePath));
+    if (await exists(distPath)) {
+      resolvedPath = await realpath(distPath);
+    }
+
+    // 2. Try node_modules path
+    if (!resolvedPath && filePath.startsWith('/node_modules/')) {
+      const npmPath = join(nodePath, filePath.slice('/node_modules/'.length));
+      if (await exists(npmPath)) {
+        resolvedPath = await realpath(npmPath);
+      }
+    }
+
+    // 3. Try direct path
+    if (!resolvedPath && await exists(filePath)) {
+      resolvedPath = await realpath(filePath);
+    }
+
+    // 4. Try relative to project root
+    if (!resolvedPath) {
+      const projectPath = join(projectRoot, filePath);
+      if (await exists(projectPath)) {
+        resolvedPath = await realpath(projectPath);
+      }
+    }
+
+    if (!resolvedPath) {
+      throw new Error(
+        `Could not resolve path. Tried:\n` +
+        `- ${distPath}\n` +
+        `- ${join(nodePath, filePath.slice('/node_modules/'.length))}\n` +
+        `- ${filePath}\n` +
+        `- ${join(projectRoot, filePath)}`
+      );
+    }
+
+    return normalize ? normalizePath(
+      resolvedPath
+        .replace(pluginRoot, "/node_modules/vite-plugin-react-server")
+        .replace(projectRoot, "/")
+        .replace(nodePath, "/node_modules")
+        .replace(/^(?!\/)/, '/')
+    ) : resolvedPath;
+
+  } catch (error) {
+    // If realpath fails, return normalized input path
+    return normalize ? normalizePath(filePath) : filePath;
+  }
+}