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

package/plugin/loader/directives/analyzeModule.ts

@@ -0,0 +1,39 @@
+import { parse } from "../parse.js";
+import { analyzeDirectives } from "./analyzeDirectives.js";
+import { getExports } from "./getExports.js";
+import type { ParseResult, Program } from "./types.js";
+import type { DirectiveOptions } from "../../types.js";
+
+/**
+ * Analyzes a module for directives and returns the parse result with directive info.
+ */
+export async function analyzeModule(
+  source: string,
+  options?: DirectiveOptions,
+  parseFn: (source: string) => Promise<{ ast: Program; code: string; map?: any }> = parse
+): Promise<ParseResult> {
+  const { ast, code } = await parseFn(source);
+
+  // Collect exports from the AST first
+  const exports = await getExports(ast);
+  if(options?.verbose) {
+    if(exports.exports.size > 0) {
+      console.log('[analyzeModule] exports', Array.from(exports.exports.values()));
+    }
+  }
+
+  const directiveInfo = analyzeDirectives(ast, source, options);
+  if(options?.verbose) {
+    if(directiveInfo.warnings.length > 0) {
+      console.log('[analyzeModule] warnings', directiveInfo.warnings);
+    }
+  }
+
+  return {
+    type: 'success',
+    ast,
+    code,
+    exports,
+    directiveInfo
+  };
+} 

package/plugin/loader/directives/collectExports.ts

@@ -0,0 +1,181 @@
+import type {
+  AnonymousClassDeclaration,
+  AnonymousFunctionDeclaration,
+  ClassDeclaration,
+  Declaration,
+  ExportSpecifier,
+  Expression,
+  FunctionDeclaration,
+  Program,
+} from "acorn";
+import type { ExportInfo } from "./types.js";
+import {
+  isArrowFunctionExpression,
+  isFunctionExpression,
+} from "./typeGuards.js";
+import { addLocalExportedNames } from "./addLocalExportedNames.js";
+
+function createExportInfo(
+  localName: string,
+  exportName: string,
+  type: "function" | "class" | "variable" | null,
+  range: [number, number],
+  originalModuleId?: string
+): ExportInfo {
+  return {
+    localName,
+    exportName,
+    type,
+    range,
+    originalModuleId,
+  };
+}
+
+function handleTypedExport(
+  id: { name: string } | null,
+  exportName: string,
+  type: "function" | "class",
+  range: [number, number]
+): ExportInfo {
+  return createExportInfo(
+    id?.name || "anonymous",
+    exportName,
+    type,
+    range
+  );
+}
+
+function handleDefaultExport(
+  declaration:
+    | AnonymousFunctionDeclaration
+    | FunctionDeclaration
+    | AnonymousClassDeclaration
+    | ClassDeclaration
+    | Expression,
+  range: [number, number]
+): ExportInfo | null {
+  if (declaration.type === "Identifier") {
+    return createExportInfo(declaration.name, "default", null, range);
+  } else if (declaration.type === "FunctionDeclaration") {
+    return handleTypedExport(declaration.id, "default", "function", range);
+  } else if (declaration.type === "ClassDeclaration") {
+    return handleTypedExport(declaration.id, "default", "class", range);
+  } else if (declaration.type === "ArrowFunctionExpression") {
+    return handleTypedExport(null, "default", "function", range);
+  }
+  return null;
+}
+
+function handleNamedExport(
+  declaration: Declaration | Expression,
+  range: [number, number]
+): ExportInfo[] {
+  const exports: ExportInfo[] = [];
+
+  if (declaration.type === "VariableDeclaration") {
+    for (const decl of declaration.declarations) {
+      if (decl.init) {
+        if (
+          isArrowFunctionExpression(decl.init) ||
+          isFunctionExpression(decl.init)
+        ) {
+          if (decl.id.type === "Identifier") {
+            exports.push(handleTypedExport(decl.id, decl.id.name, "function", range));
+          }
+        } else {
+          addLocalExportedNames(exports, decl.id, range);
+        }
+      } else {
+        addLocalExportedNames(exports, decl.id, range);
+      }
+    }
+  } else if (declaration.type === "FunctionDeclaration" && declaration.id) {
+    exports.push(
+      handleTypedExport(declaration.id, declaration.id.name, "function", range)
+    );
+  } else if (declaration.type === "ClassDeclaration" && declaration.id) {
+    exports.push(handleTypedExport(declaration.id, declaration.id.name, "class", range));
+  }
+
+  return exports;
+}
+
+async function handleReExports(
+  specifiers: ExportSpecifier[],
+  range: [number, number],
+  sourceModuleId?: string
+): Promise<ExportInfo[]> {
+  const exports: ExportInfo[] = [];
+
+  for (const specifier of specifiers) {
+    if (
+      specifier.local.type === "Identifier" &&
+      specifier.exported.type === "Identifier"
+    ) {
+      // For re-exports from another module, use exported name for function reference
+      // For local exports with aliases, use local name for function reference
+      const functionName = sourceModuleId ? specifier.exported.name : specifier.local.name;
+      
+      exports.push(
+        createExportInfo(
+          functionName,              // Function reference name
+          specifier.exported.name,   // Export name
+          "function",
+          range,
+        )
+      );
+    }
+  }
+
+  return exports;
+}
+
+/**
+ * Collects all exports from a module, including:
+ * - Named exports
+ * - Default exports
+ * - Re-exports
+ * - Object method exports
+ * - Class method exports
+ * - Export * declarations
+ */
+export async function collectExports(program: Program): Promise<ExportInfo[]> {
+  const exports: ExportInfo[] = [];
+
+  for (const node of program.body) {
+    switch (node.type) {
+      case "ExportDefaultDeclaration": {
+        const exportInfo = handleDefaultExport(node.declaration, [
+          node.start,
+          node.end,
+        ]);
+        if (exportInfo) {
+          exports.push(exportInfo);
+        }
+        break;
+      }
+
+      case "ExportAllDeclaration":
+        // If export * is used, the other file needs to explicitly opt into "use server" too.
+        // This matches React's loader behavior - we ignore export * declarations
+        break;
+
+      case "ExportNamedDeclaration":
+        if (node.declaration) {
+          exports.push(
+            ...handleNamedExport(node.declaration, [node.start, node.end])
+          );
+        }
+        if (node.specifiers) {
+          const sourceModuleId = node.source && typeof node.source.value === "string" 
+            ? node.source.value 
+            : undefined;
+          const reExports = await handleReExports(node.specifiers, [node.start, node.end], sourceModuleId);
+          exports.push(...reExports);
+        }
+        break;
+    }
+  }
+
+  return exports;
+}

