@mandujs/core 0.54.18 → 0.54.20

package/src/router/client-entry.ts

@@ -5,6 +5,7 @@ import {
   formatClientBoundaryDiagnostics,
   validateClientBoundaryServerOnlyImports,
 } from "../bundler/client-boundary-transform";
+import { analyzeRouteSource, type RouteSourceImportRecord } from "./route-source-analyzer";
 
 export interface ClientComponentImport {
   module: string;
@@ -34,13 +35,13 @@ export function normalizeRouteModulePath(value: string | undefined): string {
   return (value ?? "").replace(/\\/g, "/").replace(/^\.\//, "");
 }
 
-export function hasUseClientDirective(source: string): boolean {
-  return /^(?:\uFEFF)?\s*(?:(?:\/\/[^\r\n]*(?:\r?\n|$))|(?:\/\*[\s\S]*?\*\/\s*))*["']use client["']\s*;?/.test(source);
-}
-
-export function hasUseServerDirective(source: string): boolean {
-  return /^(?:\uFEFF)?\s*(?:(?:\/\/[^\r\n]*(?:\r?\n|$))|(?:\/\*[\s\S]*?\*\/\s*))*["']use server["']\s*;?/.test(source);
-}
+export function hasUseClientDirective(source: string): boolean {
+  return analyzeRouteSource(source).directives.useClient;
+}
+
+export function hasUseServerDirective(source: string): boolean {
+  return analyzeRouteSource(source).directives.useServer;
+}
 
 export function clientModuleIsRouteComponent(route: RouteSpec, clientModule = route.clientModule): boolean {
   if (route.kind !== "page" || !clientModule) return false;
@@ -75,77 +76,65 @@ function toPublicClientComponentImport(entry: ComponentImportRecord): ClientComp
 }
 
 function findComponentImportRecords(source: string): ComponentImportRecord[] {
-  const imports: ComponentImportRecord[] = [];
-  const importFromPattern = /import\s+(?!type\b)([\s\S]*?)\s+from\s+["']([^"']+)["']/g;
-  const sideEffectPattern = /import\s+["']([^"']+)["']/g;
-
-  for (const match of source.matchAll(importFromPattern)) {
-    const clause = (match[1] ?? "").trim();
-    const module = match[2] ?? "";
-    const names: string[] = [];
-    const specifiers: ComponentImportSpecifier[] = [];
-    let hasDefault = false;
-    let hasNamed = false;
-    let hasNamespace = false;
-
-    const namedMatch = clause.match(/\{([^}]*)\}/);
-    if (namedMatch) {
-      hasNamed = true;
-      for (const rawName of namedMatch[1].split(",")) {
-        const name = rawName.trim();
-        if (!name) continue;
-        const parts = name.split(/\s+as\s+/i).map((part) => part.trim()).filter(Boolean);
-        const importedName = parts[0] ?? "";
-        const localName = parts[1] ?? importedName;
-        names.push(localName);
-        specifiers.push({ importedName, localName });
-      }
-    }
+  return findComponentImportRecordsFromAnalysis(analyzeRouteSource(source).imports);
+}
 
-    if (/\*\s+as\s+/.test(clause)) {
-      hasNamespace = true;
-      const namespaceMatch = clause.match(/\*\s+as\s+([A-Za-z_$][A-Za-z0-9_$]*)/);
-      if (namespaceMatch?.[1]) {
-        names.push(namespaceMatch[1]);
-        specifiers.push({ importedName: "*", localName: namespaceMatch[1] });
-      }
-    }
+function findComponentImportRecordsFromAnalysis(imports: RouteSourceImportRecord[]): ComponentImportRecord[] {
+  return imports.flatMap(toComponentImportRecord);
+}
 
-    const beforeNamed = clause.split("{")[0]?.replace(/,\s*$/, "").trim() ?? "";
-    if (beforeNamed && !beforeNamed.startsWith("*")) {
-      hasDefault = true;
-      const localName = beforeNamed.split(",")[0].trim();
-      names.push(localName);
-      specifiers.push({ importedName: DEFAULT_EXPORT_NAME, localName });
-    }
-
-    const kind =
-      (hasDefault && (hasNamed || hasNamespace))
-        ? "mixed"
-        : hasNamed
-          ? "named"
-          : hasNamespace
-            ? "namespace"
-            : "default";
-
-    imports.push({ module, kind, names, specifiers });
+function toComponentImportRecord(entry: RouteSourceImportRecord): ComponentImportRecord[] {
+  if (entry.isSideEffectOnly) {
+    return [{ module: entry.source, kind: "side-effect", names: [], specifiers: [] }];
   }
-
-  for (const match of source.matchAll(sideEffectPattern)) {
-    const module = match[1] ?? "";
-    if (imports.some((entry) => entry.module === module)) continue;
-    imports.push({ module, kind: "side-effect", names: [], specifiers: [] });
+  if (entry.isTypeOnly) return [];
+
+  const names: string[] = [];
+  const specifiers: ComponentImportSpecifier[] = [];
+  let hasDefault = false;
+  let hasNamed = false;
+  let hasNamespace = false;
+
+  if (entry.defaultName) {
+    hasDefault = true;
+    names.push(entry.defaultName);
+    specifiers.push({ importedName: DEFAULT_EXPORT_NAME, localName: entry.defaultName });
   }
 
-  return imports;
-}
+  if (entry.namespaceName) {
+    hasNamespace = true;
+    names.push(entry.namespaceName);
+    specifiers.push({ importedName: "*", localName: entry.namespaceName });
+  }
+
+  for (const named of entry.named) {
+    if (named.isTypeOnly) continue;
+    hasNamed = true;
+    names.push(named.local);
+    specifiers.push({ importedName: named.imported, localName: named.local });
+  }
+
+  if (names.length === 0) return [];
+
+  const kind =
+    (hasDefault && (hasNamed || hasNamespace))
+      ? "mixed"
+      : hasNamed
+        ? "named"
+        : hasNamespace
+          ? "namespace"
+          : "default";
+
+  return [{ module: entry.source, kind, names, specifiers }];
+}
 
 export function findRouteLevelClientComponentImport(source: string): RouteLevelClientComponentImport | null {
   return findRouteLevelClientComponentImports(source)[0] ?? null;
 }
 
 export function findRouteLevelClientComponentImports(source: string): RouteLevelClientComponentImport[] {
-  const candidates = findComponentImportRecords(source).flatMap((entry) =>
+  const analysis = analyzeRouteSource(source);
+  const candidates = findComponentImportRecordsFromAnalysis(analysis.imports).flatMap((entry) =>
     isRouteLevelClientEntrySpecifier(entry.module)
       ? entry.specifiers
           .filter((specifier) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(specifier.localName))
@@ -156,10 +145,10 @@ export function findRouteLevelClientComponentImports(source: string): RouteLevel
           }))
       : []
   );
-
-  if (candidates.length === 0) return [];
-  return defaultExportRendersClientComponents(source, candidates);
-}
+
+  if (candidates.length === 0) return [];
+  return defaultExportRendersClientComponents(analysis.defaultExport.renderedJsxNames, candidates);
+}
 
 function isRouteLevelClientEntrySpecifier(specifier: string): boolean {
   const normalized = specifier.replace(/\\/g, "/");
@@ -272,236 +261,24 @@ function clientSpecifierLooksBrowserOnly(specifier: string): boolean {
   return CLIENT_ENTRY_SPECIFIER_PATTERN.test(specifier.replace(/\\/g, "/"));
 }
 
-function defaultExportRendersClientComponents(
-  source: string,
-  candidates: RouteLevelClientComponentImport[],
-): RouteLevelClientComponentImport[] {
-  const functionBody = extractDefaultExportFunctionBody(source);
-  if (functionBody !== null) {
-    const returned = extractTopLevelReturnExpression(functionBody);
-    return returned !== null ? jsxExpressionRendersClientComponents(returned, candidates) : [];
-  }
-
-  const arrowExpression = extractDefaultExportArrowExpression(source);
-  if (arrowExpression !== null) {
-    return jsxExpressionRendersClientComponents(arrowExpression, candidates);
-  }
-
-  const arrowBody = extractDefaultExportArrowFunctionBody(source);
-  if (arrowBody !== null) {
-    const returned = extractTopLevelReturnExpression(arrowBody);
-    return returned !== null ? jsxExpressionRendersClientComponents(returned, candidates) : [];
-  }
-
-  return [];
-}
-
-function extractDefaultExportFunctionBody(source: string): string | null {
-  const match = /export\s+default\s+(?:async\s+)?function(?:\s+[A-Za-z_$][A-Za-z0-9_$]*)?\s*\([^)]*\)\s*(?::\s*[^{=]+)?\{/m.exec(source);
-  if (!match) return null;
-
-  const openBrace = match.index + match[0].lastIndexOf("{");
-  const closeBrace = findMatchingBrace(source, openBrace);
-  if (closeBrace === -1) return null;
-  return source.slice(openBrace + 1, closeBrace);
-}
-
-function extractDefaultExportArrowExpression(source: string): string | null {
-  const match = /export\s+default\s+(?:async\s+)?(?:\([^)]*\)|[A-Za-z_$][A-Za-z0-9_$]*)\s*=>\s*/m.exec(source);
-  if (!match) return null;
-
-  const start = match.index + match[0].length;
-  const rest = source.slice(start).trim();
-  if (rest.startsWith("{")) return null;
-
-  const semicolon = rest.indexOf(";");
-  return semicolon === -1 ? rest : rest.slice(0, semicolon);
-}
-
-function extractDefaultExportArrowFunctionBody(source: string): string | null {
-  const match = /export\s+default\s+(?:async\s+)?(?:\([^)]*\)|[A-Za-z_$][A-Za-z0-9_$]*)\s*=>\s*\{/m.exec(source);
-  if (!match) return null;
-
-  const openBrace = match.index + match[0].lastIndexOf("{");
-  const closeBrace = findMatchingBrace(source, openBrace);
-  if (closeBrace === -1) return null;
-  return source.slice(openBrace + 1, closeBrace);
-}
-
-function extractTopLevelReturnExpression(body: string): string | null {
-  let quote: '"' | "'" | "`" | null = null;
-  let lineComment = false;
-  let blockComment = false;
-  let braceDepth = 0;
-  let parenDepth = 0;
-  let bracketDepth = 0;
-
-  for (let i = 0; i < body.length; i++) {
-    const char = body[i];
-    const next = body[i + 1];
-    const prev = body[i - 1];
-
-    if (lineComment) {
-      if (char === "\n" || char === "\r") lineComment = false;
-      continue;
-    }
-
-    if (blockComment) {
-      if (char === "*" && next === "/") {
-        blockComment = false;
-        i++;
-      }
-      continue;
-    }
-
-    if (quote) {
-      if (char === quote && prev !== "\\") quote = null;
-      continue;
-    }
-
-    if (char === "/" && next === "/") {
-      lineComment = true;
-      i++;
-      continue;
-    }
-    if (char === "/" && next === "*") {
-      blockComment = true;
-      i++;
-      continue;
-    }
-    if (char === '"' || char === "'" || char === "`") {
-      quote = char;
-      continue;
-    }
-
-    if (braceDepth === 0 && parenDepth === 0 && bracketDepth === 0 && body.startsWith("return", i)) {
-      const before = body[i - 1] ?? "";
-      const after = body[i + "return".length] ?? "";
-      if (!isIdentifierChar(before) && !isIdentifierChar(after)) {
-        const expr = body.slice(i + "return".length).trim();
-        return trimTrailingSemicolon(expr);
-      }
-    }
-
-    if (char === "{") braceDepth++;
-    if (char === "}") braceDepth = Math.max(0, braceDepth - 1);
-    if (char === "(") parenDepth++;
-    if (char === ")") parenDepth = Math.max(0, parenDepth - 1);
-    if (char === "[") bracketDepth++;
-    if (char === "]") bracketDepth = Math.max(0, bracketDepth - 1);
-  }
-
-  return null;
-}
-
-function trimTrailingSemicolon(value: string): string {
-  const trimmed = value.trim();
-  return trimmed.endsWith(";") ? trimmed.slice(0, -1).trim() : trimmed;
-}
-
-function jsxExpressionRendersClientComponents(
-  expression: string,
-  candidates: RouteLevelClientComponentImport[],
-): RouteLevelClientComponentImport[] {
-  const expr = stripWrappingParentheses(expression.trim());
-  const seen = new Set<string>();
-  const rendered: RouteLevelClientComponentImport[] = [];
-
-  for (const candidate of candidates) {
-    const key = `${candidate.module}\0${candidate.localName}`;
-    if (seen.has(key)) continue;
-    if (!jsxExpressionContainsClientElement(expr, candidate.localName)) continue;
-    seen.add(key);
-    rendered.push(candidate);
-  }
-
-  return rendered;
-}
-
-function jsxExpressionContainsClientElement(expression: string, localName: string): boolean {
-  const escaped = escapeRegExp(localName);
-  return new RegExp(`<${escaped}(?:\\s|/|>)`).test(expression);
-}
-
-function stripWrappingParentheses(value: string): string {
-  let current = value.trim();
-  while (current.startsWith("(") && current.endsWith(")")) {
-    const close = findMatchingParen(current, 0);
-    if (close !== current.length - 1) break;
-    current = current.slice(1, -1).trim();
-  }
-  return current;
-}
-
-function findMatchingBrace(source: string, openIndex: number): number {
-  return findMatchingDelimiter(source, openIndex, "{", "}");
-}
-
-function findMatchingParen(source: string, openIndex: number): number {
-  return findMatchingDelimiter(source, openIndex, "(", ")");
-}
-
-function findMatchingDelimiter(source: string, openIndex: number, open: string, close: string): number {
-  let depth = 0;
-  let quote: '"' | "'" | "`" | null = null;
-  let lineComment = false;
-  let blockComment = false;
-
-  for (let i = openIndex; i < source.length; i++) {
-    const char = source[i];
-    const next = source[i + 1];
-    const prev = source[i - 1];
-
-    if (lineComment) {
-      if (char === "\n" || char === "\r") lineComment = false;
-      continue;
-    }
-
-    if (blockComment) {
-      if (char === "*" && next === "/") {
-        blockComment = false;
-        i++;
-      }
-      continue;
-    }
-
-    if (quote) {
-      if (char === quote && prev !== "\\") quote = null;
-      continue;
-    }
-
-    if (char === "/" && next === "/") {
-      lineComment = true;
-      i++;
-      continue;
-    }
-    if (char === "/" && next === "*") {
-      blockComment = true;
-      i++;
-      continue;
-    }
-    if (char === '"' || char === "'" || char === "`") {
-      quote = char;
-      continue;
-    }
-
-    if (char === open) depth++;
-    if (char === close) {
-      depth--;
-      if (depth === 0) return i;
-    }
-  }
-
-  return -1;
-}
-
-function escapeRegExp(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-function isIdentifierChar(value: string): boolean {
-  return /[A-Za-z0-9_$]/.test(value);
-}
+function defaultExportRendersClientComponents(
+  renderedJsxNames: string[],
+  candidates: RouteLevelClientComponentImport[],
+): RouteLevelClientComponentImport[] {
+  const renderedNames = new Set(renderedJsxNames);
+  const seen = new Set<string>();
+  const rendered: RouteLevelClientComponentImport[] = [];
+
+  for (const candidate of candidates) {
+    const key = `${candidate.module}\0${candidate.localName}`;
+    if (seen.has(key)) continue;
+    if (!renderedNames.has(candidate.localName)) continue;
+    seen.add(key);
+    rendered.push(candidate);
+  }
+
+  return rendered;
+}
 
 export async function validateClientModuleForBrowserBundle(
   route: RouteSpec,

package/src/router/fs-routes.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, it } from "bun:test";
 import { mkdir, mkdtemp, rm, writeFile } from "fs/promises";
 import path from "path";
 import { generateManifest } from "./fs-routes";
+import { scanRoutes } from "./fs-scanner";
 
 const repoTempRoot = path.resolve(import.meta.dir, "../../../..", ".tmp-test-artifacts");
 
@@ -474,4 +475,58 @@ describe("generateManifest hydration config", () => {
       await rm(rootDir, { recursive: true, force: true });
     }
   });
+
+  it("ignores hydration exports inside comments and strings", async () => {
+    const rootDir = await mkRepoTempDir("routes-hydration-ast-");
+    try {
+      await mkdir(path.join(rootDir, "app", "comment"), { recursive: true });
+      await writeFile(
+        path.join(rootDir, "app", "comment", "page.tsx"),
+        `
+          // export const hydration = { strategy: "island", priority: "immediate", preload: true };
+          const example = "export const hydration = 'full'";
+
+          export default function Page() {
+            return <main>{example}</main>;
+          }
+        `,
+        "utf-8",
+      );
+
+      const result = await generateManifest(rootDir);
+      const route = result.manifest.routes.find((entry) => entry.id === "comment");
+
+      expect(route?.hydration).toBeUndefined();
+    } finally {
+      await rm(rootDir, { recursive: true, force: true });
+    }
+  });
+
+  it("reports analyzer diagnostics for unsupported hydration initializers", async () => {
+    const rootDir = await mkRepoTempDir("routes-hydration-diagnostic-");
+    try {
+      await mkdir(path.join(rootDir, "app", "diagnostic"), { recursive: true });
+      await writeFile(
+        path.join(rootDir, "app", "diagnostic", "page.tsx"),
+        `
+          const getHydration = () => ({ strategy: "island" });
+          export const hydration = getHydration();
+
+          export default function Page() {
+            return <main>Diagnostic</main>;
+          }
+        `,
+        "utf-8",
+      );
+
+      const result = await scanRoutes(rootDir);
+
+      expect(result.errors).toContainEqual(expect.objectContaining({
+        type: "route_source_diagnostic",
+        message: expect.stringContaining("MANDU_ROUTE_HYDRATION_UNSUPPORTED_INITIALIZER"),
+      }));
+    } finally {
+      await rm(rootDir, { recursive: true, force: true });
+    }
+  });
 });

