@mandujs/core 0.54.17 → 0.54.19

package/src/router/fs-scanner.ts

@@ -7,7 +7,7 @@
  */
 
 import { stat } from "fs/promises";
-import { join, relative, basename, extname } from "path";
+import { dirname, join, relative, basename, extname } from "path";
 import type {
   ScannedFile,
   FSScannerConfig,
@@ -33,46 +33,18 @@ import { METADATA_ROUTES } from "../routes/types";
 import type { HydrationConfig } from "../spec/schema";
 import {
   hasUseClientDirective,
+  resolveClientImportModulePath,
   resolveRouteLevelClientEntry,
 } from "./client-entry";
-
-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",
-  };
-}
+import { analyzeRouteSource } from "./route-source-analyzer";
+import {
+  assertNoClientBoundaryDiagnostics,
+  collectStaticImportSpecifiers,
+  isClientBoundaryModuleSpecifier,
+  transformClientBoundaries,
+  validateClientBoundaryExport,
+  validateClientBoundaryServerOnlyImports,
+} from "../bundler/client-boundary-transform";
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Scanner Class
@@ -406,8 +378,10 @@ export class FSScanner {
       // clientModule 결정: island 파일 또는 "use client"가 있는 page 자체
       let clientModule: string | undefined;
       let clientExportName: string | undefined;
+      let boundaries: NonNullable<FSRouteConfig["boundaries"]> = [];
       let hydration: HydrationConfig | undefined;
       let pageFileContent: string | null = null;
+      let pageHasUseClient = false;
 
       if (file.type === "page") {
         try {
@@ -416,7 +390,32 @@ export class FSScanner {
           pageFileContent = null;
         }
         if (pageFileContent) {
-          hydration = parsePageHydrationConfig(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,
+              modulePath,
+              routeId,
+              pageFileContent,
+              hydration?.priority ?? "visible",
+            );
+          }
+          if (boundaries.length > 0 && !hydration) {
+            hydration = {
+              strategy: "island",
+              priority: "visible",
+              preload: false,
+            };
+          }
         }
       }
 
@@ -436,12 +435,11 @@ export class FSScanner {
             conflictsWith: islands[0].absolutePath,
           });
         }
