vite-plugin-react-server 1.0.2 → 1.1.0

package/plugin/config/autoDiscover/resolveBuildPages.ts

@@ -0,0 +1,98 @@
+import { access } from "node:fs/promises";
+import { join } from "node:path";
+import type { ResolvedBuildPages, ResolvedUserOptions } from "../../types.js";
+import { resolveUrlOption } from "../resolveUrlOption.js";
+
+let stashedBuildPages: ResolvedBuildPages | null = null;
+let stashedPages: string[] | null = null;
+
+export async function resolveBuildPages({
+  pages,
+  userOptions,
+}: {
+  pages: string[];
+  userOptions: Pick<ResolvedUserOptions, "Page" | "props" | "build" | "moduleBase" | "projectRoot" | "normalizer">;
+}): Promise<ResolvedBuildPages> {
+  // Check if pages array has changed
+  const pagesChanged =
+    !stashedPages ||
+    stashedPages.length !== pages.length ||
+    !stashedPages.every((page, i) => page === pages[i]);
+
+  if (stashedBuildPages && !pagesChanged) {
+    return stashedBuildPages; // Return directly without Promise.resolve
+  }
+  const errors: Error[] = [];
+  const pageMap = new Map<string, string>();
+  const propsMap = new Map<string, string>();
+  const urlMap = new Map<string, { props: string | undefined; page: string }>();
+  const routeMap = new Map<string, string[]>();
+
+  for (const page of pages) {
+    const pageResult = await resolveUrlOption(userOptions, "Page", page);
+    if(pageResult.type === "error") {
+      errors.push(pageResult.error);
+      continue;
+    }
+    if(!userOptions.props) {
+      urlMap.set(page, { props: undefined, page: pageResult.Page });
+      pageMap.set(page, pageResult.Page);
+      // Add to routeMap
+      const routes = routeMap.get(pageResult.Page) || [];
+      routes.push(page);
+      routeMap.set(pageResult.Page, routes);
+      continue;
+    }
+    const propsResult = await resolveUrlOption(userOptions, "props", page);
+    if(propsResult.type === "error") {
+      errors.push(propsResult.error);
+      continue;
+    }
+    const [pageKey, pageValue] = userOptions.normalizer(pageResult.Page);
+
+    try {
+      await access(join(userOptions.projectRoot, pageValue));
+    } catch {
+      errors.push(new Error(`Page file not found: ${pageValue}`));
+    }
+
+    // If propsPath is defined, check if it exists
+    if (propsResult.props) {
+      const [propsKey, propsValue] = userOptions.normalizer(propsResult.props);
+      if (propsValue !== pageValue) {
+        try {
+          await access(join(userOptions.projectRoot, propsValue));
+        } catch {
+          errors.push(
+            new Error(`Props file not found: ${propsValue}`)
+          );
+        }
+      }
+      urlMap.set(page, { props: propsValue, page: pageValue });
+      propsMap.set(propsKey, propsValue);
+      
+      // Add to routeMap for both page and props files
+      const pageRoutes = routeMap.get(pageValue) || [];
+      pageRoutes.push(page);
+      routeMap.set(pageValue, pageRoutes);
+      
+      const propsRoutes = routeMap.get(propsValue) || [];
+      propsRoutes.push(page);
+      routeMap.set(propsValue, propsRoutes);
+    } else {
+      // If no props path, use the page path for both
+      urlMap.set(page, { props: undefined, page: pageValue });
+      
+      // Add to routeMap for page file only
+      const routes = routeMap.get(pageValue) || [];
+      routes.push(page);
+      routeMap.set(pageValue, routes);
+    }
+
+    pageMap.set(pageKey, pageValue);
+  }
+
+  stashedBuildPages = { pageMap, propsMap, urlMap, routeMap, errors };
+  stashedPages = [...pages];
+  return stashedBuildPages;
+}

package/plugin/config/defaults.tsx