package/plugin/loader/directives/collectExportsFromModule.ts

@@ -0,0 +1,25 @@
+import { parse } from "../parse.js";
+import type { ExportInfo } from "./types.js";
+import { getExports } from "./getExports.js";
+import { loadClientSource } from "../../helpers/moduleResolver.js";
+
+/**
+ * Recursively collects exports from a module that uses export *
+ */
+export async function collectExportsFromModule(moduleId: string): Promise<ExportInfo[]> {
+    const source = await loadClientSource(moduleId);
+  
+    if (typeof source !== 'string') {
+      throw new Error('Expected source to be a string');
+    }
+  
+    // Use our existing parse function
+    const { ast } = await parse(source);
+    const exports = await getExports(ast);
+    
+    // Set originalModuleId for local exports, preserve it for re-exports
+    return Array.from(exports.exports.values()).map(exp => ({
+      ...exp,
+      originalModuleId: exp.originalModuleId || moduleId
+    }));
+  }

package/plugin/loader/directives/findDirectiveMatches.ts

@@ -0,0 +1,58 @@
+import type { DirectiveMatch, DirectiveMatches, DirectiveWarning } from "./types.js";
+
+export function findDirectiveMatches(
+  source: string,
+): DirectiveMatches {
+  const matches: DirectiveMatch[] = [];
+  const warnings: DirectiveWarning[] = [];
+
+  // Find all directive matches in order
+  const serverMatches = findServerDirectives(source);
+  const clientMatches = findClientDirectives(source);
+
+  // Sort all matches by their position in the source
+  const allMatches = [...serverMatches, ...clientMatches].sort((a, b) => a.range[0] - b.range[0]);
+
+  // If no directives found, return early
+  if (allMatches.length === 0) {
+    return { matches, warnings };
+  }
+
+  // Add all matches as function-level for now
+  // analyzeDirectives will determine if they're file-level
+  for (const match of allMatches) {
+    matches.push(match);
+  }
+
+  return { matches, warnings };
+}
+
+function findServerDirectives(source: string): DirectiveMatch[] {
+  const matches: DirectiveMatch[] = [];
+  const regex = /"use server"|'use server'/g;
+  let match;
+
+  while ((match = regex.exec(source)) !== null) {
+    matches.push({
+      type: "server",
+      range: [match.index, match.index + match[0].length]
+    });
+  }
+
+  return matches;
+}
+
+function findClientDirectives(source: string): DirectiveMatch[] {
+  const matches: DirectiveMatch[] = [];
+  const regex = /"use client"|'use client'/g;
+  let match;
+
+  while ((match = regex.exec(source)) !== null) {
+    matches.push({
+      type: "client",
+      range: [match.index, match.index + match[0].length]
+    });
+  }
+
+  return matches;
+} 

