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

package/dist/plugin/loader/directives/analyzeDirectives.js

@@ -0,0 +1,221 @@
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+import { findDirectiveMatches } from './findDirectiveMatches.js';
+import { isFunctionNode } from './typeGuards.js';
+import { getFunctionBody } from './getFunctionBody.js';
+import { getFunctionName } from './getFunctionName.js';
+import { getExportedName } from './getExportedName.js';
+import { processFunctionNode } from './processFunctionNode.js';
+import { getDirectiveValue, isDirectiveAtStart, matchOverlapsDirective } from './utils.js';
+
+function analyzeDirectives(ast, source, optionsOrMatches) {
+  const hasOptions = optionsOrMatches != null && typeof optionsOrMatches === "object";
+  const directiveMatches = hasOptions && "matches" in optionsOrMatches ? optionsOrMatches : findDirectiveMatches(source);
+  const directiveInfo = {
+    fileLevel: null,
+    functionLevel: [],
+    warnings: []
+  };
+  let foundNonDirective = false;
+  let firstDirective = null;
+  let verbose = hasOptions && "verbose" in optionsOrMatches && optionsOrMatches.verbose;
+  for (const node of ast.body) {
+    if (verbose) {
+      console.log("[analyzeDirectives] Processing node:", {
+        type: node.type,
+        start: node.start,
+        end: node.end,
+        directive: "directive" in node ? node.directive : void 0,
+        beforeNode: node.start > 0 ? JSON.stringify(source.slice(0, node.start)) : "none",
+        foundNonDirective
+      });
+    }
+    if (node.type === "ExpressionStatement") {
+      let directive = null;
+      if ("directive" in node && typeof node.directive === "string") {
+        directive = node.directive;
+      } else if (node.expression.type === "Literal" && typeof node.expression.value === "string" && (node.expression.value === "use server" || node.expression.value === "use client")) {
+        directive = node.expression.value;
+      }
+      if (directive) {
+        const getDirectiveType = optionsOrMatches != null && "loader" in optionsOrMatches ? optionsOrMatches.loader?.getDirectiveType : void 0;
+        const type = getDirectiveType?.(directive) ?? (directive === "use server" ? "server" : "client");
+        if (!firstDirective) {
+          firstDirective = { type, range: [node.start, node.end] };
+          if (verbose) {
+            console.log("[analyzeDirectives] Found first directive:", directive, "at range:", [node.start, node.end]);
+          }
+        } else {
+          directiveInfo.warnings.push({
+            message: "Cannot have both 'use client' and 'use server' directives in the same file",
+            range: [0, 0],
+            type: "server"
+          });
+        }
+      } else {
+        if (!firstDirective) {
+          foundNonDirective = true;
+          if (optionsOrMatches != null && "verbose" in optionsOrMatches && optionsOrMatches?.verbose) {
+            console.log("[analyzeDirectives] Found non-directive expression before first directive, setting foundNonDirective=true");
+          }
+        }
+      }
+    } else if (node.type !== "ImportDeclaration" && node.type !== "ExportNamedDeclaration" && node.type !== "ExportDefaultDeclaration") {
+      if (!firstDirective) {
+        foundNonDirective = true;
+        if (verbose) {
+          console.log("[analyzeDirectives] Found non-directive node before first directive:", node.type, "setting foundNonDirective=true");
+        }
+      }
+    }
+    if (!firstDirective && node.start > 0) {
+      const beforeNode = source.slice(0, node.start).trim();
+      if (beforeNode.length > 0) {
+        foundNonDirective = true;
+        if (verbose) {
+          console.log("[analyzeDirectives] Found content before first directive:", JSON.stringify(beforeNode), "setting foundNonDirective=true");
+        }
+      }
+    }
+  }
+  if (firstDirective) {
+    directiveInfo.fileLevel = firstDirective;
+    if (!foundNonDirective && firstDirective.range[0] > 0) {
+      const beforeDirective = source.slice(0, firstDirective.range[0]).trim();
+      if (beforeDirective.length > 0) {
+        foundNonDirective = true;
+        if (verbose) {
+          console.log("[analyzeDirectives] Found content before directive:", JSON.stringify(beforeDirective), "setting foundNonDirective=true for directive");
+        }
+      }
+    }
+    if (foundNonDirective) {
+      directiveInfo.warnings.push({
+        message: "File-level directives must be at the top of the file, before any other code",
+        range: [firstDirective.range[0], firstDirective.range[1]],
+        type: firstDirective.type
+      });
+    }
+  }
+  const functionLevelMatches = directiveMatches.matches.filter((match) => {
+    if (directiveInfo.fileLevel && match.range[0] === directiveInfo.fileLevel.range[0] && match.range[1] === directiveInfo.fileLevel.range[1]) {
+      return false;
+    }
+    return true;
+  });
+  const processedFunctions = /* @__PURE__ */ new Set();
+  const functionNodes = [];
+  function traverseWithContext(node, context) {
+    if (isFunctionNode(node)) {
+      const body = getFunctionBody(node);
+      if (body) {
+        for (const match of functionLevelMatches) {
+          const directiveValue = getDirectiveValue(match.type);
+          if (isDirectiveAtStart(node, directiveValue)) {
+            const directiveNode = body.body[0];
+            const directiveStart = directiveNode.start;
+            const directiveEnd = directiveNode.end;
+            const matchOverlaps = matchOverlapsDirective(match.range, directiveStart, directiveEnd);
+            if (matchOverlaps) {
+              const functionName = getFunctionName(node) || "anonymous";
+              if (context.inFunction) {
+                const nameDesc = functionName === "anonymous" ? "" : ` '${functionName}'`;
+                directiveInfo.warnings.push({
+                  message: `Function${nameDesc} with '${directiveValue}' directive cannot be nested inside another function. Directives are only allowed in top-level functions.`,
+                  range: match.range,
+                  type: match.type
+                });
+                return;
+              }
+              if (context.inClass) {
+                const nameDesc = functionName === "anonymous" ? "" : ` '${functionName}'`;
+                directiveInfo.warnings.push({
+                  message: `Class method${nameDesc} with '${directiveValue}' directive is not supported. Directives are only allowed in top-level functions.`,
+                  range: match.range,
+                  type: match.type
+                });
+                return;
+              }
+              if (match.type === "server") {
+                functionNodes.push({ node, match, context: context.inFunction ? "nested" : context.inClass ? "class" : "top-level" });
+              } else {
+                directiveInfo.warnings.push({
+                  message: "Function-level 'use client' isn't allowed",
+                  range: match.range,
+                  type: "client"
+                });
+              }
+              break;
+            }
+          }
+        }
+      }
+      traverseChildren(node, { inFunction: true, inClass: context.inClass });
+    } else if (node.type === "ClassDeclaration" || node.type === "ClassExpression") {
+      traverseChildren(node, { inFunction: context.inFunction, inClass: true });
+    } else if (node.type === "MethodDefinition") {
+      traverseChildren(node, { inFunction: context.inFunction, inClass: true });
+    } else {
+      traverseChildren(node, context);
+    }
+  }
+  function traverseChildren(node, context) {
+    const nodeWithChildren = node;
+    for (const key in nodeWithChildren) {
+      if (key === "parent" || key === "start" || key === "end" || key === "loc" || key === "range") {
+        continue;
+      }
+      const value = nodeWithChildren[key];
+      if (value && typeof value === "object") {
+        if (Array.isArray(value)) {
+          for (const child of value) {
+            if (child && typeof child === "object" && child.type) {
+              traverseWithContext(child, context);
+            }
+          }
+        } else if (value.type) {
+          traverseWithContext(value, context);
+        }
+      }
+    }
+  }
+  traverseWithContext(ast, { inFunction: false, inClass: false });
+  for (const { node, match } of functionNodes) {
+    const name = getFunctionName(node) || "anonymous";
+    const exportName = getExportedName(node);
+    const functionKey = `${name}-${exportName || ""}-${match.range[0]}`;
+    if (processedFunctions.has(functionKey)) continue;
+    processedFunctions.add(functionKey);
+    processFunctionNode(node, name, exportName, match, directiveInfo);
+  }
+  if (directiveInfo.fileLevel && directiveInfo.functionLevel.length > 0) {
+    for (const func of directiveInfo.functionLevel) {
+      if (directiveInfo.fileLevel.type !== func.type) {
+        directiveInfo.warnings.push({
+          message: `Cannot have both 'use ${directiveInfo.fileLevel.type}' and 'use ${func.type}' directives in the same file`,
+          range: func.range,
+          type: "server"
+        });
+      } else if (func.type !== "server") {
+        directiveInfo.warnings.push({
+          message: `Function-level directives should be 'use server', but got 'use ${func.type}'`,
+          range: func.range,
+          type: "client"
+        });
+      } else {
+        directiveInfo.warnings.push({
+          message: `'use server' is already defined at the top of the file, this directive should be removed.`,
+          range: func.range,
+          type: "server"
+        });
+      }
+    }
+  }
+  return directiveInfo;
+}
+
+export { analyzeDirectives };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"analyzeDirectives.js","sources":["../../../../plugin/loader/directives/analyzeDirectives.ts"],"sourcesContent":["import { findDirectiveMatches } from \"./findDirectiveMatches.js\";\nimport { isFunctionNode } from \"./typeGuards.js\";\nimport { getFunctionBody } from \"./getFunctionBody.js\";\nimport { getFunctionName } from \"./getFunctionName.js\";\nimport { getExportedName } from \"./getExportedName.js\";\nimport { processFunctionNode } from \"./processFunctionNode.js\";\nimport { isDirectiveAtStart, getDirectiveValue, matchOverlapsDirective } from \"./utils.js\";\nimport type { DirectiveInfo, DirectiveMatch, DirectiveMatches } from \"./types.js\";\nimport type { Node, Program } from \"acorn\";\nimport type { DirectiveOptions } from \"../../types.js\";\n\n/**\n * Analyzes directives in the given source and AST, returning directiveInfo.\n */\nexport function analyzeDirectives(\n  ast: Program, \n  source: string,\n  matches?: DirectiveMatches,\n): DirectiveInfo;\nexport function analyzeDirectives(\n  ast: Program, \n  source: string,\n  options?: DirectiveOptions,\n): DirectiveInfo;\nexport function analyzeDirectives(\n  ast: Program, \n  source: string,\n  optionsOrMatches?: DirectiveMatches | DirectiveOptions,\n): DirectiveInfo {\n  const hasOptions  = optionsOrMatches != null && typeof optionsOrMatches === 'object';\n  const directiveMatches = hasOptions && 'matches' in optionsOrMatches\n    ? optionsOrMatches\n    : findDirectiveMatches(source);\n\n  const directiveInfo: DirectiveInfo = {\n    fileLevel: null,\n    functionLevel: [],\n    warnings: []\n  };\n\n  // Find file-level directives by checking AST\n  let foundNonDirective = false;\n  let firstDirective: DirectiveMatch | null = null;\n  let verbose = hasOptions && 'verbose' in optionsOrMatches && optionsOrMatches.verbose;\n  for (const node of ast.body) {\n    // Debug logging\n    if (verbose) {\n      console.log('[analyzeDirectives] Processing node:', {\n        type: node.type,\n        start: node.start,\n        end: node.end,\n        directive: 'directive' in node ? node.directive : undefined,\n        beforeNode: node.start! > 0 ? JSON.stringify(source.slice(0, node.start!)) : 'none',\n        foundNonDirective\n      });\n    }\n\n    // Only check for directives in expression statements\n    if (node.type === \"ExpressionStatement\") {\n      let directive: string | null = null;\n      if (\"directive\" in node && typeof node.directive === \"string\") {\n        directive = node.directive;\n      } else if (\n        node.expression.type === \"Literal\" &&\n        typeof node.expression.value === \"string\" &&\n        (node.expression.value === \"use server\" || node.expression.value === \"use client\")\n      ) {\n        directive = node.expression.value;\n      }\n\n      if (directive) {\n        const getDirectiveType = optionsOrMatches != null && 'loader' in optionsOrMatches ? optionsOrMatches.loader?.getDirectiveType : undefined;\n        const type = getDirectiveType?.(directive) ?? \n          (directive === \"use server\" ? \"server\" : \"client\");\n        if (!firstDirective) {\n          firstDirective = { type, range: [node.start!, node.end!] };\n          if (verbose) {\n            console.log('[analyzeDirectives] Found first directive:', directive, 'at range:', [node.start!, node.end!]);\n          }\n        } else {\n          directiveInfo.warnings.push({\n            message: \"Cannot have both 'use client' and 'use server' directives in the same file\",\n            range: [0, 0],\n            type: \"server\"\n          });\n        }\n      } else {\n        // This expression statement is not a directive, so mark as non-directive\n        // if we haven't found the first directive yet\n        if (!firstDirective) {\n          foundNonDirective = true;\n          if (optionsOrMatches != null && 'verbose' in optionsOrMatches && optionsOrMatches?.verbose) {\n            console.log('[analyzeDirectives] Found non-directive expression before first directive, setting foundNonDirective=true');\n          }\n        }\n      }\n    } else if (node.type !== \"ImportDeclaration\" && node.type !== \"ExportNamedDeclaration\" && node.type !== \"ExportDefaultDeclaration\") {\n      // Only mark actual code (not imports/exports) as non-directive\n      // if we haven't found the first directive yet\n      if (!firstDirective) {\n        foundNonDirective = true;\n        if (verbose) {\n          console.log('[analyzeDirectives] Found non-directive node before first directive:', node.type, 'setting foundNonDirective=true');\n        }\n      }\n    }\n\n    // Check if this node is after any comments or non-whitespace content\n    // Only matters if we haven't found the first directive yet\n    if (!firstDirective && node.start! > 0) {\n      const beforeNode = source.slice(0, node.start!).trim();\n      if (beforeNode.length > 0) {\n        foundNonDirective = true;\n        if (verbose) {\n          console.log('[analyzeDirectives] Found content before first directive:', JSON.stringify(beforeNode), 'setting foundNonDirective=true');\n        }\n      }\n    }\n  }\n\n  // Set the first directive as file-level if found\n  if (firstDirective) {\n    directiveInfo.fileLevel = firstDirective;\n    \n    // Check if there was content (including comments) before the directive\n    if (!foundNonDirective && firstDirective.range[0] > 0) {\n      const beforeDirective = source.slice(0, firstDirective.range[0]).trim();\n      if (beforeDirective.length > 0) {\n        foundNonDirective = true;\n        if (verbose) {\n          console.log('[analyzeDirectives] Found content before directive:', JSON.stringify(beforeDirective), 'setting foundNonDirective=true for directive');\n        }\n      }\n    }\n    \n    if (foundNonDirective) {\n      directiveInfo.warnings.push({\n        message: \"File-level directives must be at the top of the file, before any other code\",\n        range: [firstDirective.range[0], firstDirective.range[1]],\n        type: firstDirective.type\n      });\n    }\n  }\n\n  // Process function-level directives\n  const functionLevelMatches = directiveMatches.matches.filter((match: DirectiveMatch) => {\n    // Skip if this match is already used as a file-level directive\n    if (directiveInfo.fileLevel && \n        match.range[0] === directiveInfo.fileLevel.range[0] && \n        match.range[1] === directiveInfo.fileLevel.range[1]) {\n      return false;\n    }\n    return true;\n  });\n\n  const processedFunctions = new Set<string>();\n\n  // First pass: collect all function nodes with their directives\n  const functionNodes: Array<{node: Node, match: DirectiveMatch, context: string}> = [];\n  \n  // Track context during traversal\n  function traverseWithContext(node: Node, context: { inFunction: boolean, inClass: boolean }) {\n    if (isFunctionNode(node)) {\n      const body = getFunctionBody(node);\n      if (body) {\n        // Check if directive is at the start of the function body\n        for (const match of functionLevelMatches) {\n          const directiveValue = getDirectiveValue(match.type);\n          \n          if (isDirectiveAtStart(node, directiveValue)) {\n            // Check if the match range corresponds to this specific directive position\n            const directiveNode = body.body[0];\n            const directiveStart = directiveNode.start!;\n            const directiveEnd = directiveNode.end!;\n            \n            // Match based on position - the match should overlap with the directive node\n            const matchOverlaps = matchOverlapsDirective(match.range, directiveStart, directiveEnd);\n            \n            if (matchOverlaps) {\n              const functionName = getFunctionName(node) || \"anonymous\";\n              \n              // Check for invalid contexts based on traversal context\n              if (context.inFunction) {\n                const nameDesc = functionName === \"anonymous\" ? \"\" : ` '${functionName}'`;\n                directiveInfo.warnings.push({\n                  message: `Function${nameDesc} with '${directiveValue}' directive cannot be nested inside another function. Directives are only allowed in top-level functions.`,\n                  range: match.range,\n                  type: match.type\n                });\n                return; // Skip this function entirely\n              }\n              \n              if (context.inClass) {\n                const nameDesc = functionName === \"anonymous\" ? \"\" : ` '${functionName}'`;\n                directiveInfo.warnings.push({\n                  message: `Class method${nameDesc} with '${directiveValue}' directive is not supported. Directives are only allowed in top-level functions.`,\n                  range: match.range,\n                  type: match.type\n                });\n                return; // Skip this function entirely\n              }\n\n              // Only allow server directives in function-level contexts\n              if (match.type === \"server\") {\n                functionNodes.push({ node, match, context: context.inFunction ? \"nested\" : context.inClass ? \"class\" : \"top-level\" });\n              } else {\n                // Generate warning for client directives in functions\n                directiveInfo.warnings.push({\n                  message: \"Function-level 'use client' isn't allowed\",\n                  range: match.range,\n                  type: \"client\"\n                });\n              }\n              break;\n            }\n          }\n        }\n      }\n      \n      // Continue traversal with updated context (now inside a function)\n      traverseChildren(node, { inFunction: true, inClass: context.inClass });\n    } else if (node.type === \"ClassDeclaration\" || node.type === \"ClassExpression\") {\n      // Continue traversal with updated context (now inside a class)\n      traverseChildren(node, { inFunction: context.inFunction, inClass: true });\n    } else if (node.type === \"MethodDefinition\") {\n      // Method definitions are inside classes\n      traverseChildren(node, { inFunction: context.inFunction, inClass: true });\n    } else {\n      // Continue with same context\n      traverseChildren(node, context);\n    }\n  }\n  \n  function traverseChildren(node: Node, context: { inFunction: boolean, inClass: boolean }) {\n    const nodeWithChildren = node as any;\n    for (const key in nodeWithChildren) {\n      if (key === 'parent' || key === 'start' || key === 'end' || key === 'loc' || key === 'range') {\n        continue;\n      }\n      \n      const value = nodeWithChildren[key];\n      if (value && typeof value === 'object') {\n        if (Array.isArray(value)) {\n          for (const child of value) {\n            if (child && typeof child === 'object' && child.type) {\n              traverseWithContext(child, context);\n            }\n          }\n        } else if (value.type) {\n          traverseWithContext(value, context);\n        }\n      }\n    }\n  }\n  \n  // Start traversal at top level (not in function or class)\n  traverseWithContext(ast, { inFunction: false, inClass: false });\n\n  // Second pass: process functions in order\n  for (const { node, match } of functionNodes) {\n    const name = getFunctionName(node) || \"anonymous\";\n    const exportName = getExportedName(node);\n    const functionKey = `${name}-${exportName || ''}-${match.range[0]}`;\n\n    // Skip if we've already processed this function\n    if (processedFunctions.has(functionKey)) continue;\n    processedFunctions.add(functionKey);\n\n    processFunctionNode(node, name, exportName, match, directiveInfo);\n  }\n\n  // Add warnings for mixed server/client directives\n  if (directiveInfo.fileLevel && directiveInfo.functionLevel.length > 0) {\n    for (const func of directiveInfo.functionLevel) {\n      if (directiveInfo.fileLevel.type !== func.type) {\n        directiveInfo.warnings.push({\n          message: `Cannot have both 'use ${directiveInfo.fileLevel.type}' and 'use ${func.type}' directives in the same file`,\n          range: func.range,\n          type: \"server\"\n        });\n      } else if (func.type !== \"server\") {\n        directiveInfo.warnings.push({\n          message: `Function-level directives should be 'use server', but got 'use ${func.type}'`,\n          range: func.range,\n          type: \"client\"\n        });\n      } else {\n        directiveInfo.warnings.push({\n          message: `'use server' is already defined at the top of the file, this directive should be removed.`,\n          range: func.range,\n          type: \"server\"\n        });\n      }\n    }\n  }\n\n  return directiveInfo;\n} "],"names":[],"mappings":"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"}

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

