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

package/dist/plugin/helpers/workerCleanup.d.ts

@@ -0,0 +1,29 @@
+import type { Worker, MessagePort } from "node:worker_threads";
+/**
+ * Centralized worker cleanup utilities
+ * Provides consistent cleanup patterns across the codebase
+ */
+export interface WorkerCleanupOptions {
+    /** Whether to terminate the worker (default: true) */
+    terminate?: boolean;
+    /** Whether to remove all listeners (default: true) */
+    removeListeners?: boolean;
+    /** Whether to log cleanup errors (default: false) */
+    logErrors?: boolean;
+}
+/**
+ * Safely cleans up a worker with consistent error handling
+ */
+export declare function cleanupWorker(worker: Worker | null | undefined, options?: WorkerCleanupOptions): void;
+/**
+ * Safely cleans up MessagePorts with consistent error handling
+ */
+export declare function cleanupMessagePorts(ports: (MessagePort | null | undefined)[], options?: {
+    logErrors?: boolean;
+}): void;
+/**
+ * Comprehensive cleanup for worker + MessagePorts combination
+ * This is the most common cleanup pattern in the codebase
+ */
+export declare function cleanupWorkerAndPorts(worker: Worker | null | undefined, ports: (MessagePort | null | undefined)[], options?: WorkerCleanupOptions): void;
+//# sourceMappingURL=workerCleanup.d.ts.map

package/dist/plugin/helpers/workerCleanup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workerCleanup.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/workerCleanup.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAE/D;;;GAGG;AAEH,MAAM,WAAW,oBAAoB;IACnC,sDAAsD;IACtD,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,sDAAsD;IACtD,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,qDAAqD;IACrD,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACjC,OAAO,GAAE,oBAAyB,GACjC,IAAI,CAuBN;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,CAAC,WAAW,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,EACzC,OAAO,GAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAO,GACpC,IAAI,CAkBN;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACjC,KAAK,EAAE,CAAC,WAAW,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,EACzC,OAAO,GAAE,oBAAyB,GACjC,IAAI,CAGN"}

package/dist/plugin/helpers/workerCleanup.js

@@ -0,0 +1,28 @@
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+function cleanupWorker(worker, options = {}) {
+  if (!worker) return;
+  const {
+    terminate = true,
+    removeListeners = true,
+    logErrors = false
+  } = options;
+  try {
+    if (removeListeners) {
+      worker.removeAllListeners();
+    }
+    if (terminate) {
+      worker.terminate();
+    }
+  } catch (error) {
+    if (logErrors) {
+      console.warn("[workerCleanup] Error during worker cleanup:", error);
+    }
+  }
+}
+
+export { cleanupWorker };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/plugin/helpers/workerManager.d.ts

@@ -0,0 +1,5 @@
+import type { Worker } from "node:worker_threads";
+export declare const setWorker: (w: Worker | null) => void;
+export declare const getWorker: () => Worker | null;
+export declare const clearWorker: () => void;
+//# sourceMappingURL=workerManager.d.ts.map

package/dist/plugin/helpers/workerManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workerManager.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/workerManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAKlD,eAAO,MAAM,SAAS,GAAI,GAAG,MAAM,GAAG,IAAI,SAEzC,CAAC;AAEF,eAAO,MAAM,SAAS,QAAO,MAAM,GAAG,IAErC,CAAC;AAEF,eAAO,MAAM,WAAW,YAEvB,CAAC"}

package/dist/plugin/helpers/workerManager.js

@@ -0,0 +1,18 @@
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+let worker = null;
+const setWorker = (w) => {
+  worker = w;
+};
+const getWorker = () => {
+  return worker;
+};
+const clearWorker = () => {
+  worker = null;
+};
+
+export { clearWorker, getWorker, setWorker };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ya2VyTWFuYWdlci5qcyIsInNvdXJjZXMiOlsiLi4vLi4vLi4vcGx1Z2luL2hlbHBlcnMvd29ya2VyTWFuYWdlci50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IFdvcmtlciB9IGZyb20gXCJub2RlOndvcmtlcl90aHJlYWRzXCI7XG5cbi8vIFNpbXBsZSBtb2R1bGUtbGV2ZWwgd29ya2VyIHJlZmVyZW5jZSBmb3IgZGV2IHNlcnZlciBjb250ZXh0XG5sZXQgd29ya2VyOiBXb3JrZXIgfCBudWxsID0gbnVsbDtcblxuZXhwb3J0IGNvbnN0IHNldFdvcmtlciA9ICh3OiBXb3JrZXIgfCBudWxsKSA9PiB7XG4gIHdvcmtlciA9IHc7XG59O1xuXG5leHBvcnQgY29uc3QgZ2V0V29ya2VyID0gKCk6IFdvcmtlciB8IG51bGwgPT4ge1xuICByZXR1cm4gd29ya2VyO1xufTtcblxuZXhwb3J0IGNvbnN0IGNsZWFyV29ya2VyID0gKCkgPT4ge1xuICB3b3JrZXIgPSBudWxsO1xufTsgIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBR0EsSUFBSSxNQUF3QixHQUFBLElBQUE7QUFFZixNQUFBLFNBQUEsR0FBWSxDQUFDLENBQXFCLEtBQUE7QUFDN0MsRUFBUyxNQUFBLEdBQUEsQ0FBQTtBQUNYO0FBRU8sTUFBTSxZQUFZLE1BQXFCO0FBQzVDLEVBQU8sT0FBQSxNQUFBO0FBQ1Q7QUFFTyxNQUFNLGNBQWMsTUFBTTtBQUMvQixFQUFTLE1BQUEsR0FBQSxJQUFBO0FBQ1g7Ozs7In0=

