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

package/plugin/config/autoDiscover/resolveAutoDiscover.ts

@@ -1,24 +1,16 @@
-import type { ConfigEnv, UserConfig } from "vite";
-import type {
-  AutoDiscoveredFiles,
-  ResolvedUserOptions,
-} from "../../types.js";
-import { join } from "path";
+import { type ConfigEnv, type UserConfig } from "vite";
+import type { AutoDiscoveredFiles, ResolvedUserOptions } from "../../types.js";
 import { resolveBuildPages } from "./resolveBuildPages.js";
 import { resolvePages } from "../resolvePages.js";
-import { tryManifest } from "../../helpers/tryManifest.js";
-import type { Manifest } from "vite";
+import type { Logger, ResolvedConfig } from "vite";
 import { createGlobAutoDiscover } from "./createGlobAutoDiscover.js";
 import { customWorkerFiles } from "./customWorkerFiles.js";
 import { pageAndPropFiles } from "./pageAndPropFiles.js";
 
-const clientFiles = createGlobAutoDiscover("**/*.client.*");
-const serverFiles = createGlobAutoDiscover("**/*.server.*");
-const cssFiles = createGlobAutoDiscover("**/*.css");
-const jsonFiles = createGlobAutoDiscover("**/*.json");
+
 
 type ResolveAutoDiscoverProps = {
-  config: UserConfig;
+  config: UserConfig | ResolvedConfig;
   configEnv: ConfigEnv;
   userOptions: Pick<
     ResolvedUserOptions,
@@ -36,13 +28,14 @@ type ResolveAutoDiscoverProps = {
     | "pageExportName"
     | "propsExportName"
     | "htmlExportName"
-    | "rootExportName"  
+    | "rootExportName"
     | "Root"
     | "Html"
     | "verbose"
     | "panicThreshold"
+    | "autoDiscover"
   >;
-  condition: "react-server" | "react-client";
+  logger: Logger;
 };
 
 type ResolveAutoDiscoverReturn =
@@ -54,7 +47,7 @@ type ResolveAutoDiscoverReturn =
     }
   | {
       type: "error";
-      error: Error;
+      error: unknown;
       id: string;
       autoDiscoveredFiles?: never;
     };
@@ -68,16 +61,15 @@ export const resolveAutoDiscover: ResolveAutoDiscoverFn =
     config,
     configEnv,
     userOptions,