package/plugin/loader/directives/getExportedName.ts

@@ -0,0 +1,73 @@
+import type { Node, FunctionDeclaration, FunctionExpression, MethodDefinition, PropertyDefinition, VariableDeclarator, ClassBody, ClassDeclaration } from "acorn";
+
+export function getExportedName(node: Node): string | undefined {
+  // If not in export map, try to get the name based on node type
+  if (node.type === "FunctionDeclaration") {
+    const funcDecl = node as FunctionDeclaration;
+    return funcDecl.id?.name;
+  } else if (node.type === "FunctionExpression") {
+    const funcExpr = node as FunctionExpression;
+    // For anonymous functions in default exports, use "default"
+    if (funcExpr.parent?.type === "ExportDefaultDeclaration") {
+      return "default";
+    }
+    // For other anonymous functions, try to get the name from the parent
+    if (funcExpr.parent?.type === "VariableDeclarator") {
+      const varDecl = funcExpr.parent as VariableDeclarator;
+      return varDecl.id.type === "Identifier" ? varDecl.id.name : undefined;
+    }
+    return undefined;
+  } else if (node.type === "MethodDefinition") {
+    const method = node as MethodDefinition;
+    const methodName =
+      method.key.type === "Identifier"
+        ? method.key.name
+        : method.key.type === "Literal" &&
+          typeof method.key.value === "string"
+        ? method.key.value
+        : undefined;
+    if (methodName) {
+      // Get the class name from the parent
+      const classBody = method.parent as ClassBody;
+      const classDecl = classBody.parent as ClassDeclaration;
+      const className = classDecl.id?.name;
+      if (className) {
+        return method.static
+          ? `${className}.${methodName}`
+          : `${className}.prototype.${methodName}`;
+      }
+      return methodName;
+    }
+  } else if (node.type === "Property") {
+    const prop = node as PropertyDefinition;
+    const propName =
+      prop.key.type === "Identifier"
+        ? prop.key.name
+        : prop.key.type === "Literal" && typeof prop.key.value === "string"
+        ? prop.key.value
+        : undefined;
+    if (propName) {
+      // Get the full path for nested objects
+      let current = prop.parent;
+      let path = propName;
+      while (current && current.type === "Property") {
+        const parentProp = current as PropertyDefinition;
+        const parentName = parentProp.key.type === "Identifier" ? parentProp.key.name :
+                         parentProp.key.type === "Literal" ? String(parentProp.key.value) : "";
+        if (parentName) {
+          path = `${parentName}.${path}`;
+        }
+        current = current.parent;
+      }
+      // If this is part of an exported object, add the export name
+      if (current?.type === "VariableDeclarator") {
+        const varDecl = current as VariableDeclarator;
+        if (varDecl.id.type === "Identifier") {
+          path = `${varDecl.id.name}.${path}`;
+        }
+      }
+      return path;
+    }
+  }
+  return undefined;
+} 