package/dist/plugin/index.d.ts

@@ -1,2 +1,5 @@
-export declare const vitePluginReactServer: any;
+import type { VitePluginMainFn } from './types.js';
+export declare const condition: "client" | "server";
+export declare const vitePluginReactServer: VitePluginMainFn, vitePluginReactClient: VitePluginMainFn;
+export { createPluginOrchestrator } from './orchestrator/createPluginOrchestrator.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/plugin/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../plugin/index.ts"],"names":[],"mappings":"AAIA,eAAO,MAAQ,qBAAqB,KAA6C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../plugin/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD,eAAO,MAAM,SAAS,qBAAmB,CAAC;AAC1C,eAAO,MAAQ,qBAAqB,oBAAE,qBAAqB,kBAAmJ,CAAC;AAG/M,OAAO,EAAE,wBAAwB,EAAE,MAAM,4CAA4C,CAAC"}

package/dist/plugin/index.js

@@ -1,3 +1,6 @@
 import { getCondition } from './config/getCondition.js';
-const condition = getCondition('');
-export const { vitePluginReactServer } = await import(`./plugin.${condition}.js`);
+import { pluginRoot } from './root.js';
+export const condition = getCondition('');
+export const { vitePluginReactServer, vitePluginReactClient } = (await import(`${pluginRoot}/plugin.${condition}.js`));
+// Export the orchestrator for direct use
+export { createPluginOrchestrator } from './orchestrator/createPluginOrchestrator.js';

package/dist/plugin/loader/createDefaultLoader.d.ts