-    condition,
+    logger,
   }) {
-    const ssr = configEnv.isSsrBuild || condition === "react-server";
-    const envDir =
-      condition === "react-server"
-        ? userOptions.build.server
-        : ssr
-        ? userOptions.build.client
-        : userOptions.build.static;
-    const envId = `${envDir}${ssr ? "-ssr" : ""}`;
+    const envId = `${configEnv.command}-${configEnv.mode}`;
+    
+
+    
+    
+    
+
     const configInputRecord = {} as Record<string, string>;
     if (typeof config.build?.rollupOptions?.input === "string") {
       configInputRecord[
@@ -112,40 +104,19 @@ export const resolveAutoDiscover: ResolveAutoDiscoverFn =
         id: envId,
       };
     }
+    const clientFiles = createGlobAutoDiscover(userOptions.autoDiscover.clientEntry);
+    const serverFiles = createGlobAutoDiscover(userOptions.autoDiscover.serverEntry);
+    const cssFiles = createGlobAutoDiscover(userOptions.autoDiscover.cssEntry);
+    const jsonFiles = createGlobAutoDiscover(userOptions.autoDiscover.jsonEntry);
+    const htmlFiles = createGlobAutoDiscover(userOptions.autoDiscover.htmlPattern.source);
 
     const files = await resolveBuildPages({
       pages,
       userOptions,
+      logger,
     });
 
-    // Load static manifest for client build
-    let staticManifest: Manifest = {};
-    if (ssr && configEnv.command === "build") {
-      const staticManifestResult = await tryManifest({
-        root: userOptions.projectRoot,
-        ssrManifest: false,
-        outDir: join(userOptions.build.outDir, userOptions.build.static),
-      });
-      if (staticManifestResult.type === "success") {
-        staticManifest = staticManifestResult.manifest;
-      } else if (configEnv.command === "build") {
-        // in dev mode the static manifest is not needed
-        // without ssr, WE ARE BUILDING the static manifest, so only warn in the case of a build
-        if (staticManifestResult.type === "error") {
-          if(userOptions.panicThreshold === 'critical_errors') {
-            throw staticManifestResult.error;
-          } else {
-            console.error(staticManifestResult.error);
-          }
-        }
-        if(userOptions.panicThreshold === 'all_errors') {
-          throw new Error( "Failed to find static manifest." );
-        } else {
-          console.warn("Continuing without static manifest");
-        }
-        // this can still work, but, it won't be able to look up any client-side assets
-      }
-    }
+ 
 
     const customWorkerInputs = customWorkerFiles({
       inputs: {},
@@ -175,40 +146,49 @@ export const resolveAutoDiscover: ResolveAutoDiscoverFn =
       userOptions,
     });
 
+    const htmlInputs = await htmlFiles({
+      inputs: {},
+      userOptions,
+    });
+
     // Add custom Root and Html components to inputs
     const customComponentInputs: Record<string, string> = {};
-    if (typeof userOptions.Root === "string") {
-      const [rootKey] = userOptions.normalizer(userOptions.Root);
-      customComponentInputs[rootKey] = userOptions.Root;
+
+    // Add Root components from resolved build pages
+    for (const [rootKey, rootValue] of files.rootMap) {
+      if (!customComponentInputs[rootKey]) {
+        customComponentInputs[rootKey] = rootValue;
+      }
     }
-    if (typeof userOptions.Html === "string") {
-      const [htmlKey] = userOptions.normalizer(userOptions.Html);
-      customComponentInputs[htmlKey] = userOptions.Html;
+
+    // Add Html components from resolved build pages
+    for (const [htmlKey, htmlValue] of files.htmlMap) {
+      if (!customComponentInputs[htmlKey]) {
+        customComponentInputs[htmlKey] = htmlValue;
+      }
     }
 
-    const agnosticInputs = {
+
+    
+    // Separate client and server inputs
+    const clientInputsCollection = {
       ...configInputRecord,
       ...clientInputs,
       ...clientEntry,
       ...cssInputs,
     };
-    // Add inputs based on condition
-    const inputs =
-      condition !== "react-server"
-        ? {
-            ...indexHtmlInputs,
-            ...agnosticInputs,
-          }
-        : {
-            ...configInputRecord,
-            ...customWorkerInputs,
-            ...pageAndPropInputs,
-            ...agnosticInputs,
-            ...serverActions,
-            ...serverEntry,
-            ...jsonInputs,
-            ...customComponentInputs, // Add custom components to server build
-          };
+    
+    const serverInputsCollection = {
+      ...clientInputsCollection,
+      ...customWorkerInputs,
+      ...pageAndPropInputs,
+      ...cssInputs,
+      ...serverActions,
+      ...serverEntry,
+      ...jsonInputs,
+      ...customComponentInputs, // Add custom components to server build
+    };
+
     return {
       type: "success",
       id: envId,
@@ -217,8 +197,13 @@ export const resolveAutoDiscover: ResolveAutoDiscoverFn =
         workerPaths: customWorkerInputs,
         serverEntry,
         clientEntry,
-        staticManifest,
-        inputs,
+        staticInputs: {
+          ...indexHtmlInputs,
+          ...htmlInputs,
+          ...clientInputsCollection
+        },
+        clientInputs: clientInputsCollection,
+        serverInputs: serverInputsCollection,
         serverActions,
       },
     };

package/plugin/config/autoDiscover/resolveBuildPages.ts

@@ -1,30 +1,50 @@
 import { access } from "node:fs/promises";
 import { join } from "node:path";
-import type { PageName, PropsName, ResolvedBuildPages, ResolvedUserOptions } from "../../types.js";
+import type {
+  PageName,
+  PropsName,
+  ResolvedBuildPages,
+  ResolvedUserOptions,
+} from "../../types.js";
 import { resolveUrlOption } from "../resolveUrlOption.js";
+import type { Logger } from "vite";
+import type { Manifest } from "vite";
 
 let stashedBuildPages: ResolvedBuildPages | null = null;
 let stashedPages: string[] | null = null;
 
+// Helper function to resolve paths using manifest
+function resolvePathWithManifest(path: string, manifest: Manifest): string {
+  // Check if the path exists in the manifest
+  const manifestEntry = manifest[path];
+  if (manifestEntry && manifestEntry.file) {
+    // Return the compiled file path
+    return manifestEntry.file;
+  }
+  
+  // If not found in manifest, return the original path
+  return path;
+}
+
 /**
  * Resolves build pages by calling resolveUrlOption for each page in build.pages.
- * 
+ *
  * ## BUILD-TIME STATIC DISCOVERY
  * This function is called during build/startup to:
  * 1. Take the explicit `build.pages` array (e.g., ["/", "/about", "/products"])
  * 2. Call `resolveUrlOption` for each page to get file paths
  * 3. Build static maps (urlMap, pageMap, propsMap, routeMap) for fast runtime lookup
  * 4. Validate that resolved file paths actually exist on filesystem
- * 
+ *
  * ## Cache Strategy:
  * Results are cached (stashedBuildPages) to avoid re-resolving on every build.
  * Cache is invalidated only when the pages array changes.
- * 
+ *
  * ## Usage Flow:
  * - Called by build process and plugin initialization
  * - Feeds into auto-discovery system to populate urlMap cache
  * - Enables fast runtime lookup in getRouteFiles.ts without dynamic resolution
- * 
+ *
  * ## Limitation:
  * Only works when build.pages is explicitly provided. Without it, the system
  * falls back to filesystem scanning + dynamic resolution in getRouteFiles.ts.
@@ -32,12 +52,36 @@ let stashedPages: string[] | null = null;
 export async function resolveBuildPages({
   pages,
   userOptions,
+  logger,
+  manifest = {},
 }: {
   pages: string[];
-  userOptions: Pick<ResolvedUserOptions, PageName | PropsName | "Root" | "Html" | "build" | "moduleBase" | "projectRoot" | "normalizer" | "moduleBasePath" | "pageExportName" | "propsExportName" | "rootExportName" | "htmlExportName" | "verbose">;
+  userOptions: Pick<
+    ResolvedUserOptions,
+    | PageName
+    | PropsName
+    | "Root"
+    | "Html"
+    | "build"
+    | "moduleBase"
+    | "projectRoot"
+    | "normalizer"
+    | "moduleBasePath"
+    | "pageExportName"
+    | "propsExportName"
+    | "rootExportName"
+    | "htmlExportName"
+    | "verbose"
+  >;
+  logger: Logger;
+  manifest?: Manifest;
 }): Promise<ResolvedBuildPages> {
   if (userOptions.verbose) {
-    console.log(`[resolveBuildPages] resolveBuildPages called with pages:`, pages, `Root:`, userOptions.Root, `Html:`, userOptions.Html);
+    logger.info(
+      `[resolveBuildPages] resolveBuildPages called with pages:${
+        pages.length
+      } and Root: ${typeof userOptions.Root} Html: ${typeof userOptions.Html}`
+    );
   }
   // Check if pages array has changed
   const pagesChanged =
@@ -47,91 +91,124 @@ export async function resolveBuildPages({
 
   if (stashedBuildPages && !pagesChanged) {
     return stashedBuildPages; // Return directly without Promise.resolve
+  } else if (userOptions.verbose) {
+    if (stashedPages == null) {
+      logger.info(
+        `[resolveBuildPages] resolveBuildPages - first time resolving pages`
+      );
+    } else {
+      logger.info(
+        `[resolveBuildPages] resolveBuildPages - pages changed, re-resolving`
+      );
+    }
   }
-  const errors: Error[] = [];
+  const errors: unknown[] = [];
   const pageMap = new Map<string, string>();
   const propsMap = new Map<string, string>();
   const rootMap = new Map<string, string>();
   const htmlMap = new Map<string, string>();
-  const urlMap = new Map<string, { props: string | undefined; page: string; root?: string; html?: string }>();
+  const urlMap = new Map<
+    string,
+    { props: string | undefined; page: string; root?: string; html?: string }
+  >();
   const routeMap = new Map<string, string[]>();
 
   for (const page of pages) {
     const pageResult = await resolveUrlOption(userOptions, "Page", page);
-    if(pageResult.type === "error") {
+    if (pageResult.type === "error") {
       errors.push(pageResult.error);
       continue;
     }
     const [pageKey, pageValue] = userOptions.normalizer(pageResult.Page);
-    
+    const manifestResolvedPageValue = resolvePathWithManifest(pageValue, manifest);
+
     // Resolve Root component path if defined
     let rootValue: string | undefined;
     if (userOptions.Root) {
       if (userOptions.verbose) {
-        console.log(`[resolveBuildPages] resolveBuildPages - resolving Root for page: ${page}, Root option: ${userOptions.Root}`);
+        logger.info(
+          `[resolveBuildPages] resolveBuildPages - resolving Root for page: ${page}, Root option: ${userOptions.Root}`
+        );
       }
       const rootResult = await resolveUrlOption(userOptions, "Root", page);
       if (rootResult.type === "error") {
         if (userOptions.verbose) {
-          console.log(`[resolveBuildPages] resolveBuildPages - Root resolution failed:`, rootResult.error);
+          logger.info(
+            `[resolveBuildPages] resolveBuildPages - Root resolution failed with error message: \"${
+              (rootResult.error as Error)?.message
+            }\"`
+          );
         }
         errors.push(rootResult.error);
       } else {
-        const [rootKey, resolvedRootValue] = userOptions.normalizer(rootResult.Root);
+        const [rootKey, resolvedRootValue] = userOptions.normalizer(
+          rootResult.Root
+        );
+        const manifestResolvedRootValue = resolvePathWithManifest(resolvedRootValue, manifest);
         if (userOptions.verbose) {
-          console.log(`[resolveBuildPages] resolveBuildPages - Root resolved: ${rootResult.Root} -> ${resolvedRootValue}`);
+          logger.info(
+            `[resolveBuildPages] resolveBuildPages - Root resolved: ${rootResult.Root} -> ${resolvedRootValue} -> ${manifestResolvedRootValue}`
+          );
         }
-        rootValue = resolvedRootValue;
-        rootMap.set(rootKey, resolvedRootValue);
-      }
-    } else {
-      if (userOptions.verbose) {
-        console.log(`[resolveBuildPages] resolveBuildPages - No Root option defined`);
+        rootValue = manifestResolvedRootValue;
+        rootMap.set(rootKey, manifestResolvedRootValue);
       }
     }
-    
+
     // Resolve Html component path if defined
     let htmlValue: string | undefined;
     if (userOptions.Html) {
       if (userOptions.verbose) {
-        console.log(`[resolveBuildPages] resolveBuildPages - resolving Html for page: ${page}, Html option: ${userOptions.Html}`);
+        logger.info(
+          `[resolveBuildPages] resolveBuildPages - resolving Html for page: ${page}, Html option: ${userOptions.Html}`
+        );
       }
       const htmlResult = await resolveUrlOption(userOptions, "Html", page);
       if (htmlResult.type === "error") {
         if (userOptions.verbose) {
-          console.log(`[resolveBuildPages] resolveBuildPages - Html resolution failed:`, htmlResult.error);
+          logger.info(
+            `[resolveBuildPages] resolveBuildPages - Html resolution failed with error message: \"${
+              (htmlResult.error as Error)?.message
+            }\"`
+          );
         }
         errors.push(htmlResult.error);
       } else {
-        const [htmlKey, resolvedHtmlValue] = userOptions.normalizer(htmlResult.Html);
+        const [htmlKey, resolvedHtmlValue] = userOptions.normalizer(
+          htmlResult.Html
+        );
+        const manifestResolvedHtmlValue = resolvePathWithManifest(resolvedHtmlValue, manifest);
         if (userOptions.verbose) {
-          console.log(`[resolveBuildPages] resolveBuildPages - Html resolved: ${htmlResult.Html} -> ${resolvedHtmlValue}`);
+          logger.info(
+            `[resolveBuildPages] resolveBuildPages - Html resolved: ${htmlResult.Html} -> ${resolvedHtmlValue} -> ${manifestResolvedHtmlValue}`
+          );
         }
-        htmlValue = resolvedHtmlValue;
-        htmlMap.set(htmlKey, resolvedHtmlValue);
-      }
-    } else {
-      if (userOptions.verbose) {
-        console.log(`[resolveBuildPages] resolveBuildPages - No Html option defined`);
+        htmlValue = manifestResolvedHtmlValue;
+        htmlMap.set(htmlKey, manifestResolvedHtmlValue);
       }
     }
-    
-    if(!userOptions.props) {
-      urlMap.set(page, { props: undefined, page: pageValue, root: rootValue, html: htmlValue });
-      pageMap.set(pageKey, pageValue);
+
+    if (!userOptions.props) {
+      urlMap.set(page, {
+        props: undefined,
+        page: manifestResolvedPageValue,
+        root: rootValue,
+        html: htmlValue,
+      });
+      pageMap.set(pageKey, manifestResolvedPageValue);
       // Add to routeMap
-      const routes = routeMap.get(pageValue) || [];
+      const routes = routeMap.get(manifestResolvedPageValue) || [];
       routes.push(page);
-      routeMap.set(pageValue, routes);
+      routeMap.set(manifestResolvedPageValue, routes);
       continue;
     }
     try {
-      await access(join(userOptions.projectRoot, pageValue));
+      await access(join(userOptions.projectRoot, manifestResolvedPageValue));
     } catch {
-      errors.push(new Error(`Page file not found: ${pageValue}`));
+      errors.push(new Error(`Page file not found: ${manifestResolvedPageValue}`));
     }
     const propsResult = await resolveUrlOption(userOptions, "props", page);
-    if(propsResult.type === "error") {
+    if (propsResult.type === "error") {
       errors.push(propsResult.error);
       continue;
     }
@@ -139,72 +216,107 @@ export async function resolveBuildPages({
     // If propsPath is defined, check if it exists
     if (propsResult.props) {
       const [propsKey, propsValue] = userOptions.normalizer(propsResult.props);
-      if (propsValue !== pageValue) {
+      const manifestResolvedPropsValue = resolvePathWithManifest(propsValue, manifest);
+      if (manifestResolvedPropsValue !== manifestResolvedPageValue) {
         try {
-          await access(join(userOptions.projectRoot, propsValue));
+          await access(join(userOptions.projectRoot, manifestResolvedPropsValue));
         } catch {
-          errors.push(
-            new Error(`Props file not found: ${propsValue}`)
-          );
+          errors.push(new Error(`Props file not found: ${manifestResolvedPropsValue}`));
         }
       }
-      urlMap.set(page, { props: propsValue, page: pageValue, root: rootValue, html: htmlValue });
-      propsMap.set(propsKey, propsValue);
-      
+      urlMap.set(page, {
+        props: manifestResolvedPropsValue,
+        page: manifestResolvedPageValue,
+        root: rootValue,
+        html: htmlValue,
+      });
+      propsMap.set(propsKey, manifestResolvedPropsValue);
+
       // Add to routeMap for both page and props files
-      const pageRoutes = routeMap.get(pageValue) || [];
+      const pageRoutes = routeMap.get(manifestResolvedPageValue) || [];
       pageRoutes.push(page);
-      routeMap.set(pageValue, pageRoutes);
-      
-      const propsRoutes = routeMap.get(propsValue) || [];
+      routeMap.set(manifestResolvedPageValue, pageRoutes);
+
+      const propsRoutes = routeMap.get(manifestResolvedPropsValue) || [];
       propsRoutes.push(page);
-      routeMap.set(propsValue, propsRoutes);
+      routeMap.set(manifestResolvedPropsValue, propsRoutes);
     } else {
       // If no props path, use the page path for both
-      urlMap.set(page, { props: undefined, page: pageValue, root: rootValue, html: htmlValue });
-      
+      urlMap.set(page, {
+        props: undefined,
+        page: manifestResolvedPageValue,
+        root: rootValue,
+        html: htmlValue,
+      });
+
       // Add to routeMap for page file only
-      const routes = routeMap.get(pageValue) || [];
+      const routes = routeMap.get(manifestResolvedPageValue) || [];
       routes.push(page);
-      routeMap.set(pageValue, routes);
+      routeMap.set(manifestResolvedPageValue, routes);
     }
 
-    pageMap.set(pageKey, pageValue);
+    pageMap.set(pageKey, manifestResolvedPageValue);
   }
 
   // If there are no pages but custom components are defined, resolve them for a default route
   if (pages.length === 0 && (userOptions.Root || userOptions.Html)) {
     if (userOptions.verbose) {
-      console.log(`[resolveBuildPages] resolveBuildPages - No pages but custom components defined, resolving for default route`);
+      logger.info(
+        `[resolveBuildPages] resolveBuildPages - No pages but custom components defined, resolving for default route`
+      );
     }
     const defaultPage = "/";
-    
+
     // Resolve Root component for default route
     if (userOptions.Root) {
-      const rootResult = await resolveUrlOption(userOptions, "Root", defaultPage);
+      const rootResult = await resolveUrlOption(
+        userOptions,
+        "Root",
+        defaultPage
+      );
       if (rootResult.type === "success") {
-        const [rootKey, resolvedRootValue] = userOptions.normalizer(rootResult.Root);
+        const [rootKey, resolvedRootValue] = userOptions.normalizer(
+          rootResult.Root
+        );
         if (userOptions.verbose) {
-          console.log(`[resolveBuildPages] resolveBuildPages - Default Root resolved: ${rootResult.Root} -> ${resolvedRootValue}`);
+          logger.info(
+            `[resolveBuildPages] resolveBuildPages - Default Root resolved: ${rootResult.Root} -> ${resolvedRootValue}`
+          );
         }
         rootMap.set(rootKey, resolvedRootValue);
       }
     }
-    
+
     // Resolve Html component for default route
     if (userOptions.Html) {
-      const htmlResult = await resolveUrlOption(userOptions, "Html", defaultPage);
+      const htmlResult = await resolveUrlOption(
+        userOptions,
+        "Html",
+        defaultPage
+      );
       if (htmlResult.type === "success") {
-        const [htmlKey, resolvedHtmlValue] = userOptions.normalizer(htmlResult.Html);
+        const [htmlKey, resolvedHtmlValue] = userOptions.normalizer(
+          htmlResult.Html
+        );
         if (userOptions.verbose) {
-          console.log(`[resolveBuildPages] resolveBuildPages - Default Html resolved: ${htmlResult.Html} -> ${resolvedHtmlValue}`);
+          logger.info(
+            `[resolveBuildPages] resolveBuildPages - Default Html resolved: ${htmlResult.Html} -> ${resolvedHtmlValue}`
+          );
         }
         htmlMap.set(htmlKey, resolvedHtmlValue);
       }
     }
   }
 
-  stashedBuildPages = { pageMap, propsMap, rootMap, htmlMap, urlMap, routeMap, errors };
+  stashedBuildPages = {
+    pageMap,
+    propsMap,
+    rootMap,
+    htmlMap,
+    urlMap,
+    routeMap,
+    errors,
+  };
   stashedPages = [...pages];
   return stashedBuildPages;
 }