package/plugin/loader/directives/getExports.ts

@@ -0,0 +1,27 @@
+import { collectExports } from "./collectExports.js";
+import type { ParsedExports } from "./types.js";
+import type { Program } from "acorn";
+
+/**
+ * Returns the exports from the given AST (program).
+ */
+export async function getExports(program: Program): Promise<ParsedExports> {
+  const exports = await collectExports(program);
+  const exportNames = exports.map(e => e.exportName);
+  const exportsMap = new Map();
+  
+  for (const exp of exports) {
+    exportsMap.set(exp.exportName, {
+      localName: exp.localName,
+      exportName: exp.exportName,
+      type: exp.type,
+      range: exp.range,
+      loc: exp.loc
+    });
+  }
+
+  return {
+    exportNames,
+    exports: exportsMap
+  };
+} 

package/plugin/loader/directives/getFunctionBody.ts

@@ -0,0 +1,32 @@
+import type { Node, BlockStatement } from "acorn";
+import { 
+  isFunctionDeclaration, 
+  isVariableDeclaration, 
+  isArrowFunctionExpression, 
+  isBlockStatement,
+  isMethodDefinition,
+  isProperty,
+  isFunctionNode
+} from "./typeGuards.js";
+
+export function getFunctionBody(node: Node): BlockStatement | null {
+  if (isFunctionDeclaration(node)) {
+    return isBlockStatement(node.body) ? node.body : null;
+  }
+  if (isMethodDefinition(node)) {
+    return isBlockStatement(node.value.body) ? node.value.body : null;
+  }
+  if (isProperty(node) && isFunctionNode(node.value)) {
+    return isBlockStatement(node.value.body) ? node.value.body : null;
+  }
+  if (isVariableDeclaration(node)) {
+    const init = node.declarations[0]?.init;
+    if (init && isArrowFunctionExpression(init)) {
+      return isBlockStatement(init.body) ? init.body : null;
+    }
+  }
+  if (isFunctionNode(node)) {
+    return isBlockStatement(node.body) ? node.body : null;
+  }
+  return null;
+} 

package/plugin/loader/directives/getFunctionName.ts

@@ -0,0 +1,70 @@
+import type { Node } from "acorn";
+import { getQualifiedName } from "./getQualifiedName.js";
+import { 
+  isNodeWithParent, 
+  isVariableDeclarator,   
+  isIdentifier,
+  isMethodDefinition,
+  isArrowFunctionExpression,
+  isFunctionExpression,
+  isFunctionDeclaration,
+  isProperty
+} from "./typeGuards.js";
+
+/**
+ * Gets the local name of a function node.
+ * For function declarations: returns the function's id name
+ * For methods: returns the method's key name
+ * For variable declarations: returns the variable's id name
+ * For anonymous functions: returns the qualified local name
+ */
+export function getFunctionName(node: Node): string {
+  // For function declarations, use the function name
+  if (isFunctionDeclaration(node) && node.id) {
+    return node.id.name;
+  }
+
+  // For function expressions and arrow functions, try to get the name from the parent
+  if ((isFunctionExpression(node) || isArrowFunctionExpression(node)) && isNodeWithParent(node)) {
+    const parent = node.parent;
+    
+    // If parent is a variable declarator, use the variable name
+    if (isVariableDeclarator(parent) && isIdentifier(parent.id)) {
+      return parent.id.name;
+    }
+    
+    // If parent is a method definition, use the method name
+    if (isMethodDefinition(parent) && isIdentifier(parent.key)) {
+      return parent.key.name;
+    }
+    
+    // If parent is a property, use the property name
+    if (isProperty(parent) && isIdentifier(parent.key)) {
+      return parent.key.name;
+    }
+  }
+
+  // For anonymous functions, try to get a name from the parent
+  if (isNodeWithParent(node)) {
+    const parent = node.parent;
+    
+    // If parent is a variable declarator, use the variable name
+    if (isVariableDeclarator(parent) && isIdentifier(parent.id)) {
+      return parent.id.name;
+    }
+    
+    // If parent is a method definition, use the method name
+    if (isMethodDefinition(parent) && isIdentifier(parent.key)) {
+      return parent.key.name;
+    }
+    
+    // If parent is a property, use the property name
+    if (isProperty(parent) && isIdentifier(parent.key)) {
+      return parent.key.name;
+    }
+  }
+
+  // If we can't find a name, try to get a qualified name
+  const qualifiedName = getQualifiedName(node);
+  return qualifiedName || "anonymous";
+} 