@@ -20,5 +20,5 @@ export type Loader = {
  *    - Returns a loader function that takes a module ID and returns a LoaderResult
  *    - Used by the plugin to create loaders for different environments
  */
-export declare function createDefaultLoader(defaultSource: string, defaultId?: string, verbose?: boolean): (url: string, context?: Partial<LoadHookContext>, nextLoad?: (url: string, context?: Partial<LoadHookContext>) => LoadFnOutput | Promise<LoadFnOutput>) => Promise<LoadFnOutput>;
+export declare function createDefaultLoader(defaultSource: string, defaultId?: string): (url: string, context?: Partial<LoadHookContext>, nextLoad?: (url: string, context?: Partial<LoadHookContext>) => LoadFnOutput | Promise<LoadFnOutput>) => Promise<LoadFnOutput>;
 //# sourceMappingURL=createDefaultLoader.d.ts.map

package/dist/plugin/loader/createDefaultLoader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createDefaultLoader.d.ts","sourceRoot":"","sources":["../../../plugin/loader/createDefaultLoader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAKjE,MAAM,MAAM,YAAY,GAAG;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,YAAY,GAAG,IAAI,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,MAAM,GAAG;IACnB,CACE,EAAE,EAAE,MAAM,EACV,OAAO,CAAC,EAAE,aAAa,EACvB,QAAQ,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,CAAC,GAC/C,YAAY,CAAC;CACjB,CAAC;AAgBF;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CACjC,aAAa,EAAE,MAAM,EACrB,SAAS,SAAU,EACnB,OAAO,UAAQ,GACd,CACD,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,EAClC,QAAQ,CAAC,EAAE,CACT,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,KAC/B,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,KACtC,OAAO,CAAC,YAAY,CAAC,CAgFzB"}
+{"version":3,"file":"createDefaultLoader.d.ts","sourceRoot":"","sources":["../../../plugin/loader/createDefaultLoader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAKjE,MAAM,MAAM,YAAY,GAAG;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,YAAY,GAAG,IAAI,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,MAAM,GAAG;IACnB,CACE,EAAE,EAAE,MAAM,EACV,OAAO,CAAC,EAAE,aAAa,EACvB,QAAQ,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,CAAC,GAC/C,YAAY,CAAC;CACjB,CAAC;AAgBF;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CACjC,aAAa,EAAE,MAAM,EACrB,SAAS,SAAU,GAClB,CACD,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,EAClC,QAAQ,CAAC,EAAE,CACT,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,KAC/B,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,KACtC,OAAO,CAAC,YAAY,CAAC,CA4DzB"}

package/dist/plugin/loader/createDefaultLoader.js

@@ -18,7 +18,7 @@ const defaultNextLoad = async (url) => {
     map: result.map
   };
 };
-function createDefaultLoader(defaultSource, defaultId = "index", verbose = false) {
+function createDefaultLoader(defaultSource, defaultId = "index") {
   const defaultSourceNextLoad = typeof defaultSource === "string" ? async (url = defaultId) => {
     const result = await transformWithEsbuild(defaultSource, url, {
       loader: "tsx",
@@ -36,38 +36,18 @@ function createDefaultLoader(defaultSource, defaultId = "index", verbose = false
     conditions: ["react-server"],
     importAttributes: {}
   }, nextLoad = defaultSourceNextLoad) => {
-    if (verbose) {
-      console.log("[createDefaultLoader] Loading:", url);
-      console.log("[createDefaultLoader] Context:", {
-        format: context.format,
-        conditions: context.conditions
-      });
-    }
     const { format } = context;
     if (format === "module" || format === "module-typescript") {
-      if (verbose) {
-        console.log("[createDefaultLoader] Loading module:", url);
-      }
       const result = await nextLoad(url, context);
-      if (verbose) {
-        console.log("[createDefaultLoader] Next load result:", {
-          format: result.format,
-          shortCircuit: result.shortCircuit,
-          source: typeof result.source
-        });
-      }
       const source = typeof result.source === "string" ? result.source : result.source instanceof Uint8Array || result.source instanceof ArrayBuffer || result.source instanceof Uint8ClampedArray || result.source instanceof Uint16Array || result.source instanceof Uint32Array || result.source instanceof Int8Array || result.source instanceof Int16Array || result.source instanceof Int32Array || result.source instanceof Float32Array || result.source instanceof Float64Array || result.source instanceof BigUint64Array || result.source instanceof BigInt64Array ? new TextDecoder().decode(result.source) : defaultSource;
       return {
         ...result,
         source
       };
     }
-    if (verbose) {
-      console.log("[createDefaultLoader] Skipping non-module format:", format);
-    }
     return nextLoad(url, context);
   };
 }
 
 export { createDefaultLoader };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"createDefaultLoader.js","sources":["../../../plugin/loader/createDefaultLoader.ts"],"sourcesContent":["import type { LoaderContext } from \"../types.js\";\nimport type { RawSourceMap } from \"source-map\";\nimport type { LoadFnOutput, LoadHookContext } from \"node:module\";\nimport type { LoadHook } from \"node:module\";\nimport { transformWithEsbuild } from \"vite\";\nimport { readFile } from \"node:fs/promises\";\n\nexport type LoaderResult = {\n  source: string;\n  map: RawSourceMap | null;\n};\n\nexport type Loader = {\n  (\n    id: string,\n    context?: LoaderContext,\n    nextLoad?: (id: string) => Promise<LoaderResult>\n  ): LoaderResult;\n};\n\n\nconst defaultNextLoad: Parameters<LoadHook>[2] = async (url) => {\n  const result = await transformWithEsbuild(await readFile(url, \"utf-8\"), url, {\n    loader: \"tsx\",\n    format: \"esm\",\n    sourcemap: \"external\",\n  });\n  return {\n    source: result.code,\n    format: \"module\",\n    map: result.map,\n  };\n};\n\n/**\n * Creates a loader function that transforms modules and handles source maps.\n * This function can be used in two ways:\n *\n * 1. As a direct transformer:\n *    - Takes source code and returns transformed code with source map attached\n *    - Used by transformModuleIfNeeded\n *\n * 2. As a loader factory:\n *    - Returns a loader function that takes a module ID and returns a LoaderResult\n *    - Used by the plugin to create loaders for different environments\n */\nexport function createDefaultLoader(\n  defaultSource: string,\n  defaultId = \"index\",\n  verbose = false\n): (\n  url: string,\n  context?: Partial<LoadHookContext>,\n  nextLoad?: (\n    url: string,\n    context?: Partial<LoadHookContext>\n  ) => LoadFnOutput | Promise<LoadFnOutput>\n) => Promise<LoadFnOutput> {\n\n  const defaultSourceNextLoad: Parameters<LoadHook>[2] =\n    typeof defaultSource === \"string\"\n      ? async (url = defaultId) => {\n          const result = await transformWithEsbuild(defaultSource, url, {\n            loader: \"tsx\",\n            format: \"esm\",\n            sourcemap: \"external\",\n          });\n          return {\n            source: result.code,\n            format: \"module\",\n            map: result.map,\n          };\n        }\n      : defaultNextLoad;\n\n  return async (\n    url = defaultId,\n    context = {\n      format: \"module\",\n      conditions: [\"react-server\"],\n      importAttributes: {},\n    },\n    nextLoad = defaultSourceNextLoad\n  ) => {\n    if (verbose) {\n      console.log(\"[createDefaultLoader] Loading:\", url);\n      console.log(\"[createDefaultLoader] Context:\", {\n        format: context.format,\n        conditions: context.conditions,\n      });\n    }\n\n    const { format } = context;\n    if (format === \"module\" || format === \"module-typescript\") {\n      if (verbose) {\n        console.log(\"[createDefaultLoader] Loading module:\", url);\n      }\n\n      const result = await nextLoad(url, context);\n      if (verbose) {\n        console.log(\"[createDefaultLoader] Next load result:\", {\n          format: result.format,\n          shortCircuit: result.shortCircuit,\n          source: typeof result.source,\n        });\n      }\n\n      const source =\n        typeof result.source === \"string\"\n          ? result.source\n          : result.source instanceof Uint8Array ||\n            result.source instanceof ArrayBuffer ||\n            result.source instanceof Uint8ClampedArray ||\n            result.source instanceof Uint16Array ||\n            result.source instanceof Uint32Array ||\n            result.source instanceof Int8Array ||\n            result.source instanceof Int16Array ||\n            result.source instanceof Int32Array ||\n            result.source instanceof Float32Array ||\n            result.source instanceof Float64Array ||\n            result.source instanceof BigUint64Array ||\n            result.source instanceof BigInt64Array\n          ? new TextDecoder().decode(result.source)\n          : defaultSource;\n\n\n      return {\n        ...result,\n        source: source,\n      };\n    }\n\n    if (verbose) {\n      console.log(\"[createDefaultLoader] Skipping non-module format:\", format);\n    }\n    return nextLoad(url, context);\n  };\n}\n"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/plugin/loader/createTransformer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createTransformer.d.ts","sourceRoot":"","sources":["../../../plugin/loader/createTransformer.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,kBAAkB,EAAmB,MAAM,YAAY,CAAC;AAItE;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,kBAiG/B,CAAC"}
+{"version":3,"file":"createTransformer.d.ts","sourceRoot":"","sources":["../../../plugin/loader/createTransformer.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,kBAAkB,EAAmB,MAAM,YAAY,CAAC;AAOtE;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,kBA+R/B,CAAC"}

package/dist/plugin/loader/createTransformer.js

@@ -4,21 +4,41 @@
  * MIT License
  */
 import { transformModule } from './transformModule.js';
+import { transformNonServerEnvironment } from './transformNonServerEnvironment.js';
 import { isReactServerCondition } from '../config/getCondition.js';
 import { analyzeModule } from './directives/analyzeModule.js';
 import { findDirectiveMatches } from './directives/findDirectiveMatches.js';
 import { DEFAULT_LOADER_CONFIG } from '../config/defaults.js';
-import { getNodeEnv } from '../getNodeEnv.js';
+import { getNodeEnv } from '../config/getNodeEnv.js';
+import { createLogger } from 'vite';
+import pkg from 'picocolors';
 
+const { red, underline } = pkg;
 const createTransformer = ({
   options,
   forceServerFunction = void 0,
   forceClientComponent = void 0,
   isServerEnvironment = isReactServerCondition()
 }) => {
-  return async (source, moduleId) => {
-    if (options.verbose) {
-      console.log(`[createTransformer] Loading: ${moduleId}`);
+  const {
+    verbose,
+    logger = createLogger(),
+    loader = DEFAULT_LOADER_CONFIG
+  } = options;
+  const explicitForceServerFunction = forceServerFunction !== void 0;
+  const explicitForceClientComponent = forceClientComponent !== void 0;
+  const initialForceServerFunction = forceServerFunction;
+  const initialForceClientComponent = forceClientComponent;
+  return async (source, moduleId, transformedModuleId = loader?.moduleID?.(moduleId) ?? moduleId) => {
+    forceServerFunction = initialForceServerFunction;
+    forceClientComponent = initialForceClientComponent;
+    if (verbose) {
+      logger.info(`[createTransformer] moduleID function called: ${moduleId} -> ${transformedModuleId}`);
+    }
+    if (verbose && moduleId.includes("client")) {
+      logger.info(
+        `[createTransformer:${isServerEnvironment ? "server" : "client"}] Loading: ${moduleId}`
+      );
     }
     const matches = findDirectiveMatches(source);
     const hasServerDirective = matches.matches.some(
@@ -28,11 +48,106 @@ const createTransformer = ({
       (m) => m.type === "client"
     );
     if (hasClientDirective === false && hasServerDirective === false) {
-      return { code: source, map: null };
+      if (isServerEnvironment && loader?.isClientComponentByName?.(moduleId, transformedModuleId)) {
+        if (verbose) {
+          logger.info(
+            `[createTransformer:server] Transforming client file without directive: ${moduleId}`
+          );
+        }
+        forceClientComponent = true;
+      } else if (!isServerEnvironment && !hasClientDirective && !hasServerDirective && !loader?.isClientComponentByName?.(moduleId, transformedModuleId) && !moduleId.includes("node_modules")) {
+        if (verbose) {
+          logger.info(
+            `[createTransformer:non-server] Hiding server component in non-server environment: ${moduleId}`
+          );
+        }
+        return { code: source, map: null };
+      } else {
+        if (hasClientDirective || hasServerDirective) {
+          if (verbose) {
+            logger.info(
+              `[createTransformer:client] Transforming file with directives: ${moduleId}`
+            );
+          }
+          const parseResult2 = await analyzeModule(source, {
+            ...options,
+            logger,
+            loader
+          });
+          if (parseResult2.type === "success") {
+            const result = await transformNonServerEnvironment(
+              source,
+              moduleId,
+              transformedModuleId,
+              parseResult2,
+              loader
+            );
+            if (verbose) {
+              logger.info(
+                `[createTransformer:client] Transformed result for ${moduleId}: ${result.code.substring(
+                  0,
+                  100
+                )}`
+              );
+            }
+            return result;
+          }
+        } else {
+          if (loader?.isClientComponentByName?.(moduleId, transformedModuleId)) {
+            if (verbose) {
+              logger.info(
+                `[createTransformer:client] Transforming client component without directives: ${moduleId}`
+              );
+            }
+            const parseResult2 = await analyzeModule(source, {
+              ...options,
+              logger,
+              loader
+            });
+            if (parseResult2.type === "success") {
+              const result = await transformNonServerEnvironment(
+                source,
+                moduleId,
+                transformedModuleId,
+                parseResult2,
+                loader
+              );
+              if (verbose) {
+                logger.info(
+                  `[createTransformer:client] Transformed result for ${moduleId}: ${result.code.substring(
+                    0,
+                    100
+                  )}`
+                );
+              }
+              return result;
+            }
+          }
+        }
+        return { code: source, map: null };
+      }
+    } else {
+      if (hasClientDirective) {
+        forceClientComponent = true;
+      }
+      if (hasServerDirective) {
+        forceServerFunction = true;
+      }
+      if (isServerEnvironment && forceClientComponent) {
+        const isAlreadyTransformed = source.includes(
+          options?.loader?.registerClientReferenceName ?? "registerClientReference"
+        );
+        if (isAlreadyTransformed) {
+          logger.warn(
+            `[createTransformer] File already transformed ${moduleId}. This call was not needed.`
+          );
+          return { code: source, map: null };
+        }
+      }
     }
-    const loader = options.loader ?? DEFAULT_LOADER_CONFIG;
     const parseResult = await analyzeModule(source, {
       ...options,
+      logger,
       loader
     });
     if (parseResult.directiveInfo && parseResult.directiveInfo.warnings.length > 0) {
@@ -43,30 +158,37 @@ const createTransformer = ({
           const [start, end] = warning.range;
           const lines = source.split("\n");
           const startLine = source.slice(0, start).split("\n").length;
-          console.warn(`Warning: ${warning.message}`);
+          logger.warn(`Warning: ${warning.message}`);
           const contextLines = 2;
           const minLine = Math.max(1, startLine - contextLines);
           const maxLine = Math.min(lines.length, startLine + contextLines);
-          console.warn("");
           for (let i = minLine; i <= maxLine; i++) {
             const lineNum = i.toString().padStart(3, " ");
             const isErrorLine = i === startLine;
             const prefix = isErrorLine ? ">" : " ";
             const line = lines[i - 1] || "";
             if (isErrorLine) {
-              console.warn(`${prefix} ${lineNum} | ${line}`);
               const lineStart = source.lastIndexOf("\n", start - 1) + 1;
               const columnPos = Math.max(0, start - lineStart);
               const directiveLength = Math.max(1, end - start);
-              const pointer = " ".repeat(7 + columnPos) + "^".repeat(directiveLength);
-              console.warn(`  ${pointer}`);
-            } else {
-              console.warn(`  ${lineNum} | ${line}`);
+              const beforeDirective = line.slice(0, columnPos);
+              const directiveText = line.slice(
+                columnPos,
+                columnPos + directiveLength
+              );
+              const afterDirective = line.slice(columnPos + directiveLength);
+              logger.warn(
+                `${prefix} ${lineNum} | ${beforeDirective}${red(
+                  underline(directiveText)
+                )}${afterDirective}`
+              );
+            } else if (line.trim() !== "") {
+              logger.warn(`  ${lineNum} | ${line}`);
             }
           }
-          console.warn("");
+          logger.warn("");
           if (options.verbose) {
-            console.warn(`  range: [${start}, ${end}]`);
+            logger.warn(`  range: [${start}, ${end}]`);
           }
         } else {
           throw new Error(warning.message);
@@ -76,17 +198,25 @@ const createTransformer = ({
     if (parseResult.type !== "success") {
       return { code: source, map: null };
     }
-    return await transformModule(source, moduleId, parseResult, {
-      forceServerFunction: forceServerFunction ?? hasServerDirective,
-      forceClientComponent: forceClientComponent ?? hasClientDirective,
-      isServerEnvironment,
-      loader: options.loader,
-      directiveWarnings: parseResult.directiveInfo.warnings,
-      verbose: options.verbose || false,
-      panicThreshold: options.panicThreshold || "none"
-    });
+    const finalForceServerFunction = isServerEnvironment ? forceServerFunction ?? hasServerDirective : explicitForceServerFunction ? forceServerFunction : void 0;
+    const finalForceClientComponent = isServerEnvironment ? forceClientComponent ?? hasClientDirective : explicitForceClientComponent ? forceClientComponent : void 0;
+    return await transformModule(
+      source,
+      moduleId,
+      transformedModuleId,
+      parseResult,
+      {
+        forceServerFunction: finalForceServerFunction,
+        forceClientComponent: finalForceClientComponent,
+        isServerEnvironment,
+        loader: options.loader,
+        directiveWarnings: parseResult.directiveInfo.warnings,
+        verbose: options.verbose || false,
+        panicThreshold: options.panicThreshold || "none"
+      }
+    );
   };
 };
 
 export { createTransformer };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"createTransformer.js","sources":["../../../plugin/loader/createTransformer.ts"],"sourcesContent":["import { transformModule } from \"./transformModule.js\";\nimport { isReactServerCondition } from \"../config/getCondition.js\";\nimport { analyzeModule } from \"./directives/analyzeModule.js\";\nimport { findDirectiveMatches } from \"./directives/findDirectiveMatches.js\";\nimport type { DirectiveMatch } from \"./directives/types.js\";\nimport type { TransformerFactory, TransformResult } from \"./types.js\";\nimport { DEFAULT_LOADER_CONFIG } from \"../config/defaults.js\";\nimport { getNodeEnv } from \"../getNodeEnv.js\";\n\n/**\n * Creates a transformer that handles React Server Components (RSC) boundaries.\n */\nexport const createTransformer: TransformerFactory = ({\n  options,\n  forceServerFunction = undefined,\n  forceClientComponent = undefined,\n  isServerEnvironment = isReactServerCondition(),\n}) => {\n  return async (source: string, moduleId: string): Promise<TransformResult> => {\n    if (options.verbose) {\n      console.log(`[createTransformer] Loading: ${moduleId}`);\n    }\n\n    // Fast-path: skip parsing and transformation if no directives are present\n    const matches = findDirectiveMatches(source);\n    const hasServerDirective = matches.matches.some(\n      (m: DirectiveMatch) => m.type === \"server\"\n    );\n    const hasClientDirective = matches.matches.some(\n      (m: DirectiveMatch) => m.type === \"client\"\n    );\n\n    if (hasClientDirective === false && hasServerDirective === false) {\n      return { code: source, map: null };\n    }\n    const loader = options.loader ?? DEFAULT_LOADER_CONFIG;\n    // Use analyzeModule to get the full parse result, passing the custom parseFn\n    const parseResult = await analyzeModule(source, {\n      ...options,\n      loader: loader,\n    });\n    if (\n      parseResult.directiveInfo &&\n      parseResult.directiveInfo.warnings.length > 0\n    ) {\n      const isProduction = getNodeEnv() === \"production\";\n\n      // Handle directive errors (can be downgraded to warnings based on panicThreshold)\n      for (const warning of parseResult.directiveInfo.warnings) {\n        const shouldDowngradeToWarning = !isProduction && options.panicThreshold === 'none';\n          \n        if (shouldDowngradeToWarning) {\n          // Downgrade error to warning in development when panicThreshold is 'none'\n          const [start, end] = warning.range;\n          const lines = source.split('\\n');\n          const startLine = source.slice(0, start).split('\\n').length;\n          \n          console.warn(`Warning: ${warning.message}`);\n          \n          // Show document preview with line numbers\n          const contextLines = 2; // Show 2 lines before and after\n          const minLine = Math.max(1, startLine - contextLines);\n          const maxLine = Math.min(lines.length, startLine + contextLines);\n          \n          console.warn('');\n          for (let i = minLine; i <= maxLine; i++) {\n            const lineNum = i.toString().padStart(3, ' ');\n            const isErrorLine = i === startLine;\n            const prefix = isErrorLine ? '>' : ' ';\n            const line = lines[i - 1] || '';\n            \n            if (isErrorLine) {\n              console.warn(`${prefix} ${lineNum} | ${line}`);\n              // Show pointer to the directive\n              const lineStart = source.lastIndexOf('\\n', start - 1) + 1;\n              const columnPos = Math.max(0, start - lineStart);\n              const directiveLength = Math.max(1, end - start);\n              const pointer = ' '.repeat(7 + columnPos) + '^'.repeat(directiveLength);\n              console.warn(`  ${pointer}`);\n            } else {\n              console.warn(`  ${lineNum} | ${line}`);\n            }\n          }\n          console.warn('');\n\n          if (options.verbose) {\n            console.warn(`  range: [${start}, ${end}]`);\n          }\n        } else {\n          // Treat as error (default behavior) - panic and stop compilation\n          throw new Error(warning.message);\n        }\n      }\n    }\n    if (parseResult.type !== \"success\") {\n      return { code: source, map: null };\n    }\n\n    // Transform the module\n    return await transformModule(source, moduleId, parseResult, {\n      forceServerFunction: forceServerFunction ?? hasServerDirective,\n      forceClientComponent: forceClientComponent ?? hasClientDirective,\n      isServerEnvironment,\n      loader: options.loader,\n      directiveWarnings: parseResult.directiveInfo.warnings,\n      verbose: options.verbose || false,\n      panicThreshold: options.panicThreshold || 'none',\n    });\n  };\n};\n"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"createTransformer.js","sources":["../../../plugin/loader/createTransformer.ts"],"sourcesContent":["import { transformModule } from \"./transformModule.js\";\nimport { transformNonServerEnvironment } from \"./transformNonServerEnvironment.js\";\nimport { isReactServerCondition } from \"../config/getCondition.js\";\nimport { analyzeModule } from \"./directives/analyzeModule.js\";\nimport { findDirectiveMatches } from \"./directives/findDirectiveMatches.js\";\nimport type { DirectiveMatch } from \"./directives/types.js\";\nimport type { TransformerFactory, TransformResult } from \"./types.js\";\nimport { DEFAULT_LOADER_CONFIG } from \"../config/defaults.js\";\nimport { getNodeEnv } from \"../config/getNodeEnv.js\";\nimport { createLogger } from \"vite\";\nimport pkg from \"picocolors\";\nconst { red, underline } = pkg;\n\n/**\n * Creates a transformer that handles React Server Components (RSC) boundaries.\n */\nexport const createTransformer: TransformerFactory = ({\n  options,\n  forceServerFunction = undefined,\n  forceClientComponent = undefined,\n  isServerEnvironment = isReactServerCondition(),\n}) => {\n  \n  const {\n    verbose,\n    logger = createLogger(),\n    loader = DEFAULT_LOADER_CONFIG,\n  } = options;\n\n  // Track if forceServerFunction/forceClientComponent were explicitly passed (for testing)\n  // vs auto-detected from directives (for normal builds)\n  const explicitForceServerFunction = forceServerFunction !== undefined;\n  const explicitForceClientComponent = forceClientComponent !== undefined;\n  \n  // Save initial values to reset on each call (closure bug fix)\n  const initialForceServerFunction = forceServerFunction;\n  const initialForceClientComponent = forceClientComponent;\n\n  return async (\n    source: string,\n    moduleId: string,\n    // if a moduleID function is provided, use it to get the transformed module ID by default\n    // otherwise, use the original module ID\n    // can also be passed directly as a parameter\n    transformedModuleId = loader?.moduleID?.(moduleId) ?? moduleId\n  ): Promise<TransformResult> => {\n    // Reset flags at start of each call to prevent closure state pollution\n    // (Each transformation should start fresh, not inherit state from previous calls)\n    forceServerFunction = initialForceServerFunction;\n    forceClientComponent = initialForceClientComponent;\n    \n    if (verbose) {\n      logger.info(`[createTransformer] moduleID function called: ${moduleId} -> ${transformedModuleId}`);\n    }\n    if (verbose && moduleId.includes(\"client\")) {\n      logger.info(\n        `[createTransformer:${\n          isServerEnvironment ? \"server\" : \"client\"\n        }] Loading: ${moduleId}`\n      );\n    }\n\n    // Fast-path: skip parsing and transformation if no directives are present\n    const matches = findDirectiveMatches(source);\n    const hasServerDirective = matches.matches.some(\n      (m: DirectiveMatch) => m.type === \"server\"\n    );\n    const hasClientDirective = matches.matches.some(\n      (m: DirectiveMatch) => m.type === \"client\"\n    );\n\n    if (hasClientDirective === false && hasServerDirective === false) {\n      // For files without directives, handle differently based on environment\n\n      if (isServerEnvironment && loader?.isClientComponentByName?.(moduleId, transformedModuleId)) {\n        // In server environment, client components without directives should be transformed to registerClientReference\n        // This handles cases where client components don't have explicit \"use client\" directives\n        // but are identified by file naming convention (.client.tsx)\n        if (verbose) {\n          logger.info(\n            `[createTransformer:server] Transforming client file without directive: ${moduleId}`\n          );\n        }\n        // Set forceClientComponent to true for client components identified by filename\n        forceClientComponent = true;\n        // Don't return early - let it fall through to transformModule\n      } else if (\n        !isServerEnvironment &&\n        !hasClientDirective &&\n        !hasServerDirective &&\n        !loader?.isClientComponentByName?.(moduleId, transformedModuleId) &&\n        !moduleId.includes(\"node_modules\")\n      ) {\n        // In non-server environments, server components (modules without client/server directives and not client by name) should be hidden\n        // This prevents server components from being loaded in client/ssr environments\n        // But don't hide third-party modules from node_modules or modules with directives\n        if (verbose) {\n          logger.info(\n            `[createTransformer:non-server] Hiding server component in non-server environment: ${moduleId}`\n          );\n        }\n        // Return a module that exports null/undefined instead of empty string\n        return { code: source, map: null };\n      } else {\n        // In client/ssr environments, we need to transform to remove directives\n        // but we don't transform to registerClientReference\n        if (hasClientDirective || hasServerDirective) {\n          if (verbose) {\n            logger.info(\n              `[createTransformer:client] Transforming file with directives: ${moduleId}`\n            );\n          }\n          // Transform to remove directives in client/ssr environment\n          const parseResult = await analyzeModule(source, {\n            ...options,\n            logger,\n            loader: loader,\n          });\n\n          if (parseResult.type === \"success\") {\n            const result = await transformNonServerEnvironment(\n              source,\n              moduleId,\n              transformedModuleId,\n              parseResult,\n              loader\n            );\n            if (verbose) {\n              logger.info(\n                `[createTransformer:client] Transformed result for ${moduleId}: ${result.code.substring(\n                  0,\n                  100\n                )}`\n              );\n            }\n            return result;\n          }\n        } else {\n          // For files without directives in client/ssr environment, we still need to check\n          // if this is a client component that should be transformed\n          if (loader?.isClientComponentByName?.(moduleId, transformedModuleId)) {\n            if (verbose) {\n              logger.info(\n                `[createTransformer:client] Transforming client component without directives: ${moduleId}`\n              );\n            }\n            // Transform to ensure proper exports in client environment\n            const parseResult = await analyzeModule(source, {\n              ...options,\n              logger,\n              loader: loader,\n            });\n\n            if (parseResult.type === \"success\") {\n              const result = await transformNonServerEnvironment(\n                source,\n                moduleId,\n                transformedModuleId,\n                parseResult,\n                loader,\n              );\n              if (verbose) {\n                logger.info(\n                  `[createTransformer:client] Transformed result for ${moduleId}: ${result.code.substring(\n                    0,\n                    100\n                  )}`\n                );\n              }\n              return result;\n            }\n          }\n        }\n        // For files without directives and not identified as client components, keep original code\n        return { code: source, map: null };\n      }\n    } else {\n      // Set appropriate flags based on directives\n      if (hasClientDirective) {\n        forceClientComponent = true;\n      }\n      if (hasServerDirective) {\n        forceServerFunction = true;\n      }\n\n      // Performance optimization: Check if file is already transformed to avoid unnecessary work\n      // Only check this for files that actually have directives and are in the right environment\n      if (isServerEnvironment && forceClientComponent) {\n        const isAlreadyTransformed = source.includes(\n          options?.loader?.registerClientReferenceName ??\n            \"registerClientReference\"\n        );\n\n        if (isAlreadyTransformed) {\n          logger.warn(\n            `[createTransformer] File already transformed ${moduleId}. This call was not needed.`\n          );\n          return { code: source, map: null };\n        }\n      }\n    }\n    // Use analyzeModule to get the full parse result, passing the custom parseFn\n    const parseResult = await analyzeModule(source, {\n      ...options,\n      logger,\n      loader: loader,\n    });\n    if (\n      parseResult.directiveInfo &&\n      parseResult.directiveInfo.warnings.length > 0\n    ) {\n      const isProduction = getNodeEnv() === \"production\";\n\n      // Handle directive errors (can be downgraded to warnings based on panicThreshold)\n      for (const warning of parseResult.directiveInfo.warnings) {\n        const shouldDowngradeToWarning =\n          !isProduction && options.panicThreshold === \"none\";\n\n        if (shouldDowngradeToWarning) {\n          // Downgrade error to warning in development when panicThreshold is 'none'\n          const [start, end] = warning.range;\n          const lines = source.split(\"\\n\");\n          const startLine = source.slice(0, start).split(\"\\n\").length;\n\n          logger.warn(`Warning: ${warning.message}`);\n\n          // Show document preview with line numbers\n          const contextLines = 2; // Show 2 lines before and after\n          const minLine = Math.max(1, startLine - contextLines);\n          const maxLine = Math.min(lines.length, startLine + contextLines);\n\n          for (let i = minLine; i <= maxLine; i++) {\n            const lineNum = i.toString().padStart(3, \" \");\n            const isErrorLine = i === startLine;\n            const prefix = isErrorLine ? \">\" : \" \";\n            const line = lines[i - 1] || \"\";\n\n            if (isErrorLine) {\n              // Highlight the directive text itself using Vite's logger color methods\n              const lineStart = source.lastIndexOf(\"\\n\", start - 1) + 1;\n              const columnPos = Math.max(0, start - lineStart);\n              const directiveLength = Math.max(1, end - start);\n\n              // Split the line to highlight just the directive\n              const beforeDirective = line.slice(0, columnPos);\n              const directiveText = line.slice(\n                columnPos,\n                columnPos + directiveLength\n              );\n              const afterDirective = line.slice(columnPos + directiveLength);\n\n              // Use picocolors for proper semantic coloring that adapts to themes\n              logger.warn(\n                `${prefix} ${lineNum} | ${beforeDirective}${red(\n                  underline(directiveText)\n                )}${afterDirective}`\n              );\n            } else if (line.trim() !== \"\") {\n              logger.warn(`  ${lineNum} | ${line}`);\n            }\n          }\n          logger.warn(\"\");\n\n          if (options.verbose) {\n            logger.warn(`  range: [${start}, ${end}]`);\n          }\n        } else {\n          // Treat as error (default behavior) - panic and stop compilation\n          throw new Error(warning.message);\n        }\n      }\n    }\n    if (parseResult.type !== \"success\") {\n      return { code: source, map: null };\n    }\n\n    // Transform the module\n    // Only use explicit forceServerFunction/forceClientComponent in client environments\n    // In client environments, auto-detected directives should go to transformNonServerEnvironment\n    // (which throws errors for \"use server\" directives)\n    const finalForceServerFunction = isServerEnvironment\n      ? (forceServerFunction ?? hasServerDirective)\n      : (explicitForceServerFunction ? forceServerFunction : undefined);\n    const finalForceClientComponent = isServerEnvironment\n      ? (forceClientComponent ?? hasClientDirective)\n      : (explicitForceClientComponent ? forceClientComponent : undefined);\n\n    return await transformModule(\n      source,\n      moduleId,\n      transformedModuleId,\n      parseResult,\n      {\n        forceServerFunction: finalForceServerFunction,\n        forceClientComponent: finalForceClientComponent,\n        isServerEnvironment,\n        loader: options.loader,\n        directiveWarnings: parseResult.directiveInfo.warnings,\n        verbose: options.verbose || false,\n        panicThreshold: options.panicThreshold || \"none\",\n      }\n    );\n  };\n};\n"],"names":["parseResult"],"mappings":"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"}

package/dist/plugin/loader/directives/analyzeDirectives.d.ts

@@ -1,9 +1,10 @@
 import type { DirectiveInfo, DirectiveMatches } from "./types.js";
 import type { Program } from "acorn";
 import type { DirectiveOptions } from "../../types.js";
+import { type Logger } from "vite";
 /**
  * Analyzes directives in the given source and AST, returning directiveInfo.
  */
-export declare function analyzeDirectives(ast: Program, source: string, matches?: DirectiveMatches): DirectiveInfo;
-export declare function analyzeDirectives(ast: Program, source: string, options?: DirectiveOptions): DirectiveInfo;
+export declare function analyzeDirectives(ast: Program, source: string, matches?: DirectiveMatches, logger?: Logger): DirectiveInfo;
+export declare function analyzeDirectives(ast: Program, source: string, options?: DirectiveOptions, logger?: Logger): DirectiveInfo;
 //# sourceMappingURL=analyzeDirectives.d.ts.map

package/dist/plugin/loader/directives/analyzeDirectives.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"analyzeDirectives.d.ts","sourceRoot":"","sources":["../../../../plugin/loader/directives/analyzeDirectives.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,aAAa,EAAkB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAClF,OAAO,KAAK,EAAQ,OAAO,EAAE,MAAM,OAAO,CAAC;AAC3C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAEvD;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,OAAO,EACZ,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,gBAAgB,GACzB,aAAa,CAAC;AACjB,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,OAAO,EACZ,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,gBAAgB,GACzB,aAAa,CAAC"}
+{"version":3,"file":"analyzeDirectives.d.ts","sourceRoot":"","sources":["../../../../plugin/loader/directives/analyzeDirectives.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EACV,aAAa,EAEb,gBAAgB,EACjB,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAQ,OAAO,EAAE,MAAM,OAAO,CAAC;AAC3C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,EAAgB,KAAK,MAAM,EAAE,MAAM,MAAM,CAAC;AAEjD;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,OAAO,EACZ,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,gBAAgB,EAC1B,MAAM,CAAC,EAAE,MAAM,GACd,aAAa,CAAC;AACjB,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,OAAO,EACZ,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,gBAAgB,EAC1B,MAAM,CAAC,EAAE,MAAM,GACd,aAAa,CAAC"}