-      } else if (file.type === "page" && pageFileContent) {
-        // page 파일 자체에서 "use client" 확인
-        const hasUseClient = hasUseClientDirective(pageFileContent);
-        if (hasUseClient) {
+      } else if (file.type === "page" && pageFileContent) {
+        // page 파일 자체에서 "use client" 확인
+        if (pageHasUseClient) {
           clientModule = modulePath;
-        } else {
+        } else if (boundaries.length === 0) {
           const routeClientEntry = await resolveRouteLevelClientEntry(rootDir, modulePath, pageFileContent);
           clientModule = routeClientEntry?.modulePath;
           clientExportName = routeClientEntry?.exportName;
@@ -465,6 +463,7 @@ export class FSScanner {
         componentModule: file.type === "page" ? modulePath : undefined,
         clientModule,
         clientExportName,
+        boundaries: boundaries && boundaries.length > 0 ? boundaries : undefined,
         hydration,
         layoutChain,
         loadingModule,
@@ -486,7 +485,7 @@ export class FSScanner {
     return { routes, routeErrors };
   }
 
-  private hasHydrationShellMismatchRisk(pageContent: string, _islandRelativePath: string): boolean {
+  private hasHydrationShellMismatchRisk(pageContent: string, _islandRelativePath: string): boolean {
     // import문에서 island 모듈의 변수명을 직접 파싱
     const importMatch = pageContent.match(
       /import\s+([A-Za-z_$][A-Za-z0-9_$]*)\s+from\s+["'][^"']*\.island(?:\.(?:tsx?|jsx?))?["']/
@@ -503,10 +502,116 @@ export class FSScanner {
     return new RegExp(
       `typeof\\s+${islandVarName}\\s*!==\\s*["']undefined["']\\s*&&\\s*null`
     ).test(pageContent);
-  }
-
-  /**
-   * 레이아웃 체인 해결
+  }
+
+  private async resolveClientBoundaries(
+    rootDir: string,
+    routeModule: string,
+    routeId: string,
+    source: string,
+    hydrate: NonNullable<HydrationConfig["priority"]>,
+  ): Promise<NonNullable<FSRouteConfig["boundaries"]>> {
+    const modules = await this.collectRouteBoundaryModules(rootDir, routeModule, source);
+    const boundaries: NonNullable<FSRouteConfig["boundaries"]> = [];
+
+    for (const moduleInfo of modules) {
+      const result = transformClientBoundaries(moduleInfo.source, {
+        routeId,
+        fileName: moduleInfo.modulePath,
+        hydrate,
+        ordinalOffset: boundaries.length,
+      });
+      if (result.boundaries.length === 0) continue;
+
+      const diagnostics = [...result.diagnostics];
+      const resolved = await Promise.all(result.boundaries.map(async (boundary) => {
+        const modulePath = await resolveClientImportModulePath(rootDir, boundary.source.file, boundary.module);
+        const resolvedBoundary = {
+          ...boundary,
+          module: modulePath ?? boundary.module,
+        };
+        if (modulePath) {
+          const clientSource = await Bun.file(join(rootDir, modulePath)).text();
+          diagnostics.push(...validateClientBoundaryServerOnlyImports(clientSource, resolvedBoundary, modulePath));
+          const validation = validateClientBoundaryExport(clientSource, resolvedBoundary, modulePath);
+          if (validation.diagnostic) diagnostics.push(validation.diagnostic);
+        }
+        return resolvedBoundary;
+      }));
+      assertNoClientBoundaryDiagnostics(diagnostics);
+      boundaries.push(...resolved);
+    }
+
+    return boundaries;
+  }
+
+  private async collectRouteBoundaryModules(
+    rootDir: string,
+    routeModule: string,
+    routeSource: string,
+  ): Promise<Array<{ modulePath: string; source: string }>> {
+    const visited = new Set<string>();
+    const modules: Array<{ modulePath: string; source: string }> = [];
+
+    const visit = async (modulePath: string, source: string): Promise<void> => {
+      const normalizedModulePath = modulePath.replace(/\\/g, "/").replace(/^\.\//, "");
+      if (visited.has(normalizedModulePath)) return;
+      visited.add(normalizedModulePath);
+      modules.push({ modulePath: normalizedModulePath, source });
+
+      for (const specifier of collectStaticImportSpecifiers(source, normalizedModulePath)) {
+        if (isClientBoundaryModuleSpecifier(specifier)) continue;
+        const resolved = await this.resolveRouteOwnedImportModulePath(rootDir, normalizedModulePath, specifier);
+        if (!resolved || visited.has(resolved)) continue;
+
+        let childSource: string;
+        try {
+          childSource = await Bun.file(join(rootDir, resolved)).text();
+        } catch {
+          continue;
+        }
+        if (hasUseClientDirective(childSource)) continue;
+
+        await visit(resolved, childSource);
+      }
+    };
+
+    await visit(routeModule, routeSource);
+    return modules;
+  }
+
+  private async resolveRouteOwnedImportModulePath(
+    rootDir: string,
+    importerModule: string,
+    specifier: string,
+  ): Promise<string | null> {
+    const normalized = specifier.replace(/\\/g, "/");
+    let basePath: string | null = null;
+
+    if (normalized.startsWith("@/") || normalized.startsWith("~/")) {
+      basePath = join(rootDir, "src", normalized.slice(2));
+    } else if (normalized.startsWith("./") || normalized.startsWith("../")) {
+      basePath = join(rootDir, dirname(importerModule), normalized);
+    }
+
+    if (!basePath) return null;
+
+    for (const candidate of expandRouteImportCandidates(basePath)) {
+      try {
+        const entry = await stat(candidate);
+        if (entry.isFile()) {
+          return relative(rootDir, candidate).replace(/\\/g, "/");
+        }
+      } catch {
+        // Try the next candidate.
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * 레이아웃 체인 해결
    */
   private resolveLayoutChain(
     segments: ScannedFile["segments"],
@@ -755,7 +860,7 @@ export function synthesizeLocaleRoutes(
   return out;
 }
 
-function prefixRouteWithLocale(route: FSRouteConfig, locale: string): FSRouteConfig {
+function prefixRouteWithLocale(route: FSRouteConfig, locale: string): FSRouteConfig {
   const prefixedPattern = route.pattern === "/"
     ? `/${locale}`
     : `/${locale}${route.pattern.startsWith("/") ? route.pattern : `/${route.pattern}`}`;
@@ -771,12 +876,26 @@ function prefixRouteWithLocale(route: FSRouteConfig, locale: string): FSRouteCon
       { raw: locale, type: "static" },
       ...route.segments,
     ],
-  };
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Factory Function
-// ═══════════════════════════════════════════════════════════════════════════
+  };
+}
+
+function expandRouteImportCandidates(basePath: string): string[] {
+  if (/\.[cm]?[jt]sx?$/.test(basePath)) return [basePath];
+  return [
+    `${basePath}.tsx`,
+    `${basePath}.ts`,
+    `${basePath}.jsx`,
+    `${basePath}.js`,
+    join(basePath, "index.tsx"),
+    join(basePath, "index.ts"),
+    join(basePath, "index.jsx"),
+    join(basePath, "index.js"),
+  ];
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Factory Function
+// ═══════════════════════════════════════════════════════════════════════════
 
 /**
  * 스캐너 생성 팩토리 함수

package/src/router/fs-types.ts

@@ -6,7 +6,7 @@
  * @module router/fs-types
  */
 
-import type { RouteKind, HydrationConfig, SpecHttpMethod } from "../spec/schema";
+import type { RouteKind, HydrationConfig, RouteClientBoundary, SpecHttpMethod } from "../spec/schema";
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Segment Types
@@ -123,6 +123,9 @@ export interface FSRouteConfig {
   /** Named export used by the route-level client module, if not default. */
   clientExportName?: string;
 
+  /** Compiler-discovered client boundaries rendered by this route. */
+  boundaries?: RouteClientBoundary[];
+
   /** 적용할 레이아웃 체인 */
   layoutChain: string[];
 
@@ -223,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;