package/plugin/loader/directives/getQualifiedName.ts

@@ -0,0 +1,76 @@
+import type { Node } from "acorn";
+import { 
+  isFunctionDeclaration, 
+  isMethodDefinition, 
+  isVariableDeclarator,
+  isClassDeclaration,
+  isObjectExpression,
+  isIdentifier,
+  isClassBody,
+  isNodeWithParent,
+  isFunctionNode,
+  isExportNamedDeclaration,
+  isExportDefaultDeclaration
+} from "./typeGuards.js";
+
+export function getQualifiedName(node: Node): string {
+  const parts: string[] = [];
+  let current: Node | undefined = node;
+
+  while (current) {
+    if (isFunctionDeclaration(current)) {
+      if (current.id) {
+        parts.unshift(current.id.name);
+      } else if (isNodeWithParent(current) && current.parent) {
+        // For anonymous function declarations, try to find a name from the parent
+        if (isExportNamedDeclaration(current.parent)) {
+          parts.unshift("default");
+        } else if (isExportDefaultDeclaration(current.parent)) {
+          parts.unshift("default");
+        } else if (isVariableDeclarator(current.parent) && isIdentifier(current.parent.id)) {
+          parts.unshift(current.parent.id.name);
+        }
+      }
+      break;
+    }
+    if (isMethodDefinition(current)) {
+      parts.unshift(current.key.type === "Identifier" ? current.key.name : "method");
+      // Look for the containing object/class name
+      if (isNodeWithParent(current) && current.parent) {
+        if (isClassBody(current.parent)) {
+          const classDecl = current.parent.parent;
+          if (classDecl && isClassDeclaration(classDecl) && classDecl.id) {
+            parts.unshift(classDecl.id.name);
+          }
+        } else if (isObjectExpression(current.parent)) {
+          // For object methods, try to find the variable name
+          let objNode: Node = current.parent;
+          while (isNodeWithParent(objNode) && objNode.parent) {
+            if (isVariableDeclarator(objNode.parent) && isIdentifier(objNode.parent.id)) {
+              parts.unshift(objNode.parent.id.name);
+              break;
+            }
+            objNode = objNode.parent;
+          }
+        }
+      }
+      break;
+    }
+    if (isVariableDeclarator(current) && isIdentifier(current.id)) {
+      parts.unshift(current.id.name);
+      break;
+    }
+    if (isFunctionNode(current)) {
+      // For anonymous functions, try to find a name from the parent
+      if (isNodeWithParent(current) && current.parent) {
+        if (isVariableDeclarator(current.parent) && isIdentifier(current.parent.id)) {
+          parts.unshift(current.parent.id.name);
+          break;
+        }
+      }
+    }
+    current = isNodeWithParent(current) ? current.parent : undefined;
+  }
+
+  return parts.length > 0 ? parts.join(".") : "anonymous";
+} 

package/plugin/loader/directives/index.ts

@@ -0,0 +1,13 @@
+export * from "./addLocalExportedNames.js";
+export * from "./getExports.js";
+export * from "./collectExportsFromModule.js";
+export * from "./analyzeDirectives.js";
+export * from "./analyzeModule.js";
+export * from "./collectExports.js";
+export * from "./getFunctionBody.js";
+export * from "./getFunctionName.js";
+export * from "./getQualifiedName.js";
+export * from "./processFunctionNode.js";
+export * from "./typeGuards.js";
+export * from "./utils.js";
+export * from "./types.js";