vite-plugin-react-server 1.4.1 → 1.4.3

package/dist/plugin/transformer/createTransformerPlugin.js

@@ -1,269 +1,230 @@
-import { perEnvironmentState } from "vite";
-import { createTransformer } from "../loader/createTransformer.js";
-import { resolveOptions } from "../config/resolveOptions.js";
-import { readFileSync } from "node:fs";
-import { resolve, join } from "node:path";
-import { getNodeEnv, isValidEnv } from "../config/getNodeEnv.js";
-// import { getEnvironmentName } from "../env/plugin.js";
-import { DEFAULT_CONFIG } from "../config/defaults.js";
-import { resolveRegExp } from "../config/resolveRegExp.js";
-import { userProjectRoot } from "../root.js";
-import { createDefaultModuleID } from "../config/createModuleID.js";
-export const createTransformerPlugin = (options) => {
-    return (userOptions) => {
-        const { name } = options;
-        // CRITICAL: Use per-environment state to prevent cross-environment cache contamination
-        // This fixes the issue where server environment cached modules affect client environment builds
-        const transformationCache = perEnvironmentState(() => new Map());
-        const defaultEnvironment = options.defaultEnvironment ?? (name === "client" ? "client" : "server");
-        const allowedEnvironments = options.allowedEnvironments ??
-            (name === "client"
-                ? defaultEnvironment === "client"
-                    ? ["client", "ssr"]
-                    : ["client"]
-                : defaultEnvironment === "server"
-                    ? ["server", "ssr"]
-                    : ["server"]);
-        const logPrefix = `[vite-plugin-react-server:transform-${defaultEnvironment}-as-${name}]`;
-        const resolvedOptionsResult = resolveOptions(userOptions);
-        if (resolvedOptionsResult.type === "error")
-            throw resolvedOptionsResult.error;
-        const { userOptions: resolvedUserOptions } = resolvedOptionsResult;
-        let isBuild = true;
-        let isSSR = true;
-        const nodeEnv = getNodeEnv(process.env.NODE_ENV);
-        let mode = nodeEnv;
-        let runtimeResolvedUserOptions = resolvedUserOptions;
-        // Use global cache for transformation results to ensure consistent hashing across all plugin instances
-        const outDir = resolvedUserOptions.build.outDir || "dist";
-        const serverDir = join(outDir, resolvedUserOptions.build.server || "server");
-        const clientDir = join(outDir, resolvedUserOptions.build.client || "client");
-        const staticDir = join(outDir, resolvedUserOptions.build.static || "static");
-        const modulePattern = resolveRegExp(userOptions.autoDiscover?.modulePattern ??
-            DEFAULT_CONFIG.AUTO_DISCOVER.modulePattern);
-        const nodeModulesPattern = resolveRegExp(userOptions.autoDiscover?.vendorPattern ??
-            DEFAULT_CONFIG.AUTO_DISCOVER.vendorPattern);
-        const noDist = (id) => {
-            // Allow files from test fixtures and project root
-            if (id.startsWith(userProjectRoot) ||
-                id.startsWith(join(userProjectRoot, outDir)) ||
-                id.startsWith(join(outDir, staticDir)) ||
-                id.startsWith(join(outDir, serverDir)) ||
-                id.startsWith(join(outDir, clientDir))) {
-                return true;
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+import { perEnvironmentState } from 'vite';
+import { createTransformer } from '../loader/createTransformer.js';
+import { resolveOptions } from '../config/resolveOptions.js';
+import { readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { getNodeEnv, isValidEnv } from '../config/getNodeEnv.js';
+import { DEFAULT_CONFIG } from '../config/defaults.js';
+import { resolveRegExp } from '../config/resolveRegExp.js';
+import { userProjectRoot } from '../root.js';
+import { createDefaultModuleID } from '../config/createModuleID.js';
+
+const createTransformerPlugin = (options) => {
+  return (userOptions) => {
+    const { name } = options;
+    const transformationCache = perEnvironmentState(() => /* @__PURE__ */ new Map());
+    const defaultEnvironment = options.defaultEnvironment ?? (name === "client" ? "client" : "server");
+    const allowedEnvironments = options.allowedEnvironments ?? (name === "client" ? defaultEnvironment === "client" ? ["client", "ssr"] : ["client"] : defaultEnvironment === "server" ? ["server", "ssr"] : ["server"]);
+    const logPrefix = `[vite-plugin-react-server:transform-${defaultEnvironment}-as-${name}]`;
+    const resolvedOptionsResult = resolveOptions(userOptions);
+    if (resolvedOptionsResult.type === "error")
+      throw resolvedOptionsResult.error;
+    const { userOptions: resolvedUserOptions } = resolvedOptionsResult;
+    let isBuild = true;
+    let isSSR = true;
+    const nodeEnv = getNodeEnv(process.env.NODE_ENV);
+    let mode = nodeEnv;
+    let runtimeResolvedUserOptions = resolvedUserOptions;
+    const outDir = resolvedUserOptions.build.outDir || "dist";
+    const serverDir = join(
+      outDir,
+      resolvedUserOptions.build.server || "server"
+    );
+    const clientDir = join(
+      outDir,
+      resolvedUserOptions.build.client || "client"
+    );
+    const staticDir = join(
+      outDir,
+      resolvedUserOptions.build.static || "static"
+    );
+    const modulePattern = resolveRegExp(
+      userOptions.autoDiscover?.modulePattern ?? DEFAULT_CONFIG.AUTO_DISCOVER.modulePattern
+    );
+    const nodeModulesPattern = resolveRegExp(
+      userOptions.autoDiscover?.vendorPattern ?? DEFAULT_CONFIG.AUTO_DISCOVER.vendorPattern
+    );
+    const noDist = (id) => {
+      if (id.startsWith(userProjectRoot) || id.startsWith(join(userProjectRoot, outDir)) || id.startsWith(join(outDir, staticDir)) || id.startsWith(join(outDir, serverDir)) || id.startsWith(join(outDir, clientDir))) {
+        return true;
+      }
+      return false;
+    };
+    return {
+      name: `vite-plugin-react-server:transform-${name}`,
+      enforce: "post",
+      // CRITICAL: Enable per-environment hooks during dev to prevent cache contamination
+      perEnvironmentStartEndDuringDev: true,
+      // Note: Removed applyToEnvironment - let transform hook handle filtering
+      // With --app builds, applyToEnvironment may not be called correctly
+      configResolved(config) {
+        isBuild = config.command === "build";
+        isSSR = Boolean(config.build.ssr);
+        mode = config.mode;
+        if (!isValidEnv(mode)) {
+          throw new Error(`Invalid mode: ${mode}`);
+        }
+        const runtimeOptionsResult = resolveOptions({
+          ...userOptions,
+          loader: {
+            ...userOptions.loader,
+            mode
+          }
+        }, true);
+        if (runtimeOptionsResult.type === "success") {
+          runtimeResolvedUserOptions = runtimeOptionsResult.userOptions;
+        }
+        if (runtimeResolvedUserOptions.loader) {
+          runtimeResolvedUserOptions.loader.moduleID = createDefaultModuleID(
+            runtimeResolvedUserOptions,
+            {
+              command: config.command,
+              mode: config.mode},
+            mode
+          );
+        }
+        const logger = config.customLogger || config.logger;
+        if (runtimeResolvedUserOptions.verbose) {
+          logger.info(
+            `${logPrefix} configResolved: isBuild=${isBuild} isSSR=${isSSR} mode=${mode} allowed=${JSON.stringify(
+              allowedEnvironments
+            )} defaultEnv=${defaultEnvironment} importServerPath=${runtimeResolvedUserOptions.loader?.importServerPath}`
+          );
+        }
+      },
+      async buildStart() {
+      },
+      transform: {
+        order: "post",
+        // when transforming to:
+        // dist/server / env=server - it adds registerClientReference and registerServerReference based on directive (ssg portable)
+        // dist/client / env=ssr - removes use client directive and hides server modules, hides client entry or without exports (ssg portable)
+        // dist/static / env=client  -  removes use client directive and hides server modules, emits client entry (and is browser portable)
+        async handler(code, id, { ssr } = {}) {
+          if (nodeModulesPattern.test(id) || !modulePattern.test(id) || !noDist(id)) {
+            return null;
+          }
+          let [, normalizedPath] = resolvedUserOptions.normalizer(id);
+          const normalizedId = id.replace(/\\/g, "/");
+          const normalizedServerDir = serverDir.replace(/\\/g, "/");
+          const normalizedClientDir = clientDir.replace(/\\/g, "/");
+          const isFromServerBuild = normalizedId.includes(`/${normalizedServerDir}/`) || normalizedId.includes(`dist/server/`);
+          const isFromClientBuild = normalizedId.includes(`/${normalizedClientDir}/`) || normalizedId.includes(`dist/client/`);
+          const isFromStaticBuild = normalizedId.includes(`dist/static/`);
+          const isBuiltFile = isBuild && /-[a-zA-Z0-9_]{6,}\.(js|mjs|cjs)$/.test(normalizedId);
+          const isAlreadyTransformed = code.includes(
+            runtimeResolvedUserOptions.loader?.registerClientReferenceName ?? "registerClientReference"
+          );
+          if (isAlreadyTransformed) {
+            if (runtimeResolvedUserOptions.verbose) {
+              this.environment?.logger?.info(
+                `[react-${name}-transform] Encountered already transformed file: ${id}. This indicates two transformers are running on the same file: ${this.environment?.name} and ${Object.entries(this.environment?.plugins ?? {}).map(([name2, plugin]) => `${name2} (${plugin.name})`).join(", ")}`
+              );
+              this.environment?.logger?.info("");
             }
-            return false;
-        };
-        return {
-            name: `vite-plugin-react-server:transform-${name}`,
-            enforce: "post",
-            // CRITICAL: Enable per-environment hooks during dev to prevent cache contamination
-            perEnvironmentStartEndDuringDev: true,
-            // Note: Removed applyToEnvironment - let transform hook handle filtering
-            // With --app builds, applyToEnvironment may not be called correctly
-            configResolved(config) {
-                isBuild = config.command === "build";
-                isSSR = Boolean(config.build.ssr);
-                mode = config.mode;
-                if (!isValidEnv(mode)) {
-                    throw new Error(`Invalid mode: ${mode}`);
-                }
-                // CRITICAL: Re-resolve options with runtime mode to get correct importServerPath
-                // This ensures test mode uses react-server-dom-esm/server.node instead of server
-                // Force re-resolve to avoid cached moduleID functions from different build contexts
-                const runtimeOptionsResult = resolveOptions({
-                    ...userOptions,
-                    loader: {
-                        ...userOptions.loader,
-                        mode: mode,
-                    },
-                }, true); // Force resolve to bypass cache
-                if (runtimeOptionsResult.type === "success") {
-                    runtimeResolvedUserOptions = runtimeOptionsResult.userOptions;
-                }
-                // CRITICAL: Update moduleID function with correct configEnv for build mode
-                // This ensures client component hashing uses the correct build context
-                // ALWAYS recreate the moduleID to ensure it matches the current command
-                if (runtimeResolvedUserOptions.loader) {
-                    runtimeResolvedUserOptions.loader.moduleID = createDefaultModuleID(runtimeResolvedUserOptions, {
-                        command: config.command,
-                        mode: config.mode,
-                        isSsrBuild: isSSR,
-                        isPreview: false,
-                    }, mode);
-                }
-                // Note: condition override is set in env plugin during config phase
-                // Verbose summary (config hook has void context, use config logger)
-                const logger = config.customLogger || config.logger;
-                // Only log in verbose mode
-                if (runtimeResolvedUserOptions.verbose) {
-                    logger.info(`${logPrefix} configResolved: isBuild=${isBuild} isSSR=${isSSR} mode=${mode} allowed=${JSON.stringify(allowedEnvironments)} defaultEnv=${defaultEnvironment} importServerPath=${runtimeResolvedUserOptions.loader?.importServerPath}`);
-                }
-            },
-            async buildStart() {
-                // No longer load static manifest - rely on hash coordination to ensure consistent hashes
-                // This removes the file I/O dependency and allows parallel builds
-            },
-            transform: {
-                order: "post",
-                // when transforming to:
-                // dist/server / env=server - it adds registerClientReference and registerServerReference based on directive (ssg portable)
-                // dist/client / env=ssr - removes use client directive and hides server modules, hides client entry or without exports (ssg portable)
-                // dist/static / env=client  -  removes use client directive and hides server modules, emits client entry (and is browser portable)
-                async handler(code, id, { ssr } = {}) {
-                    if (nodeModulesPattern.test(id) ||
-                        !modulePattern.test(id) ||
-                        !noDist(id)) {
-                        return null;
-                    }
-                    let [, normalizedPath] = resolvedUserOptions.normalizer(id);
-                    // Check if this is a built file that doesn't need transformation
-                    // Normalize paths to handle cross-platform differences
-                    const normalizedId = id.replace(/\\/g, "/");
-                    const normalizedServerDir = serverDir.replace(/\\/g, "/");
-                    const normalizedClientDir = clientDir.replace(/\\/g, "/");
-                    // Check if the file is from a build output directory
-                    const isFromServerBuild = normalizedId.includes(`/${normalizedServerDir}/`) ||
-                        normalizedId.includes(`dist/server/`);
-                    const isFromClientBuild = normalizedId.includes(`/${normalizedClientDir}/`) ||
-                        normalizedId.includes(`dist/client/`);
-                    const isFromStaticBuild = normalizedId.includes(`dist/static/`);
-                    // Check if this looks like a built/hashed file (should never be transformed)
-                    // Built files have hashes and are already processed
-                    const isBuiltFile = isBuild && /-[a-zA-Z0-9_]{6,}\.(js|mjs|cjs)$/.test(normalizedId);
-                    // Check if this file is already transformed (contains registerClientReference)
-                    const isAlreadyTransformed = code.includes(runtimeResolvedUserOptions.loader?.registerClientReferenceName ??
-                        "registerClientReference");
-                    if (isAlreadyTransformed) {
-                        if (runtimeResolvedUserOptions.verbose) {
-                            this.environment?.logger?.info(`[react-${name}-transform] Encountered already transformed file: ${id}. This indicates two transformers are running on the same file: ${this.environment?.name} and ${Object.entries(this.environment?.plugins ?? {})
-                                .map(([name, plugin]) => `${name} (${plugin.name})`)
-                                .join(", ")}`);
-                            this.environment?.logger?.info('');
-                        }
-                        return {
-                            code: code,
-                            map: null,
-                        };
-                    }
-                    // Check if we've already transformed this module to avoid double-hashing
-                    // Include environment context in cache key since different environments need different transformations
-                    const isServerEnv = this.environment?.name === "server";
-                    // CRITICAL: Use per-environment cache to prevent cross-environment contamination
-                    const envCache = transformationCache(this);
-                    const cacheKey = `${normalizedPath}:${isServerEnv ? "server" : "client"}:${code}`;
-                    if (envCache.has(cacheKey)) {
-                        if (runtimeResolvedUserOptions.verbose) {
-                            this.environment?.logger?.info(`[react-${name}-transform] Using cached transformation for: ${normalizedPath} (${isServerEnv ? "server" : "client"}) env=${this.environment?.name}`);
-                        }
-                        return envCache.get(cacheKey);
-                    }
-                    // Get the original source content for consistent hashing
-                    // Read the file directly to ensure we use the original content, not transformed code
-                    let originalSourceContent;
-                    try {
-                        const sourcePath = resolve(userProjectRoot, id);
-                        originalSourceContent = readFileSync(sourcePath, "utf-8");
-                    }
-                    catch (error) {
-                        // Fallback to the provided code if we can't read the file
-                        originalSourceContent = code;
-                    }
-                    // Use the original normalized path for moduleID function calls
-                    // This ensures registerClientReference calls use the correct paths
-                    let finalModuleID = runtimeResolvedUserOptions.loader?.moduleID
-                        ? runtimeResolvedUserOptions.loader.moduleID(normalizedPath, originalSourceContent)
-                        : normalizedPath;
-                    if (runtimeResolvedUserOptions.verbose) {
-                        this.environment?.logger?.info(`[react-${name}-transform] ModuleID transformation: ${normalizedPath} -> ${finalModuleID}`);
-                    }
-                    // Determine if this is a server environment
-                    // Check both the environment name and if we're doing server-side rendering for static generation
-                    const envName = this.environment?.name?.toLowerCase() || "";
-                    const isServerEnvironment = envName === "server" || envName === "rsc" || envName === "react-server";
-                    const transformer = createTransformer({
-                        parseFn: (source) => {
-                            const ast = this.parse(source, {
-                                allowReturnOutsideFunction: true,
-                                jsx: true,
-                            });
-                            return ast;
-                        },
-                        options: {
-                            loader: runtimeResolvedUserOptions.loader,
-                            verbose: runtimeResolvedUserOptions.verbose,
-                            panicThreshold: runtimeResolvedUserOptions.panicThreshold,
-                            logger: this.environment?.logger,
-                            moduleBase: userOptions.moduleBase ?? "",
-                        },
-                        // Pass the actual environment context to the transformer
-                        // Only the actual "server" environment should transform client components to registerClientReference
-                        // SSR environment needs actual React components, not placeholders
-                        isServerEnvironment: isServerEnvironment,
-                        ssr: ssr,
-                    });
-                    // Skip files from output directories that are already built and transformed
-                    // But allow transformation of server-built client components that need registerClientReference
-                    if (isFromServerBuild ||
-                        isFromClientBuild ||
-                        isFromStaticBuild ||
-                        isBuiltFile) {
-                        const buildType = isFromServerBuild
-                            ? "server"
-                            : isFromClientBuild
-                                ? "client"
-                                : isFromStaticBuild
-                                    ? "static"
-                                    : "built";
-                        // Allow transformation of server-built client components
-                        if (isFromServerBuild &&
-                            runtimeResolvedUserOptions.loader?.isClientComponentByName?.(id)) {
-                            if (runtimeResolvedUserOptions.verbose) {
-                                this.environment?.logger?.info(`[react-${name}-transform] Allowing transformation of server-built client component: ${id}`);
-                            }
-                            // Don't skip - let it fall through to transformer
-                        }
-                        else {
-                            if (runtimeResolvedUserOptions.verbose) {
-                                this.environment?.logger?.info(`[react-${name}-transform] Skipping built file from ${buildType} build: ${id}`);
-                            }
-                            return {
-                                code: code,
-                                map: null,
-                            };
-                        }
-                    }
-                    const transformResult = await transformer(code, normalizedPath, finalModuleID);
-                    // If transformer returns null (e.g., for built files), return original code
-                    if (!transformResult) {
-                        return { code, map: null };
-                    }
-                    const { code: transformed, map } = transformResult;
-                    // Store the transformation result in per-environment cache
-                    const result = { code: transformed, map };
-                    envCache.set(cacheKey, result);
-                    // Logging for verbose mode
-                    if (runtimeResolvedUserOptions.verbose) {
-                        const hasDirectives = code.includes('"use client"') ||
-                            code.includes('"use server"') ||
-                            code.includes("'use client'") ||
-                            code.includes("'use server'");
-                        if (transformed !== code) {
-                            this.environment?.logger?.info(`[react-${name}-transform] ` +
-                                id.split("/").pop() +
-                                (code.startsWith('"use client"') ? " (client)" : "") +
-                                (hasDirectives ? " (directives processed)" : ""));
-                            this.environment?.logger?.info(`[react-${name}-transform] ` + transformed.slice(0, 100) + "...");
-                        }
-                        else if (hasDirectives) {
-                            this.environment?.logger?.info(`[react-${name}-transform] ` +
-                                id.split("/").pop() +
-                                " (directives already processed)");
-                        }
-                    }
-                    return result;
-                },
+            return {
+              code,
+              map: null
+            };
+          }
+          const isServerEnv = this.environment?.name === "server";
+          const envCache = transformationCache(this);
+          const cacheKey = `${normalizedPath}:${isServerEnv ? "server" : "client"}:${code}`;
+          if (envCache.has(cacheKey)) {
+            if (runtimeResolvedUserOptions.verbose) {
+              this.environment?.logger?.info(
+                `[react-${name}-transform] Using cached transformation for: ${normalizedPath} (${isServerEnv ? "server" : "client"}) env=${this.environment?.name}`
+              );
+            }
+            return envCache.get(cacheKey);
+          }
+          let originalSourceContent;
+          try {
+            const sourcePath = resolve(userProjectRoot, id);
+            originalSourceContent = readFileSync(sourcePath, "utf-8");
+          } catch (error) {
+            originalSourceContent = code;
+          }
+          let finalModuleID = runtimeResolvedUserOptions.loader?.moduleID ? runtimeResolvedUserOptions.loader.moduleID(
+            normalizedPath,
+            originalSourceContent
+          ) : normalizedPath;
+          if (runtimeResolvedUserOptions.verbose) {
+            this.environment?.logger?.info(
+              `[react-${name}-transform] ModuleID transformation: ${normalizedPath} -> ${finalModuleID}`
+            );
+          }
+          const envName = this.environment?.name?.toLowerCase() || "";
+          const isServerEnvironment = envName === "server" || envName === "rsc" || envName === "react-server";
+          const transformer = createTransformer({
+            options: {
+              loader: runtimeResolvedUserOptions.loader,
+              verbose: runtimeResolvedUserOptions.verbose,
+              panicThreshold: runtimeResolvedUserOptions.panicThreshold,
+              logger: this.environment?.logger,
+              moduleBase: userOptions.moduleBase ?? ""
             },
-        };
+            // Pass the actual environment context to the transformer
+            // Only the actual "server" environment should transform client components to registerClientReference
+            // SSR environment needs actual React components, not placeholders
+            isServerEnvironment});
+          if (isFromServerBuild || isFromClientBuild || isFromStaticBuild || isBuiltFile) {
+            const buildType = isFromServerBuild ? "server" : isFromClientBuild ? "client" : isFromStaticBuild ? "static" : "built";
+            if (isFromServerBuild && runtimeResolvedUserOptions.loader?.isClientComponentByName?.(id)) {
+              if (runtimeResolvedUserOptions.verbose) {
+                this.environment?.logger?.info(
+                  `[react-${name}-transform] Allowing transformation of server-built client component: ${id}`
+                );
+              }
+            } else {
+              if (runtimeResolvedUserOptions.verbose) {
+                this.environment?.logger?.info(
+                  `[react-${name}-transform] Skipping built file from ${buildType} build: ${id}`
+                );
+              }
+              return {
+                code,
+                map: null
+              };
+            }
+          }
+          const transformResult = await transformer(
+            code,
+            normalizedPath,
+            finalModuleID
+          );
+          if (!transformResult) {
+            return { code, map: null };
+          }
+          const { code: transformed, map } = transformResult;
+          const result = { code: transformed, map };
+          envCache.set(cacheKey, result);
+          if (runtimeResolvedUserOptions.verbose) {
+            const hasDirectives = code.includes('"use client"') || code.includes('"use server"') || code.includes("'use client'") || code.includes("'use server'");
+            if (transformed !== code) {
+              this.environment?.logger?.info(
+                `[react-${name}-transform] ` + id.split("/").pop() + (code.startsWith('"use client"') ? " (client)" : "") + (hasDirectives ? " (directives processed)" : "")
+              );
+              this.environment?.logger?.info(
+                `[react-${name}-transform] ` + transformed.slice(0, 100) + "..."
+              );
+            } else if (hasDirectives) {
+              this.environment?.logger?.info(
+                `[react-${name}-transform] ` + id.split("/").pop() + " (directives already processed)"
+              );
+            }
+          }
+          return result;
+        }
+      }
     };
+  };
 };
+
+export { createTransformerPlugin };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"createTransformerPlugin.js","sources":["../../../plugin/transformer/createTransformerPlugin.ts"],"sourcesContent":["import type { Plugin } from \"vite\";\nimport { perEnvironmentState } from \"vite\";\nimport type { VitePluginFn } from \"../types.js\";\nimport { createTransformer } from \"../loader/createTransformer.js\";\nimport type { Program } from \"acorn\";\nimport { resolveOptions } from \"../config/resolveOptions.js\";\nimport { readFileSync } from \"node:fs\";\nimport { resolve, join } from \"node:path\";\nimport { getNodeEnv, isValidEnv } from \"../config/getNodeEnv.js\";\n\n// import { getEnvironmentName } from \"../env/plugin.js\";\nimport { DEFAULT_CONFIG } from \"../config/defaults.js\";\nimport { resolveRegExp } from \"../config/resolveRegExp.js\";\nimport { userProjectRoot } from \"../root.js\";\nimport { createDefaultModuleID } from \"../config/createModuleID.js\";\n\nexport interface TransformerPluginOptions {\n  name: string;\n  /**\n   * Optional. If omitted, sensible defaults are applied based on `name`:\n   * - name === \"client\" -> [\"client\", \"ssr\"]\n   * - name === \"server\" -> [\"server\"]\n   */\n  allowedEnvironments?: (\"client\" | \"server\" | \"ssr\")[];\n  /**\n   * Optional. If omitted, sensible defaults are applied based on `name`:\n   * - name === \"client\" -> \"client\"\n   * - name === \"server\" -> \"server\"\n   */\n  defaultEnvironment?: \"client\" | \"server\" | \"ssr\";\n}\n\nexport const createTransformerPlugin = (\n  options: TransformerPluginOptions\n): VitePluginFn => {\n  return (userOptions) => {\n    const { name } = options;\n\n    // CRITICAL: Use per-environment state to prevent cross-environment cache contamination\n    // This fixes the issue where server environment cached modules affect client environment builds\n    const transformationCache = perEnvironmentState<\n      Map<string, { code: string; map: any }>\n    >(() => new Map());\n    const defaultEnvironment =\n      options.defaultEnvironment ?? (name === \"client\" ? \"client\" : \"server\");\n    const allowedEnvironments =\n      options.allowedEnvironments ??\n      (name === \"client\"\n        ? defaultEnvironment === \"client\"\n          ? [\"client\", \"ssr\"]\n          : [\"client\"]\n        : defaultEnvironment === \"server\"\n        ? [\"server\", \"ssr\"]\n        : [\"server\"]);\n    const logPrefix = `[vite-plugin-react-server:transform-${defaultEnvironment}-as-${name}]`;\n\n    const resolvedOptionsResult = resolveOptions(userOptions);\n    if (resolvedOptionsResult.type === \"error\")\n      throw resolvedOptionsResult.error;\n    const { userOptions: resolvedUserOptions } = resolvedOptionsResult;\n\n    let isBuild = true;\n    let isSSR = true;\n    const nodeEnv = getNodeEnv(process.env.NODE_ENV);\n    let mode = nodeEnv;\n    let runtimeResolvedUserOptions = resolvedUserOptions;\n\n    // Use global cache for transformation results to ensure consistent hashing across all plugin instances\n    const outDir = resolvedUserOptions.build.outDir || \"dist\";\n    const serverDir = join(\n      outDir,\n      resolvedUserOptions.build.server || \"server\"\n    );\n    const clientDir = join(\n      outDir,\n      resolvedUserOptions.build.client || \"client\"\n    );\n    const staticDir = join(\n      outDir,\n      resolvedUserOptions.build.static || \"static\"\n    );\n    const modulePattern = resolveRegExp(\n      userOptions.autoDiscover?.modulePattern ??\n        DEFAULT_CONFIG.AUTO_DISCOVER.modulePattern\n    );\n    const nodeModulesPattern = resolveRegExp(\n      userOptions.autoDiscover?.vendorPattern ??\n        DEFAULT_CONFIG.AUTO_DISCOVER.vendorPattern\n    );\n    const noDist = (id: string) => {\n      // Allow files from test fixtures and project root\n      if (\n        id.startsWith(userProjectRoot) ||\n        id.startsWith(join(userProjectRoot, outDir)) ||\n        id.startsWith(join(outDir, staticDir)) ||\n        id.startsWith(join(outDir, serverDir)) ||\n        id.startsWith(join(outDir, clientDir))\n      ) {\n        return true;\n      }\n      return false;\n    };\n\n    return {\n      name: `vite-plugin-react-server:transform-${name}`,\n      enforce: \"post\",\n      // CRITICAL: Enable per-environment hooks during dev to prevent cache contamination\n      perEnvironmentStartEndDuringDev: true,\n      // Note: Removed applyToEnvironment - let transform hook handle filtering\n      // With --app builds, applyToEnvironment may not be called correctly\n      configResolved(config) {\n        isBuild = config.command === \"build\";\n        isSSR = Boolean(config.build.ssr);\n        mode = config.mode as \"development\" | \"production\" | \"test\";\n        if (!isValidEnv(mode)) {\n          throw new Error(`Invalid mode: ${mode}`);\n        }\n\n        // CRITICAL: Re-resolve options with runtime mode to get correct importServerPath\n        // This ensures test mode uses react-server-dom-esm/server.node instead of server\n        // Force re-resolve to avoid cached moduleID functions from different build contexts\n        const runtimeOptionsResult = resolveOptions({\n          ...userOptions,\n          loader: {\n            ...userOptions.loader,\n            mode: mode,\n          },\n        }, true); // Force resolve to bypass cache\n        if (runtimeOptionsResult.type === \"success\") {\n          runtimeResolvedUserOptions = runtimeOptionsResult.userOptions;\n        }\n\n        // CRITICAL: Update moduleID function with correct configEnv for build mode\n        // This ensures client component hashing uses the correct build context\n        // ALWAYS recreate the moduleID to ensure it matches the current command\n        if (runtimeResolvedUserOptions.loader) {\n          runtimeResolvedUserOptions.loader.moduleID = createDefaultModuleID(\n            runtimeResolvedUserOptions,\n            {\n              command: config.command,\n              mode: config.mode,\n              isSsrBuild: isSSR,\n              isPreview: false,\n            },\n            mode\n          );\n        }\n\n        // Note: condition override is set in env plugin during config phase\n        // Verbose summary (config hook has void context, use config logger)\n        const logger = config.customLogger || config.logger;\n        // Only log in verbose mode\n        if (runtimeResolvedUserOptions.verbose) {\n          logger.info(\n            `${logPrefix} configResolved: isBuild=${isBuild} isSSR=${isSSR} mode=${mode} allowed=${JSON.stringify(\n              allowedEnvironments\n            )} defaultEnv=${defaultEnvironment} importServerPath=${\n              runtimeResolvedUserOptions.loader?.importServerPath\n            }`\n          );\n        }\n      },\n      async buildStart() {\n        // No longer load static manifest - rely on hash coordination to ensure consistent hashes\n        // This removes the file I/O dependency and allows parallel builds\n      },\n      transform: {\n        order: \"post\",\n        // when transforming to:\n        // dist/server / env=server - it adds registerClientReference and registerServerReference based on directive (ssg portable)\n        // dist/client / env=ssr - removes use client directive and hides server modules, hides client entry or without exports (ssg portable)\n        // dist/static / env=client  -  removes use client directive and hides server modules, emits client entry (and is browser portable)\n        async handler(code, id, { ssr } = {}) {\n          if (\n            nodeModulesPattern.test(id) ||\n            !modulePattern.test(id) ||\n            !noDist(id)\n          ) {\n            return null;\n          }\n          let [, normalizedPath] = resolvedUserOptions.normalizer(id);\n\n          // Check if this is a built file that doesn't need transformation\n          // Normalize paths to handle cross-platform differences\n          const normalizedId = id.replace(/\\\\/g, \"/\");\n          const normalizedServerDir = serverDir.replace(/\\\\/g, \"/\");\n          const normalizedClientDir = clientDir.replace(/\\\\/g, \"/\");\n\n          // Check if the file is from a build output directory\n          const isFromServerBuild =\n            normalizedId.includes(`/${normalizedServerDir}/`) ||\n            normalizedId.includes(`dist/server/`);\n          const isFromClientBuild =\n            normalizedId.includes(`/${normalizedClientDir}/`) ||\n            normalizedId.includes(`dist/client/`);\n          const isFromStaticBuild = normalizedId.includes(`dist/static/`);\n\n          // Check if this looks like a built/hashed file (should never be transformed)\n          // Built files have hashes and are already processed\n          const isBuiltFile =\n            isBuild && /-[a-zA-Z0-9_]{6,}\\.(js|mjs|cjs)$/.test(normalizedId);\n\n          // Check if this file is already transformed (contains registerClientReference)\n          const isAlreadyTransformed = code.includes(\n            runtimeResolvedUserOptions.loader?.registerClientReferenceName ??\n              \"registerClientReference\"\n          );\n          if (isAlreadyTransformed) {\n            if (runtimeResolvedUserOptions.verbose) {\n              this.environment?.logger?.info(\n                `[react-${name}-transform] Encountered already transformed file: ${id}. This indicates two transformers are running on the same file: ${\n                  this.environment?.name\n                } and ${Object.entries(this.environment?.plugins ?? {})\n                  .map(([name, plugin]) => `${name} (${plugin.name})`)\n                  .join(\", \")}`\n              );\n              this.environment?.logger?.info('')\n            }\n            return {\n              code: code,\n              map: null,\n            };\n          }\n\n          // Check if we've already transformed this module to avoid double-hashing\n          // Include environment context in cache key since different environments need different transformations\n          const isServerEnv = this.environment?.name === \"server\";\n          // CRITICAL: Use per-environment cache to prevent cross-environment contamination\n          const envCache = transformationCache(this);\n          const cacheKey = `${normalizedPath}:${\n            isServerEnv ? \"server\" : \"client\"\n          }:${code}`;\n          if (envCache.has(cacheKey)) {\n            if (runtimeResolvedUserOptions.verbose) {\n              this.environment?.logger?.info(\n                `[react-${name}-transform] Using cached transformation for: ${normalizedPath} (${\n                  isServerEnv ? \"server\" : \"client\"\n                }) env=${this.environment?.name}`\n              );\n            }\n            return envCache.get(cacheKey);\n          }\n\n          // Get the original source content for consistent hashing\n          // Read the file directly to ensure we use the original content, not transformed code\n          let originalSourceContent: string;\n          try {\n            const sourcePath = resolve(userProjectRoot, id);\n            originalSourceContent = readFileSync(sourcePath, \"utf-8\");\n          } catch (error) {\n            // Fallback to the provided code if we can't read the file\n            originalSourceContent = code;\n          }\n\n          // Use the original normalized path for moduleID function calls\n          // This ensures registerClientReference calls use the correct paths\n          let finalModuleID = runtimeResolvedUserOptions.loader?.moduleID\n            ? runtimeResolvedUserOptions.loader.moduleID(\n                normalizedPath,\n                originalSourceContent\n              )\n            : normalizedPath;\n\n          if (runtimeResolvedUserOptions.verbose) {\n            this.environment?.logger?.info(\n              `[react-${name}-transform] ModuleID transformation: ${normalizedPath} -> ${finalModuleID}`\n            );\n          }\n\n          // Determine if this is a server environment\n          // Check both the environment name and if we're doing server-side rendering for static generation\n          const envName = this.environment?.name?.toLowerCase() || \"\";\n          const isServerEnvironment = envName === \"server\" || envName === \"rsc\" || envName === \"react-server\";\n\n          const transformer = createTransformer({\n            parseFn: (source) => {\n              const ast = this.parse(source, {\n                allowReturnOutsideFunction: true,\n                jsx: true,\n              }) as Program;\n              return ast;\n            },\n            options: {\n              loader: runtimeResolvedUserOptions.loader,\n              verbose: runtimeResolvedUserOptions.verbose,\n              panicThreshold: runtimeResolvedUserOptions.panicThreshold,\n              logger: this.environment?.logger,\n              moduleBase: userOptions.moduleBase ?? \"\",\n            },\n\n            // Pass the actual environment context to the transformer\n            // Only the actual \"server\" environment should transform client components to registerClientReference\n            // SSR environment needs actual React components, not placeholders\n            isServerEnvironment: isServerEnvironment,\n            ssr: ssr,\n          });\n\n          // Skip files from output directories that are already built and transformed\n          // But allow transformation of server-built client components that need registerClientReference\n\n          if (\n            isFromServerBuild ||\n            isFromClientBuild ||\n            isFromStaticBuild ||\n            isBuiltFile\n          ) {\n            const buildType = isFromServerBuild\n              ? \"server\"\n              : isFromClientBuild\n              ? \"client\"\n              : isFromStaticBuild\n              ? \"static\"\n              : \"built\";\n\n            // Allow transformation of server-built client components\n            if (\n              isFromServerBuild &&\n              runtimeResolvedUserOptions.loader?.isClientComponentByName?.(id)\n            ) {\n              if (runtimeResolvedUserOptions.verbose) {\n                this.environment?.logger?.info(\n                  `[react-${name}-transform] Allowing transformation of server-built client component: ${id}`\n                );\n              }\n              // Don't skip - let it fall through to transformer\n            } else {\n              if (runtimeResolvedUserOptions.verbose) {\n                this.environment?.logger?.info(\n                  `[react-${name}-transform] Skipping built file from ${buildType} build: ${id}`\n                );\n              }\n              return {\n                code: code,\n                map: null,\n              };\n            }\n          }\n\n          const transformResult = await transformer(\n            code,\n            normalizedPath,\n            finalModuleID\n          );\n\n          // If transformer returns null (e.g., for built files), return original code\n          if (!transformResult) {\n            return { code, map: null };\n          }\n\n          const { code: transformed, map } = transformResult;\n\n          // Store the transformation result in per-environment cache\n          const result = { code: transformed, map };\n          envCache.set(cacheKey, result);\n\n          // Logging for verbose mode\n          if (runtimeResolvedUserOptions.verbose) {\n            const hasDirectives =\n              code.includes('\"use client\"') ||\n              code.includes('\"use server\"') ||\n              code.includes(\"'use client'\") ||\n              code.includes(\"'use server'\");\n\n            if (transformed !== code) {\n              this.environment?.logger?.info(\n                `[react-${name}-transform] ` +\n                  id.split(\"/\").pop() +\n                  (code.startsWith('\"use client\"') ? \" (client)\" : \"\") +\n                  (hasDirectives ? \" (directives processed)\" : \"\")\n              );\n              this.environment?.logger?.info(\n                `[react-${name}-transform] ` + transformed.slice(0, 100) + \"...\"\n              );\n            } else if (hasDirectives) {\n              this.environment?.logger?.info(\n                `[react-${name}-transform] ` +\n                  id.split(\"/\").pop() +\n                  \" (directives already processed)\"\n              );\n            }\n          }\n\n          return result;\n        },\n      },\n    } as Plugin;\n  };\n};\n"],"names":["name"],"mappings":"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"}

package/dist/plugin/utils/checkReactVersion.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Verify React experimental is available. The vendored react-server-dom-esm
+ * transport requires Taint APIs that only exist in React experimental builds.
+ * Stable React 19.x causes: "Cannot read properties of undefined (reading 'add')"
+ */
+export declare function checkReactExperimental(): void;
+//# sourceMappingURL=checkReactVersion.d.ts.map

package/dist/plugin/utils/checkReactVersion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkReactVersion.d.ts","sourceRoot":"","sources":["../../../plugin/utils/checkReactVersion.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,wBAAgB,sBAAsB,SAoBrC"}

package/dist/plugin/utils/checkReactVersion.js

@@ -0,0 +1,23 @@
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+let checked = false;
+function checkReactExperimental() {
+  if (checked) return;
+  checked = true;
+  try {
+    const version = globalThis.process?.versions ? require("react").version : "";
+    if (version && !version.includes("experimental")) {
+      throw new Error(
+        `[vite-plugin-react-server] React ${version} is not supported. This plugin requires React experimental builds. Install with: npm install react@experimental react-dom@experimental`
+      );
+    }
+  } catch (e) {
+    if (e instanceof Error && e.message.includes("not supported")) throw e;
+  }
+}
+
+export { checkReactExperimental };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlY2tSZWFjdFZlcnNpb24uanMiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3BsdWdpbi91dGlscy9jaGVja1JlYWN0VmVyc2lvbi50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJsZXQgY2hlY2tlZCA9IGZhbHNlO1xuXG4vKipcbiAqIFZlcmlmeSBSZWFjdCBleHBlcmltZW50YWwgaXMgYXZhaWxhYmxlLiBUaGUgdmVuZG9yZWQgcmVhY3Qtc2VydmVyLWRvbS1lc21cbiAqIHRyYW5zcG9ydCByZXF1aXJlcyBUYWludCBBUElzIHRoYXQgb25seSBleGlzdCBpbiBSZWFjdCBleHBlcmltZW50YWwgYnVpbGRzLlxuICogU3RhYmxlIFJlYWN0IDE5LnggY2F1c2VzOiBcIkNhbm5vdCByZWFkIHByb3BlcnRpZXMgb2YgdW5kZWZpbmVkIChyZWFkaW5nICdhZGQnKVwiXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBjaGVja1JlYWN0RXhwZXJpbWVudGFsKCkge1xuICBpZiAoY2hlY2tlZCkgcmV0dXJuO1xuICBjaGVja2VkID0gdHJ1ZTtcbiAgXG4gIHRyeSB7XG4gICAgLy8gVXNlIHJlcXVpcmUgZm9yIHN5bmMgYWNjZXNzIOKAlCBSZWFjdCBpcyBhbHdheXMgYXZhaWxhYmxlIGF0IHRoaXMgcG9pbnRcbiAgICBjb25zdCB2ZXJzaW9uOiBzdHJpbmcgPSBnbG9iYWxUaGlzLnByb2Nlc3M/LnZlcnNpb25zXG4gICAgICA/IHJlcXVpcmUoXCJyZWFjdFwiKS52ZXJzaW9uXG4gICAgICA6IFwiXCI7XG4gICAgXG4gICAgaWYgKHZlcnNpb24gJiYgIXZlcnNpb24uaW5jbHVkZXMoXCJleHBlcmltZW50YWxcIikpIHtcbiAgICAgIHRocm93IG5ldyBFcnJvcihcbiAgICAgICAgYFt2aXRlLXBsdWdpbi1yZWFjdC1zZXJ2ZXJdIFJlYWN0ICR7dmVyc2lvbn0gaXMgbm90IHN1cHBvcnRlZC4gYCArXG4gICAgICAgIGBUaGlzIHBsdWdpbiByZXF1aXJlcyBSZWFjdCBleHBlcmltZW50YWwgYnVpbGRzLiBgICtcbiAgICAgICAgYEluc3RhbGwgd2l0aDogbnBtIGluc3RhbGwgcmVhY3RAZXhwZXJpbWVudGFsIHJlYWN0LWRvbUBleHBlcmltZW50YWxgXG4gICAgICApO1xuICAgIH1cbiAgfSBjYXRjaCAoZTogdW5rbm93bikge1xuICAgIGlmIChlIGluc3RhbmNlb2YgRXJyb3IgJiYgZS5tZXNzYWdlLmluY2x1ZGVzKFwibm90IHN1cHBvcnRlZFwiKSkgdGhyb3cgZTtcbiAgfVxufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEsSUFBSSxPQUFVLEdBQUEsS0FBQTtBQU9QLFNBQVMsc0JBQXlCLEdBQUE7QUFDdkMsRUFBQSxJQUFJLE9BQVMsRUFBQTtBQUNiLEVBQVUsT0FBQSxHQUFBLElBQUE7QUFFVixFQUFJLElBQUE7QUFFRixJQUFBLE1BQU0sVUFBa0IsVUFBVyxDQUFBLE9BQUEsRUFBUyxXQUN4QyxPQUFRLENBQUEsT0FBTyxFQUFFLE9BQ2pCLEdBQUEsRUFBQTtBQUVKLElBQUEsSUFBSSxPQUFXLElBQUEsQ0FBQyxPQUFRLENBQUEsUUFBQSxDQUFTLGNBQWMsQ0FBRyxFQUFBO0FBQ2hELE1BQUEsTUFBTSxJQUFJLEtBQUE7QUFBQSxRQUNSLG9DQUFvQyxPQUFPLENBQUEsc0lBQUE7QUFBQSxPQUc3QztBQUFBO0FBQ0YsV0FDTyxDQUFZLEVBQUE7QUFDbkIsSUFBQSxJQUFJLGFBQWEsS0FBUyxJQUFBLENBQUEsQ0FBRSxRQUFRLFFBQVMsQ0FBQSxlQUFlLEdBQVMsTUFBQSxDQUFBO0FBQUE7QUFFekU7Ozs7In0=