@@ -0,0 +1,7 @@
+import type { ParseResult } from "./types.js";
+import type { DirectiveOptions } from "../../types.js";
+/**
+ * Analyzes a module for directives and returns the parse result with directive info.
+ */
+export declare function analyzeModule(source: string, options?: DirectiveOptions): Promise<ParseResult>;
+//# sourceMappingURL=analyzeModule.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"analyzeModule.d.ts","sourceRoot":"","sources":["../../../../plugin/loader/directives/analyzeModule.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAiB,WAAW,EAAE,MAAM,YAAY,CAAC;AAC7D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAEvD;;GAEG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,CAAC,WAAW,CAAC,CA4CtB"}

package/dist/plugin/loader/directives/analyzeModule.js

@@ -0,0 +1,48 @@
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+import { parse } from '../parse.js';
+import { analyzeDirectives } from './analyzeDirectives.js';
+import { getExports } from './getExports.js';
+
+async function analyzeModule(source, options) {
+  let result = typeof options?.loader.parse === "function" ? options.loader.parse(source) : parse(source);
+  if (result instanceof Promise) {
+    result = await result;
+  }
+  if (typeof result === "object" && !("ast" in result)) {
+    result = {
+      ast: result
+    };
+  }
+  const exports = typeof result === "object" && "exports" in result && result.exports ? result.exports : await getExports(result.ast);
+  if (options?.verbose) {
+    if (exports && exports.exports.size > 0) {
+      console.log(
+        "[analyzeModule] exports",
+        Array.from(exports.exports.values())
+      );
+    }
+  }
+  const directiveInfo = analyzeDirectives(result.ast, source, options);
+  if (options?.verbose) {
+    if (directiveInfo.warnings.length > 0) {
+      console.log("[analyzeModule] warnings", directiveInfo.warnings);
+    }
+  }
+  let { code = source, map, ast, exports: _, ...rest } = result;
+  return {
+    type: "success",
+    ...rest,
+    code,
+    map,
+    ast,
+    exports,
+    directiveInfo
+  };
+}
+
+export { analyzeModule };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,13 @@
+import type { Program } from "acorn";
+import type { ExportInfo } from "./types.js";
+/**
+ * Collects all exports from a module, including:
+ * - Named exports
+ * - Default exports
+ * - Re-exports
+ * - Object method exports
+ * - Class method exports
+ * - Export * declarations
+ */
+export declare function collectExports(program: Program): Promise<ExportInfo[]>;
+//# sourceMappingURL=collectExports.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"collectExports.d.ts","sourceRoot":"","sources":["../../../../plugin/loader/directives/collectExports.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAQV,OAAO,EACR,MAAM,OAAO,CAAC;AACf,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AA0H7C;;;;;;;;GAQG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAuC5E"}