@@ -1,38 +1,36 @@
 import { CssCollector } from "../css-collector.js";
 import { Html } from "../html.js";
 export const DEFAULT_CONFIG = {
-  FILE_REGEX: /\.(m|c)?(j|t)sx?$/,
+  MODULE_EXTENSION: /\.(m|c)?(j|t)sx?$/,
   CLIENT_ASSETS_DIR: "assets",
   RSC_DIR: "rsc",
   MODULE_BASE: "src",
   MODULE_BASE_PATH: "",
   MODULE_BASE_URL: "",
-  PAGE: "src/page/page.tsx",
-  PROPS: "src/page/props.ts",
-  CLIENT_ENTRY: "src/client.tsx",
-  SERVER_ENTRY: "src/server.tsx",
+  PAGE: "page.tsx",
+  PROPS: "props.ts",
+  CLIENT_ENTRY: undefined,
+  SERVER_ENTRY: undefined,
   PAGE_EXPORT_NAME: "Page",
   PROPS_EXPORT_NAME: "props",
   HTML_WORKER_PATH: `worker/html/html-worker.${
-    process.env["NODE_ENV"] === "development" ? "development" : "production"
+    process.env["NODE_ENV"] === "production" ? "production" : "development"
   }.js`,
   RSC_WORKER_PATH: `worker/rsc/rsc-worker.${
-    process.env["NODE_ENV"] === "development" ? "development" : "production"
+    process.env["NODE_ENV"] === "production" ? "production" : "development"
   }.js`,
   LOADER_PATH: "worker/loader.js",
   RSC_EXTENSION: ".rsc",
   CSS_COLLECTOR: CssCollector,
   HTML: Html,
-  COLLECT_CSS: true,
-  COLLECT_ASSETS: true,
-  INLINE_CSS: true,
+  ON_METRICS: ()=>{},
   DEV_PORT: 5173,
   PREVIEW_PORT: 4173,
   DEV_HOST: "localhost",
   PREVIEW_HOST: "localhost",
   ENV_PREFIX: "VITE_",
   BUILD: {
-    pages: () => ["/"],
+    pages: ["/"],
     client: "client",
     server: "server",
     static: "static",
@@ -40,31 +38,42 @@ export const DEFAULT_CONFIG = {
     outDir: "dist",
     assetsDir: "assets",
     hash: "hash",
+    rscOutputPath: "index.rsc",
+    htmlOutputPath: "index.html",
     preserveModulesRoot: true,
   },
   CSS: {
+    inlineCss: false,
+    purgeCss: false,
     inlineThreshold: 4096, // 4KB
-    inlinePatterns: [/\.module\.css$/], // Always inline CSS modules
-    linkPatterns: [/node_modules/], // Always link node_modules CSS
+    inlinePatterns: [] as RegExp[], // Always inline CSS modules
+    linkPatterns: [] as RegExp[], // Always link node_modules CSS
   },
   MODULE_BASE_EXCEPTIONS: [] as string[],
   AUTO_DISCOVER: {
-    modulePattern: (n: string) => DEFAULT_CONFIG.FILE_REGEX.test(n),
-    pagePattern: (n: string) =>
-      n.toLowerCase().endsWith("/page") || n.toLowerCase() === "page",
-    propsPattern: (n: string) =>
-      n.toLowerCase().endsWith("/props") || n.toLowerCase() === "props",
-    clientComponents: (n: string) =>
-      n.toLowerCase().endsWith(".client") || n.toLowerCase() === "client",
-    serverFunctions: (n: string) =>
-      n.toLowerCase().endsWith(".server") || n.toLowerCase() === "server",
-    cssPattern: (n: string) => n.toLowerCase().endsWith(".css"),
-    cssModulePattern: (n: string) => n.toLowerCase().endsWith(".css.js"),
+    // All REGEX tricks used here are based on the following:
+    // $ = endsWith
+    // ^ = startsWith
+    // . = includes
+    // \ = escape
+    // ? = optional
+    // () = group
+    // | = or
+    modulePattern: (n: string) => /\.(m|c)?(j|t)sx?$/.test(n),
+    pagePattern: (n: string) => /\.?page(\.js)?$/.test(n),
+    propsPattern: (n: string) => /\.?props(\.js)?$/.test(n),
+    clientComponents: (n: string) => /(\.|\/)?client(\.js)?$/.test(n),
+    serverFunctions: (n: string) => /(\.|\/)?server(\.js)?$/.test(n),
+    cssPattern: (n: string) => /\.css$/.test(n),
+    cssModulePattern: (n: string) => /\.css\.js$/.test(n),
+    virtualPattern: (n: string) => /^\/_virtual\//.test(n),
     vendorPattern: (n: string) =>
-      n.toLowerCase().startsWith("node_modules") ||
-      n.toLowerCase().startsWith("_virtual"),
-    htmlPattern: (n: string) => n.toLowerCase().endsWith(".html"),
-    jsonPattern: (n: string) => n.toLowerCase().endsWith(".json"),
+      /^\/node_modules\//.test(n),
+    htmlPattern: (n: string) => /\.html$/.test(n),
+    jsonPattern: (n: string) => /\.json$/.test(n),
+    nodeOnly: (n: string) => /\.node(\.js)?$/.test(n),
+    dotFiles: (n: string) => n.split('/').some(p => p.startsWith('.')),
+    rscPattern: (n: string) => /\.rsc$/.test(n),  
   },
   MODULE_ID: (id: string) => id,
-} as const;
+} as const;

