vite-plugin-react-server 1.1.12 → 1.1.13

package/plugin/loader/handleExports.ts

@@ -0,0 +1,276 @@
+import type { Program } from "./types.js";
+import type { FunctionDeclaration, VariableDeclaration, VariableDeclarator } from "acorn";
+
+/**
+ * Collects and organizes export information from a module.
+ *
+ * For all modules:
+ * - Collects import statements
+ * - Collects export names
+ * - Collects declarations
+ *
+ * The actual transformation of exports (like wrapping with registerServerReference)
+ * happens in transformModuleWithPreservedFunctions.
+ *
+ * @param source - The source code of the module
+ * @param url - The URL of the module
+ * @param program - The parsed AST program
+ * @param isServerFunction - Whether this is a server module
+ * @param isClientComponent - Whether this is a client module
+ * @returns Object containing imports, declarations, and export names
+ */
+export function handleExports(
+  source: string,
+  program: Program,
+  isServerFunction: boolean | RegExpMatchArray | null,
+  isClientComponent: boolean | RegExpMatchArray | null
+): {
+  imports: string[];
+  declarations: string[];
+  exportNames: string[];
+  exports: Map<
+    string,
+    {
+      type: "function" | "class" | "variable" | "default" | "all";
+      declaration?: string;
+      localName?: string;
+      before?: string[];
+      after?: string[];
+      isAsync?: boolean;
+    }
+  >;
+} {
+  const imports: string[] = [];
+  const declarations: string[] = [];
+  const exportNames: string[] = [];
+  // Track exports and their types
+  const exports = new Map<
+    string,
+    {
+      type: "function" | "class" | "variable" | "default" | "all";
+      declaration?: string;
+      localName?: string;
+      before?: string[];
+      after?: string[];
+      isAsync?: boolean;
+    }
+  >();
+
+  let lastEnd = 0;
+  let currentBefore: string[] = [];
+  let foundFirstExport = false;
+
+  // First pass: collect all exports and code between them
+  for (const node of program.body) {
+    // Add any code before this node
+    if (node.start > lastEnd) {
+      const beforeCode = source.slice(lastEnd, node.start);
+      if (beforeCode.trim()) {
+        currentBefore.push(beforeCode);
+      }
+    }
+
+    if (node.type === "ImportDeclaration") {
+      imports.push(source.slice(node.start, node.end));
+    } else if (node.type === "ExportAllDeclaration") {
+      // For export * from './other', just add the * export
+      exports.set("*", {
+        type: "all",
+        before: [...currentBefore],
+      });
+      currentBefore = [];
+      exportNames.push("*");
+    } else if (node.type === "ExportNamedDeclaration") {
+      if (!foundFirstExport) {
+        // This is the first export, so all code before it goes into its before array
+        foundFirstExport = true;
+      }
+
+      if (node.declaration) {
+        if (
+          node.declaration.type === "FunctionDeclaration" &&
+          node.declaration.id
+        ) {
+          const name = node.declaration.id.name;
+          exports.set(name, {
+            type: "function",
+            declaration: source.slice(node.declaration.start, node.declaration.end),
+            before: [...currentBefore], // Copy the current before array
+            isAsync: node.declaration.async,
+          });
+          exportNames.push(name);
+          currentBefore = []; // Reset for next export
+        } else if (
+          node.declaration.type === "ClassDeclaration" &&
+          node.declaration.id
+        ) {
+          const name = node.declaration.id.name;
+          exports.set(name, {
+            type: "class",
+            declaration: source.slice(node.declaration.start, node.declaration.end),
+            before: [...currentBefore], // Copy the current before array
+          });
+          exportNames.push(name);
+          currentBefore = []; // Reset for next export
+        } else if (node.declaration.type === "VariableDeclaration") {
+          for (const decl of node.declaration.declarations) {
+            if (decl.id && decl.id.type === "Identifier") {
+              const name = decl.id.name;
+              // Check if the declaration is a function expression or arrow function
+              const init = decl.init;
+              const isFunction = init && (
+                init.type === "FunctionExpression" ||
+                init.type === "ArrowFunctionExpression"
+              );
+              // For function expressions and arrow functions, we want to mark them as async
+              // if they are explicitly marked as async
+              const isAsync = isFunction && (
+                (init.type === "FunctionExpression" && init.async === true) ||
+                (init.type === "ArrowFunctionExpression" && init.async === true)
+              );
+              exports.set(name, {
+                type: isFunction ? "function" : "variable",
+                declaration: source.slice(decl.start, decl.end),
+                before: [...currentBefore], // Copy the current before array
+                isAsync: isAsync || false
+              });
+              exportNames.push(name);
+              currentBefore = []; // Reset for next export
+            }
+          }
+        }
+      } else if (node.specifiers) {
+        // For named exports (export { a, b, c })
+        for (const spec of node.specifiers) {
+          if (spec.type === "ExportSpecifier") {
+            const localName = spec.local.type === "Identifier" ? spec.local.name : "";
+            const exportedName = spec.exported.type === "Identifier" ? spec.exported.name : "";
+            if (localName && exportedName) {
+              // Find the function declaration in the AST
+              const functionDecl = program.body.find(
+                (node): node is FunctionDeclaration =>
+                  node.type === "FunctionDeclaration" &&
+                  node.id?.name === localName
+              );
+
+              if (functionDecl) {
+                exports.set(exportedName, {
+                  type: "function",
+                  localName,
+                  declaration: source.slice(functionDecl.start, functionDecl.end),
+                  before: [...currentBefore],
+                  isAsync: functionDecl.async
+                });
+                exportNames.push(exportedName);
+              } else {
+                // If we can't find a function declaration, check if it's a variable declaration
+                const varDecl = program.body.find(
+                  (node): node is VariableDeclaration =>
+                    node.type === "VariableDeclaration" &&
+                    node.declarations.some(
+                      (decl) =>
+                        decl.id.type === "Identifier" &&
+                        decl.id.name === localName &&
+                        decl.init &&
+                        (decl.init.type === "FunctionExpression" ||
+                         decl.init.type === "ArrowFunctionExpression")
+                    )
+                );
+
+                if (varDecl) {
+                  const decl = varDecl.declarations.find(
+                    (d: VariableDeclarator) => d.id.type === "Identifier" && d.id.name === localName
+                  );
+                  if (decl && decl.init) {
+                    const isAsync = decl.init.type === "FunctionExpression" ? decl.init.async :
+                                  decl.init.type === "ArrowFunctionExpression" ? decl.init.async : false;
+                    exports.set(exportedName, {
+                      type: "function",
+                      localName,
+                      declaration: source.slice(decl.start, decl.end),
+                      before: [...currentBefore],
+                      isAsync
+                    });
+                    exportNames.push(exportedName);
+                  }
+                } else {
+                  exports.set(exportedName, {
+                    type: "variable",
+                    localName,
+                    before: [...currentBefore],
+                  });
+                  exportNames.push(exportedName);
+                }
+              }
+            }
+          }
+        }
+        currentBefore = []; // Reset for next export
+      }
+    } else if (node.type === "ExportDefaultDeclaration") {
+      if (node.declaration && node.declaration.type === "FunctionDeclaration" && node.declaration.id) {
+        exports.set("default", {
+          type: "default",
+          before: [...currentBefore],
+          localName: node.declaration.id.name, // Capture the function name
+          isAsync: node.declaration.async
+        });
+      } else {
+        exports.set("default", {
+          type: "default",
+          before: [...currentBefore]
+        });
+      }
+      currentBefore = []; // Reset for next export
+    } else if (
+      node.type === "FunctionDeclaration" ||
+      node.type === "VariableDeclaration" ||
+      node.type === "ClassDeclaration"
+    ) {
+      // For non-exported declarations:
+      // - Keep all declarations for server functions
+      // - Remove function declarations for client components
+      if (
+        isServerFunction ||
+        !isClientComponent ||
+        node.type !== "FunctionDeclaration"
+      ) {
+        declarations.push(source.slice(node.start, node.end));
+      }
+    }
+
+    lastEnd = node.end;
+  }
+
+  // Add any remaining code after the last node
+  if (lastEnd < source.length) {
+    const afterCode = source.slice(lastEnd);
+    if (afterCode.trim()) {
+      // Add to the last export's after array
+      const lastExport = Array.from(exports.values()).pop();
+      if (lastExport) {
+        lastExport.after = [afterCode];
+      }
+    }
+  }
+
+  // Second pass: generate transformed exports
+  // Process all exports regardless of environment - the actual transformation
+  // happens in transformModuleWithPreservedFunctions
+  for (const [name, info] of exports) {
+    if (info.before) {
+      declarations.push(...info.before);
+    }
+    if (info.declaration) {
+      declarations.push(info.declaration);
+    }
+    if (info.after) {
+      declarations.push(...info.after);
+    }
+    if (!exportNames.includes(name)) {
+      exportNames.push(name);
+    }
+  }
+
+  return { imports, declarations, exportNames, exports };
+}