package/dist/plugin/loader/directives/collectExports.js

@@ -0,0 +1,116 @@
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+import { isArrowFunctionExpression, isFunctionExpression } from './typeGuards.js';
+import { addLocalExportedNames } from './addLocalExportedNames.js';
+
+function createExportInfo(localName, exportName, type, range, originalModuleId) {
+  return {
+    localName,
+    exportName,
+    type,
+    range,
+    originalModuleId
+  };
+}
+function handleTypedExport(id, exportName, type, range) {
+  return createExportInfo(
+    id?.name || "anonymous",
+    exportName,
+    type,
+    range
+  );
+}
+function handleDefaultExport(declaration, range) {
+  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, range) {
+  const exports = [];
+  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, range, sourceModuleId) {
+  const exports = [];
+  for (const specifier of specifiers) {
+    if (specifier.local.type === "Identifier" && specifier.exported.type === "Identifier") {
+      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;
+}
+async function collectExports(program) {
+  const exports = [];
+  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":
+        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 : void 0;
+          const reExports = await handleReExports(node.specifiers, [node.start, node.end], sourceModuleId);
+          exports.push(...reExports);
+        }
+        break;
+    }
+  }
+  return exports;
+}
+
+export { collectExports };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"collectExports.js","sources":["../../../../plugin/loader/directives/collectExports.ts"],"sourcesContent":["import type {\n  AnonymousClassDeclaration,\n  AnonymousFunctionDeclaration,\n  ClassDeclaration,\n  Declaration,\n  ExportSpecifier,\n  Expression,\n  FunctionDeclaration,\n  Program,\n} from \"acorn\";\nimport type { ExportInfo } from \"./types.js\";\nimport {\n  isArrowFunctionExpression,\n  isFunctionExpression,\n} from \"./typeGuards.js\";\nimport { addLocalExportedNames } from \"./addLocalExportedNames.js\";\n\nfunction createExportInfo(\n  localName: string,\n  exportName: string,\n  type: \"function\" | \"class\" | \"variable\" | null,\n  range: [number, number],\n  originalModuleId?: string\n): ExportInfo {\n  return {\n    localName,\n    exportName,\n    type,\n    range,\n    originalModuleId,\n  };\n}\n\nfunction handleTypedExport(\n  id: { name: string } | null,\n  exportName: string,\n  type: \"function\" | \"class\",\n  range: [number, number]\n): ExportInfo {\n  return createExportInfo(\n    id?.name || \"anonymous\",\n    exportName,\n    type,\n    range\n  );\n}\n\nfunction handleDefaultExport(\n  declaration:\n    | AnonymousFunctionDeclaration\n    | FunctionDeclaration\n    | AnonymousClassDeclaration\n    | ClassDeclaration\n    | Expression,\n  range: [number, number]\n): ExportInfo | null {\n  if (declaration.type === \"Identifier\") {\n    return createExportInfo(declaration.name, \"default\", null, range);\n  } else if (declaration.type === \"FunctionDeclaration\") {\n    return handleTypedExport(declaration.id, \"default\", \"function\", range);\n  } else if (declaration.type === \"ClassDeclaration\") {\n    return handleTypedExport(declaration.id, \"default\", \"class\", range);\n  } else if (declaration.type === \"ArrowFunctionExpression\") {\n    return handleTypedExport(null, \"default\", \"function\", range);\n  }\n  return null;\n}\n\nfunction handleNamedExport(\n  declaration: Declaration | Expression,\n  range: [number, number]\n): ExportInfo[] {\n  const exports: ExportInfo[] = [];\n\n  if (declaration.type === \"VariableDeclaration\") {\n    for (const decl of declaration.declarations) {\n      if (decl.init) {\n        if (\n          isArrowFunctionExpression(decl.init) ||\n          isFunctionExpression(decl.init)\n        ) {\n          if (decl.id.type === \"Identifier\") {\n            exports.push(handleTypedExport(decl.id, decl.id.name, \"function\", range));\n          }\n        } else {\n          addLocalExportedNames(exports, decl.id, range);\n        }\n      } else {\n        addLocalExportedNames(exports, decl.id, range);\n      }\n    }\n  } else if (declaration.type === \"FunctionDeclaration\" && declaration.id) {\n    exports.push(\n      handleTypedExport(declaration.id, declaration.id.name, \"function\", range)\n    );\n  } else if (declaration.type === \"ClassDeclaration\" && declaration.id) {\n    exports.push(handleTypedExport(declaration.id, declaration.id.name, \"class\", range));\n  }\n\n  return exports;\n}\n\nasync function handleReExports(\n  specifiers: ExportSpecifier[],\n  range: [number, number],\n  sourceModuleId?: string\n): Promise<ExportInfo[]> {\n  const exports: ExportInfo[] = [];\n\n  for (const specifier of specifiers) {\n    if (\n      specifier.local.type === \"Identifier\" &&\n      specifier.exported.type === \"Identifier\"\n    ) {\n      // For re-exports from another module, use exported name for function reference\n      // For local exports with aliases, use local name for function reference\n      const functionName = sourceModuleId ? specifier.exported.name : specifier.local.name;\n      \n      exports.push(\n        createExportInfo(\n          functionName,              // Function reference name\n          specifier.exported.name,   // Export name\n          \"function\",\n          range,\n        )\n      );\n    }\n  }\n\n  return exports;\n}\n\n/**\n * Collects all exports from a module, including:\n * - Named exports\n * - Default exports\n * - Re-exports\n * - Object method exports\n * - Class method exports\n * - Export * declarations\n */\nexport async function collectExports(program: Program): Promise<ExportInfo[]> {\n  const exports: ExportInfo[] = [];\n\n  for (const node of program.body) {\n    switch (node.type) {\n      case \"ExportDefaultDeclaration\": {\n        const exportInfo = handleDefaultExport(node.declaration, [\n          node.start,\n          node.end,\n        ]);\n        if (exportInfo) {\n          exports.push(exportInfo);\n        }\n        break;\n      }\n\n      case \"ExportAllDeclaration\":\n        // If export * is used, the other file needs to explicitly opt into \"use server\" too.\n        // This matches React's loader behavior - we ignore export * declarations\n        break;\n\n      case \"ExportNamedDeclaration\":\n        if (node.declaration) {\n          exports.push(\n            ...handleNamedExport(node.declaration, [node.start, node.end])\n          );\n        }\n        if (node.specifiers) {\n          const sourceModuleId = node.source && typeof node.source.value === \"string\" \n            ? node.source.value \n            : undefined;\n          const reExports = await handleReExports(node.specifiers, [node.start, node.end], sourceModuleId);\n          exports.push(...reExports);\n        }\n        break;\n    }\n  }\n\n  return exports;\n}\n"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,6 @@
+import type { ExportInfo } from "./types.js";
+/**
+ * Recursively collects exports from a module that uses export *
+ */
+export declare function collectExportsFromModule(moduleId: string): Promise<ExportInfo[]>;
+//# sourceMappingURL=collectExportsFromModule.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"collectExportsFromModule.d.ts","sourceRoot":"","sources":["../../../../plugin/loader/directives/collectExportsFromModule.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAI7C;;GAEG;AACH,wBAAsB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAgBpF"}

package/dist/plugin/loader/directives/collectExportsFromModule.js

@@ -0,0 +1,24 @@
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+import { parse } from '../parse.js';
+import { getExports } from './getExports.js';
+import { loadClientSource } from '../../helpers/moduleResolver.js';
+
+async function collectExportsFromModule(moduleId) {
+  const source = await loadClientSource(moduleId);
+  if (typeof source !== "string") {
+    throw new Error("Expected source to be a string");
+  }
+  const { ast } = await parse(source);
+  const exports = await getExports(ast);
+  return Array.from(exports.exports.values()).map((exp) => ({
+    ...exp,
+    originalModuleId: exp.originalModuleId || moduleId
+  }));
+}
+
+export { collectExportsFromModule };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,3 @@
+import type { DirectiveMatches } from "./types.js";
+export declare function findDirectiveMatches(source: string): DirectiveMatches;
+//# sourceMappingURL=findDirectiveMatches.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"findDirectiveMatches.d.ts","sourceRoot":"","sources":["../../../../plugin/loader/directives/findDirectiveMatches.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,gBAAgB,EAAoB,MAAM,YAAY,CAAC;AAErF,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,GACb,gBAAgB,CAuBlB"}

package/dist/plugin/loader/directives/findDirectiveMatches.js

@@ -0,0 +1,46 @@
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+function findDirectiveMatches(source) {
+  const matches = [];
+  const warnings = [];
+  const serverMatches = findServerDirectives(source);
+  const clientMatches = findClientDirectives(source);
+  const allMatches = [...serverMatches, ...clientMatches].sort((a, b) => a.range[0] - b.range[0]);
+  if (allMatches.length === 0) {
+    return { matches, warnings };
+  }
+  for (const match of allMatches) {
+    matches.push(match);
+  }
+  return { matches, warnings };
+}
+function findServerDirectives(source) {
+  const matches = [];
+  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) {
+  const matches = [];
+  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;
+}
+
+export { findDirectiveMatches };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,3 @@
+import type { Node } from "acorn";
+export declare function getExportedName(node: Node): string | undefined;
+//# sourceMappingURL=getExportedName.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getExportedName.d.ts","sourceRoot":"","sources":["../../../../plugin/loader/directives/getExportedName.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAkI,MAAM,OAAO,CAAC;AAElK,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,GAAG,SAAS,CAsE9D"}