package/plugin/config/getCondition.ts

@@ -1,3 +1,7 @@
-export const getCondition = (): 'react-client' | 'react-server' => {
-  return process.env['NODE_OPTIONS']?.match(/--condition[= ]react-server/) ? 'react-server' : 'react-client';
-} 
+export const getCondition = <Prefix extends string = "react-">(
+  prefix: Prefix = "react-" as Prefix
+): `${Prefix}client` | `${Prefix}server` => {
+  return process.env["NODE_OPTIONS"]?.match(/--conditions[= ]react-server/)
+    ? (`${prefix}server` as `${Prefix}server`)
+    : (`${prefix}client` as `${Prefix}client`);
+};

package/plugin/config/getPaths.ts

@@ -10,10 +10,4 @@ export const getMode = (): "production" | "development" | "test" => {
     : process.env['NODE_ENV'] === "test" 
       ? "test" 
       : "production";
-}
-
-export const getDistDir = (mode: "production" | "development" | "test"): string => {
-  return mode === 'production' 
-    ? join(process.cwd(), 'dist') 
-    : join(process.cwd(), 'test/fixtures/dist');
-} 
+}

package/plugin/config/index.ts

@@ -1,5 +1,4 @@
 export * from './getCondition.js';
-export * from './getWorkerPath.js';
 export * from './getPaths.js';
 export * from './defaults.js';
 export * from './resolveUserConfig.js';

package/plugin/config/resolveAutoDiscover.ts