package/src/router/fs-scanner.ts

@@ -36,6 +36,7 @@ import {
   resolveClientImportModulePath,
   resolveRouteLevelClientEntry,
 } from "./client-entry";
+import { analyzeRouteSource } from "./route-source-analyzer";
 import {
   assertNoClientBoundaryDiagnostics,
   collectStaticImportSpecifiers,
@@ -45,44 +46,6 @@ import {
   validateClientBoundaryServerOnlyImports,
 } from "../bundler/client-boundary-transform";
 
-const HYDRATION_STRATEGIES = new Set(["none", "island", "full", "progressive"]);
-const HYDRATION_PRIORITIES = new Set(["immediate", "visible", "idle", "interaction"]);
-
-function parsePageHydrationConfig(source: string): HydrationConfig | undefined {
-  const stringMatch = source.match(
-    /export\s+const\s+hydration\s*(?::[^=]+)?=\s*["'](none|island|full|progressive)["']/m,
-  );
-  if (stringMatch?.[1]) {
-    return {
-      strategy: stringMatch[1] as HydrationConfig["strategy"],
-      priority: "visible",
-      preload: false,
-    };
-  }
-
-  const objectMatch = source.match(
-    /export\s+const\s+hydration\s*(?::[^=]+)?=\s*\{([\s\S]*?)\}\s*;?/m,
-  );
-  const body = objectMatch?.[1];
-  if (!body) return undefined;
-
-  const strategyMatch = body.match(/\bstrategy\s*:\s*["']([^"']+)["']/);
-  const strategy = strategyMatch?.[1];
-  if (!strategy || !HYDRATION_STRATEGIES.has(strategy)) return undefined;
-
-  const priorityMatch = body.match(/\bpriority\s*:\s*["']([^"']+)["']/);
-  const priority = priorityMatch?.[1];
-  const preloadMatch = body.match(/\bpreload\s*:\s*(true|false)\b/);
-
-  return {
-    strategy: strategy as HydrationConfig["strategy"],
-    priority: HYDRATION_PRIORITIES.has(priority ?? "")
-      ? (priority as HydrationConfig["priority"])
-      : "visible",
-    preload: preloadMatch?.[1] === "true",
-  };
-}
-
 // ═══════════════════════════════════════════════════════════════════════════
 // Scanner Class
 // ═══════════════════════════════════════════════════════════════════════════
@@ -427,8 +390,16 @@ export class FSScanner {
           pageFileContent = null;
         }
         if (pageFileContent) {
-          hydration = parsePageHydrationConfig(pageFileContent);
-          pageHasUseClient = hasUseClientDirective(pageFileContent);
+          const analysis = analyzeRouteSource(pageFileContent, modulePath);
+          hydration = analysis.hydrationConfig;
+          pageHasUseClient = analysis.directives.useClient;
+          for (const diagnostic of analysis.diagnostics) {
+            routeErrors.push({
+              type: "route_source_diagnostic",
+              message: `${diagnostic.code}: ${diagnostic.message}`,
+              filePath: file.absolutePath,
+            });
+          }
           if (!pageHasUseClient) {
             boundaries = await this.resolveClientBoundaries(
               rootDir,

package/src/router/fs-types.ts

@@ -226,7 +226,13 @@ export interface ScanResult {
  */
 export interface ScanError {
   /** 에러 타입 */
-  type: "invalid_segment" | "duplicate_route" | "file_read_error" | "pattern_conflict" | "hydration_shell_mismatch_risk";
+  type:
+    | "invalid_segment"
+    | "duplicate_route"
+    | "file_read_error"
+    | "pattern_conflict"
+    | "hydration_shell_mismatch_risk"
+    | "route_source_diagnostic";
 
   /** 에러 메시지 */
   message: string;