package/plugin/loader/index.ts

@@ -1 +1,6 @@
-export { reactLoaderPlugin } from "./plugin.js";
+import { getCondition } from "../config/getCondition.js"
+
+const condition  = getCondition('')
+const loader = await import(`react-loader.${condition}.ts`);
+
+export const { load, resolve } = loader;

package/plugin/loader/parse.ts

@@ -0,0 +1,22 @@
+import * as acorn from "acorn-loose";
+import type { Program } from "./types.js";
+
+/**
+ * Parses source code and handles source maps
+ */
+export function parse(source: string): Program {
+  let program: Program;
+
+  // Parse the transformed code with acorn
+  program = acorn.parse(source, {
+    ecmaVersion: "latest" as const,
+    sourceType: "module",
+    locations: true,
+    allowAwaitOutsideFunction: true,
+    allowImportExportEverywhere: true,
+    allowReturnOutsideFunction: true,
+    allowReserved: true,
+  }) as Program;
+
+  return program
+}

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

@@ -0,0 +1 @@
+throw new Error("Not supported on the client");

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

@@ -0,0 +1,107 @@
+import type { LoaderContext, ResolvedUserOptions } from "../types.js";
+import type { ModuleInfo } from "rollup";
+import { transformModuleIfNeeded } from "./transformModuleIfNeeded.js";
+import type { MessagePort } from "node:worker_threads";
+import type { InitializedReactLoaderMessage, ServerModuleMessage } from "../worker/types.js";
+import { hydrateUserOptions } from "../helpers/index.js";
+import { resolveOptions } from "../config/index.js";
+import { fileURLToPath } from "node:url";
+import { join } from "node:path";
+
+export interface LoaderOptions {
+  id: string;
+  resolveDependencies?: boolean;
+  format?: string;
+  conditions?: string[];
+  importAssertions?: Record<string, any>;
+  importAttributes?: Record<string, any>;
+  source: string;
+}
+
+export type LoaderFunction = (options: LoaderOptions) => Promise<ModuleInfo>;
+
+let userOptions: ResolvedUserOptions | undefined;
+let loaderPort: MessagePort | undefined;
+export async function initialize(data: { id: string, port: MessagePort, userOptions: any }) {
+  const userOptionsResult = resolveOptions(hydrateUserOptions(data.userOptions));
+  loaderPort = data.port;
+  loaderPort.postMessage({ type: "INITIALIZED_REACT_LOADER", id: data.id } satisfies InitializedReactLoaderMessage);
+  if(userOptionsResult.type === "error") {
+    throw userOptionsResult.error
+  }
+  userOptions = userOptionsResult.userOptions;
+}
+
+export async function load(url: string, context: LoaderContext, nextLoad: any) {
+  const { format } = context;
+
+  if (format === "module") {
+    const result = await nextLoad(url, context);
+    const source = typeof result.source === 'string' ? result.source : 
+                  result.source instanceof Uint8Array ? new TextDecoder().decode(result.source) :
+                  String(result.source);
+
+    // Handle file URLs
+    const filePath = url.startsWith("file://") ? fileURLToPath(url) : url;
+
+    // Normalize the URL using the same logic as plugin.server.ts
+    let moduleID = filePath;
+    let finalID = filePath;
+    if (userOptions?.normalizer) {
+      const [, value] = userOptions.normalizer(filePath);
+      moduleID = join(userOptions.moduleBasePath, value);
+      finalID = userOptions.moduleID(moduleID);
+    }
+    if (userOptions?.verbose) {
+      console.log("[react-loader] moduleID:", moduleID);
+      console.log("[react-loader] finalID:", finalID);
+    }
+
+    const transformed = transformModuleIfNeeded(
+      source,
+      finalID,
+      userOptions?.autoDiscover?.isServerFunction(source),
+      userOptions?.autoDiscover?.isClientComponent(source),
+      true, // isServerEnvironment
+    );
+
+    if (userOptions?.verbose) {
+      console.log("[react-loader] Transformed source:", transformed);
+    }
+
+    if (loaderPort) {
+      if (userOptions?.verbose) {
+        console.log("[react-loader] Sending SERVER_MODULE message:", { id: finalID, url: filePath });
+      }
+      loaderPort.postMessage({
+        type: "SERVER_MODULE",
+        id: finalID,
+        url: filePath,
+        source: transformed,
+      } satisfies ServerModuleMessage);
+    }
+
+    // If we have a source map, update it to point to the transformed source
+    const map = result.map ? {
+      ...result.map,
+      sourcesContent: [transformed],
+      mappings: result.map.mappings
+    } : null;
+
+    return {
+      ...result,
+      source: transformed,
+      map
+    };
+  }
+
+  return nextLoad(url, context);
+}
+
+export async function resolve(
+  specifier: string,
+  context: any,
+  nextResolve: any
+) {
+  return nextResolve(specifier, context);
+}