@@ -0,0 +1,177 @@
+import type { ConfigEnv, UserConfig } from "vite";
+import type {
+  ResolvedUserOptions,
+  AutoDiscoveredFiles,
+} from "../types.js";
+import { join } from "path";
+import { resolveBuildPages } from "./autoDiscover/resolveBuildPages.js";
+import { resolvePages } from "./resolvePages.js";
+import { tryManifest } from "../helpers/tryManifest.js";
+import type { Manifest } from "vite";
+import { createGlobAutoDiscover } from "./autoDiscover/createGlobAutoDiscover.js";
+import { customWorkerFiles } from "./autoDiscover/customWorkerFiles.js";
+import { pageAndPropFiles } from "./autoDiscover/pageAndPropFiles.js";
+
+let stashedAutoDiscover: Record<string, AutoDiscoveredFiles | null> = {};
+
+const clientFiles = createGlobAutoDiscover("**/*.client.*");
+const serverFiles = createGlobAutoDiscover("**/*.server.*");
+const cssFiles = createGlobAutoDiscover("**/*.css");
+const jsonFiles = createGlobAutoDiscover("**/*.json");
+
+type ResolveAutoDiscoverProps = {
+  config: UserConfig;
+  configEnv: ConfigEnv;
+  userOptions: ResolvedUserOptions;
+  condition: "react-server" | "react-client";
+};
+
+type ResolveAutoDiscoverReturn =
+  | {
+      type: "success";
+      autoDiscoveredFiles: AutoDiscoveredFiles;
+      error?: never;
+    }
+  | {
+      type: "error";
+      error: Error;
+      autoDiscoveredFiles?: never;
+    };
+
+export async function resolveAutoDiscover({
+  config,
+  configEnv,
+  userOptions,
+  condition,
+}: ResolveAutoDiscoverProps): Promise<ResolveAutoDiscoverReturn> {
+  const ssr = configEnv.isSsrBuild;
+  const envDir =
+    condition === "react-server"
+      ? userOptions.build.server
+      : ssr
+      ? userOptions.build.client
+      : userOptions.build.static;
+  const envId = `${envDir}${ssr ? "-ssr" : ""}`;
+  const configInputRecord = {} as Record<string, string>;
+  if (typeof config.build?.rollupOptions?.input === "string") {
+    configInputRecord[
+      userOptions.normalizer(config.build?.rollupOptions?.input)[0]
+    ] = config.build?.rollupOptions?.input;
+  } else if (typeof config.build?.rollupOptions?.input === "object") {
+    for (const [, value] of Object.entries(
+      config.build?.rollupOptions?.input
+    )) {
+      configInputRecord[userOptions.normalizer(value)[0]] = value;
+    }
+  }
+  if (stashedAutoDiscover[envId]) {
+    return {
+      type: "success",
+      autoDiscoveredFiles: stashedAutoDiscover[envId],
+    };
+  }
+
+  const serverEntry =
+    typeof userOptions.serverEntry === "string"
+      ? Object.fromEntries([userOptions.normalizer(userOptions.serverEntry)])
+      : null;
+
+  const indexHtmlInputs = { index: "index.html" };
+
+  const clientEntry =
+    typeof userOptions.clientEntry === "string"
+      ? Object.fromEntries([userOptions.normalizer(userOptions.clientEntry)])
+      : {};
+
+  const { type, error, pages } = await resolvePages(userOptions.build.pages);
+
+  if (type === "error") {
+    return {
+      type: "error",
+      error,
+    };
+  }
+
+  const files = await resolveBuildPages({
+    pages,
+    userOptions,
+  });
+
+  // Load static manifest for client build
+  let staticManifest: Manifest = {};
+  if (ssr) {
+    const staticManifestResult = await tryManifest({
+      root: userOptions.projectRoot,
+      ssrManifest: false,
+      outDir: join(userOptions.build.outDir, userOptions.build.static),
+    });
+    if (staticManifestResult.type === "success") {
+      staticManifest = staticManifestResult.manifest;
+    }
+  }
+
+  const customWorkerInputs = customWorkerFiles({
+    inputs: {},
+    userOptions,
+  });
+  const clientInputs = await clientFiles({
+    inputs: {},
+    userOptions,
+  });
+  const serverInputs = await serverFiles({
+    inputs: {},
+    userOptions,
+  });
+
+  const pageAndPropInputs = pageAndPropFiles({
+    files,
+    inputs: {},
+  });
+
+  const cssInputs = await cssFiles({
+    inputs: {},
+    userOptions,
+  });
+
+  const jsonInputs = await jsonFiles({
+    inputs: {},
+    userOptions,
+  });
+  const agnosticInputs = {
+    ...configInputRecord,
+    ...clientInputs,
+    ...clientEntry,
+    ...serverInputs,
+    ...serverEntry,
+  };
+  // Add inputs based on condition
+  const inputs =
+    condition === "react-client"
+      ? {
+          ...indexHtmlInputs,
+          ...agnosticInputs,
+          ...cssInputs,
+          ...jsonInputs,
+        }
+      : {
+          ...configInputRecord,
+          ...customWorkerInputs,
+          ...pageAndPropInputs,
+          ...agnosticInputs,
+          ...cssInputs,
+          ...jsonInputs,
+        };
+
+  stashedAutoDiscover[envId] = {
+    ...files,
+    workerPaths: customWorkerInputs,
+    serverEntry,
+    clientEntry,
+    staticManifest,
+    inputs,
+  };
+  return {
+    type: "success",
+    autoDiscoveredFiles: stashedAutoDiscover[envId],
+  };
+}