vite-plugin-react-server 0.3.10 → 0.3.12

package/plugin/helpers/getBundleManifest.ts

@@ -0,0 +1,113 @@
+import type {
+  OutputBundle,
+  PluginContext,
+  OutputChunk,
+} from "rollup";
+import { createInputNormalizer } from "./inputNormalizer.js";
+import { join } from "path";
+import { DEFAULT_CONFIG, resolveOptions } from "../config/index.js";
+
+interface BundleManifestEntry {
+  file: string;
+  name: string;
+  src?: string;
+  isEntry?: boolean;
+  imports?: string[];
+  dynamicImports?: string[];
+  css?: string[];
+}
+
+/**
+ * Get the bundle manifest from the plugin context. Will only work during production build
+ * @param pluginContext - The plugin context
+ * @param bundle - The bundle
+ * @param preserveModulesRoot - The preserve modules root
+ * @returns The bundle manifest
+ */
+export function getBundleManifest({
+  pluginContext,
+  bundle,
+  moduleBase,
+  preserveModulesRoot,
+}: {
+  pluginContext: PluginContext,
+  bundle: OutputBundle,
+  moduleBase?: string,
+  preserveModulesRoot?: boolean,
+}): Record<string, BundleManifestEntry> {
+
+  const normalizer = createInputNormalizer({
+    root: pluginContext.environment.config.root,
+    removeExtension: DEFAULT_CONFIG.FILE_REGEX,
+    preserveModulesRoot: preserveModulesRoot === true ? moduleBase : undefined,
+  });
+
+  if (!bundle) return {};
+
+  // Track virtual modules to prevent duplicates
+  const virtualModules = new Map<string, string>();
+
+  const bundleManifest = Object.fromEntries(
+    Object.entries(bundle)
+      .map(([fileName, chunk]) => {
+        if (chunk.type !== "chunk") return null as never;
+        const chunkWithFacade = chunk as OutputChunk;
+        
+        // Get the module ID, preferring facadeModuleId
+        const moduleId = chunkWithFacade.facadeModuleId || chunkWithFacade.moduleIds[0] || fileName;
+        
+        // Handle commonjs helpers specially - must be done before normalization
+        if (moduleId.includes('commonjsHelpers')) {
+          return [
+            moduleId,
+            {
+              file: 'commonjs-runtime.js',
+              name: 'commonjsHelpers',
+              src: moduleId,
+              isEntry: false
+            }
+          ];
+        }
+        
+        // Normalize both paths, removing the root prefix
+        const [normalizedId, sourcePath] = normalizer(moduleId);
+
+        // For virtual modules, use a consistent naming scheme
+        let finalFileName = fileName;
+        if (moduleId.includes('?')) {
+          const [basePath, query] = moduleId.split('?');
+          const virtualPath = basePath.includes('node_modules') 
+            ? basePath.split('node_modules/')[1] 
+            : basePath;
+          
+          // Create a unique key for this virtual module
+          const virtualKey = `${virtualPath}?${query}`;
+          
+          if (!virtualModules.has(virtualKey)) {
+            // First time seeing this virtual module
+            const virtualFileName = `${virtualPath.replace(/\.js$/, '')}.${query}.js`;
+            virtualModules.set(virtualKey, virtualFileName);
+          }
+          
+          finalFileName = virtualModules.get(virtualKey)!;
+        }
+        const bundleManifestEntry = [
+          sourcePath,
+          {
+            file: finalFileName,
+            name: normalizedId.startsWith('\x00') ? normalizedId.replace('\x00', '') : normalizedId,
+            src: sourcePath.startsWith('/') ? sourcePath.slice(1) : sourcePath,
+            isEntry: chunk.isEntry,
+            ...(chunk.imports?.length > 0 ? { imports: chunk.imports } : {}),
+            ...(chunk.dynamicImports?.length > 0 ? { dynamicImports: chunk.dynamicImports } : {}),
+            ...(chunk.viteMetadata?.importedCss?.size ? {
+              css: Array.from(chunk.viteMetadata.importedCss),
+            } : {}),
+          },
+        ];
+        return bundleManifestEntry;
+      })
+      .filter(Boolean)
+  );
+  return bundleManifest;
+}

package/plugin/helpers/inputNormalizer.ts

@@ -1,37 +1,198 @@
-import { join } from "path";
 import { normalizePath } from "vite";
-import { DEFAULT_CONFIG } from "../config/defaults.js";
 import type { InputNormalizer, NormalizerInput } from "../types.js";
+import { join } from "path";
+import { DEFAULT_CONFIG } from "../config/defaults.js";
 
-export function createInputNormalizer(root: string): InputNormalizer {
+type CreateInputNormalizerProps = {
+  root: string;
+  preserveModulesRoot?: string | undefined;
+  removeExtension?: boolean | RegExp | string | ((path: string) => boolean);
+};
 
-  // Normalize a key by removing file extensions and leading slashes
-  const normalizeKey = (key: string): string => {
-    return key
-      .replace(DEFAULT_CONFIG.FILE_REGEX, "") // Remove TypeScript/JavaScript extensions
-      .replace(/^\/+/, ""); // Remove leading slashes
-  };
+const resolveExtensionOptions = (
+  removeExtension: CreateInputNormalizerProps["removeExtension"]
+) => {
+  if (typeof removeExtension === "boolean") {
+    if (removeExtension) {
+      return (path: string) => {
+        const extensionIndex = path.lastIndexOf(".");
+        return extensionIndex !== -1 ? path.slice(0, extensionIndex) : path;
+      };
+    }
+    return (path: string) => path;
+  }
+  if (typeof removeExtension === "string") {
+    return (path: string) => path.replace(removeExtension, "");
+  }
+  if (removeExtension instanceof RegExp) {
+    return (path: string) =>
+      removeExtension.test(path) ? path.replace(removeExtension, "") : path;
+  }
+  if (typeof removeExtension === "function") {
+    return (path: string) => {
+      const extIndex = path.lastIndexOf(".");
+      if (extIndex !== -1) {
+        const extension = path.slice(extIndex);
+        if (removeExtension(extension)) {
+          return path.slice(0, extIndex);
+        }
+      }
+      return path;
+    };
+  }
+  return (path: string) => path;
+};
 
-  // Main normalize function
-  return (input: NormalizerInput): [string, string] => {
+const resolveRootOption = (
+  root: CreateInputNormalizerProps["root"],
+  preserveModulesRoot: CreateInputNormalizerProps["preserveModulesRoot"]
+) => {
+  if (typeof preserveModulesRoot === "string" && typeof root === "string") {
+    const normalizedPreserveModulesRoot = normalizePath(preserveModulesRoot);
+    if (normalizedPreserveModulesRoot.startsWith(root)) {
+      return normalizedPreserveModulesRoot.slice(root.length + 1);
+    }
+    return "";
+  } else if (typeof preserveModulesRoot === "string" && typeof root !== "string") {
+    return normalizePath(preserveModulesRoot);
+  }
+  return "";
+};
+const createKeyNormalizer =
+  ({
+    root: normalizedRoot,
+    preserveModulesRoot,
+    handleExtension,
+  }: {
+    root: string;
+    preserveModulesRoot: string | undefined;
+    handleExtension: (path: string) => string;
+  }) =>
+  (key: string) => {
+    // Handle virtual modules first
+    const virtualPrefix = key.match(/^\0+/)?.[0] || '';
+    const actualKey = key.slice(virtualPrefix.length);
     
-    // Handle tuple input [key, path]
-    if (Array.isArray(input)) {
-      const [key, path] = input;
-      const normalized: [string, string] = [
-        normalizeKey(key),
-        normalizePath(join(root, path))
-      ] 
-      return normalized;
+    let moduleId = normalizePath(actualKey);
+    
+    if (moduleId.startsWith(normalizedRoot)) {
+      moduleId = moduleId.slice(normalizedRoot.length);
+    }
+
+    moduleId = handleExtension(moduleId);
+    while (moduleId.startsWith("/") || moduleId.startsWith(".")) {
+      moduleId = moduleId.slice(1);
+    }
+    while (moduleId.endsWith("/")) {
+      moduleId = moduleId.slice(0, -1);
+    }
+    if (typeof preserveModulesRoot === "string" && preserveModulesRoot !== "") {
+      moduleId = moduleId.startsWith(preserveModulesRoot)
+        ? moduleId.slice(preserveModulesRoot.length)
+        : moduleId;
     }
+    
+    // Add virtual prefix back
+    return virtualPrefix + moduleId;
+  };
 
-    // Handle string input
-    if (typeof input === "string") {
-      const key = normalizeKey(input);
-      const path = normalizePath(join(root, input));  
-      return [key, path];
+const createPathNormalizer =
+  ({
+    root,
+    preserveModulesRoot,
+  }: {
+    root: string;
+    preserveModulesRoot: string | undefined;
+  }) =>
+  (path: string) => {
+    if (typeof path !== "string") {
+      throw new Error(`Invalid path: ${JSON.stringify(path)}`);
+    }
+    let normalPath = normalizePath(path);
+    if(normalPath.startsWith(root)) {
+      normalPath = normalPath.slice(root.length);
+    }
+    if (typeof preserveModulesRoot === "string" && preserveModulesRoot !== "") {
+      normalPath = normalPath.startsWith(preserveModulesRoot)
+        ? normalPath.slice(preserveModulesRoot.length)
+        : normalPath;
     }
+    while (normalPath.endsWith("/")) {
+      normalPath = normalPath.slice(0, -1);
+    }
+    return normalPath;
+  };
+/**
+ * @description Create a function that normalizes the input
+ * @param root - The root of the project
+ * @param preserveModulesRoot - The root of the preserve modules
+ * @param removeExtension - Whether to remove the extension of the file
+ * @returns A function that normalizes the input
+ */
+export function createInputNormalizer({
+  root,
+  preserveModulesRoot = undefined,
+  removeExtension = DEFAULT_CONFIG.FILE_REGEX,
+}: CreateInputNormalizerProps): InputNormalizer {
+  const relativeRoot = resolveRootOption(root, preserveModulesRoot);
+  const handleExtension = resolveExtensionOptions(removeExtension);
 
-    throw new Error(`Invalid input type: ${typeof input}`);
+  const normalizeEntryKey = createKeyNormalizer({
+    root: root,
+    preserveModulesRoot: relativeRoot,
+    handleExtension,
+  });
+
+  const normalizeEntryPath = createPathNormalizer({
+    root: root,
+    preserveModulesRoot: relativeRoot,
+  });
+  function normalizeInput(id: NormalizerInput): [string, string] {
+    // Normalize both paths to use POSIX separators
+    if (Array.isArray(id)) {
+      const [key, path] = id;
+      if (typeof key === "string" && Array.isArray(path) && path.length === 2) {
+        const isNumber = !isNaN(Number(key));
+        if (isNumber) {
+          // ignore it
+          return normalizeInput([path[0], path[1]]);
+        }
+        return normalizeInput([join(key, path[0]), path[1]]);
+      }
+      if (typeof key !== "string" || typeof path !== "string") {
+        throw new Error(`Invalid input: ${JSON.stringify(id)}`);
+      }
+      return [normalizeEntryKey(key), normalizeEntryPath(path)];
+    } else if (typeof id === "string") {
+      // Return both the normalized ID and original normalized path
+      return [normalizeEntryKey(id), normalizeEntryPath(id)];
+    } else if (
+      typeof id === "object" &&
+      id !== null &&
+      "$$typeof" in id &&
+      "$$id" in id &&
+      typeof id.$$id === "string"
+    ) {
+      const normalized: [string, string] = [
+        normalizeEntryKey(id.$$id),
+        normalizeEntryPath(id.$$id),
+      ];
+      return normalized;
+    }
+    throw new Error(`Invalid input type: ${typeof id}`);
+  };
+
+  return (input: NormalizerInput): [string, string] => {
+    const [key, path] = normalizeInput(input);
+    // Apply the same normalization to both key and path
+    const normalizedPath = path.startsWith('/') ? path.slice(1) : path;
+    const virtualPrefix = key.match(/^\0+/)?.[0] || '';
+    
+    // If key has virtual prefix, ensure path has it too
+    const finalPath = virtualPrefix ? 
+      (normalizedPath.startsWith(virtualPrefix) ? normalizedPath : virtualPrefix + normalizedPath) : 
+      normalizedPath;
+    
+    return [key, finalPath];
   };
 }

package/plugin/helpers/tryManifest.ts

@@ -5,15 +5,17 @@ import type { Manifest } from "vite";
 type TryManifestOptions<SSR extends boolean> = {
   root: string;
   outDir: string;
-  ssrManifest: SSR;
+  ssrManifest?: SSR;
 };
 
 export function tryManifest<SSR extends boolean>(options: TryManifestOptions<SSR>): {
   type: "success";
   manifest: SSR extends true ? Record<string, string[]> : Manifest;
+  error?:never
 } | {
   type: "error";
   error: Error;
+  manifest?:never
 } {
   const manifestPath = resolve(
     options.root,

package/plugin/loader/createBuildLoader.ts

@@ -1,23 +1,64 @@
-import { join } from "path";
+import { join, relative, resolve } from "node:path";
 import type { PluginContext } from "rollup";
-import type { ResolvedUserConfig } from "../../server.js";
-import { DEFAULT_CONFIG } from "../config/defaults.js";
+import type { ResolvedUserConfig, ResolvedUserOptions } from "../../server.js";
+import type { Manifest } from "vite";
+import { createInputNormalizer } from "../helpers/inputNormalizer.js";
 
 export interface BuildLoaderOptions {
   root: string;
   pluginContext: PluginContext;
   userConfig: ResolvedUserConfig;
+  userOptions: ResolvedUserOptions;
+  serverManifest: Manifest;
+  clientManifest: Manifest;
 }
 
 export function createBuildLoader({
   root,
   userConfig,
+  userOptions,
+  pluginContext,
+  serverManifest,
+  clientManifest,
 }: BuildLoaderOptions) {
-  return async (id: string) => {
-    return import(join(
-      root,
-      userConfig.build.outDir,
-      id.replace(DEFAULT_CONFIG.FILE_REGEX, "") + ".js"
-    ));
+  const normalizer = createInputNormalizer({
+    root,
+    preserveModulesRoot: undefined,
+    removeExtension: false,
+  });
+  return async function buildLoader(id: string) {
+    const [key, value] = normalizer(id);
+    // Remove leading slash if present
+    const distDir = userOptions.build.outDir;
+    const manifests = [clientManifest, serverManifest];
+    // Try to find the module in the manifest
+    for (const n of [0, 1]) {
+      const manifest = manifests[n];
+      const manifestEntry = manifest[key]
+      if (!manifestEntry) {
+        continue;
+      }
+      const isClient = userOptions.autoDiscover.clientComponents(id);
+      const isServer = userOptions.autoDiscover.serverFunctions(id);
+      const outDir = isClient
+        ? userOptions.build.client
+        : isServer
+        ? userOptions.build.server
+        : n === 0
+        ? userOptions.build.client
+        : userOptions.build.server;
+      if (manifestEntry.file.startsWith(`${root}/${distDir}/${outDir}/`)) {
+        return import(manifestEntry.file);
+      }
+      if (manifestEntry.file.startsWith(`${distDir}/`)) {
+        return import(join(root, manifestEntry.file));
+      }
+      if (manifestEntry.file.startsWith(`${outDir}/`)) {
+        return import(join(root, distDir, outDir, manifestEntry.file));
+      }
+      // Load the module
+      return import(join(root, distDir, outDir, manifestEntry.file));
+    }
+    throw new Error(`Module not found: ${id}`);
   };
 }

package/plugin/loader/createPageLoader.ts

@@ -76,13 +76,7 @@ export function createPageLoader({
   registerClient,
 }: CreatePageLoaderOptions) {
   return async function loader(id: string) {
-    console.log("[pageLoader] Loading:", {
-      id,
-      manifest: Object.keys(manifest),
-      outDir,
-      moduleBase
-    });
-    console.log("[pageLoader] Manifest:", manifest);
+
     // Try to find the entry directly or by source file
     const manifestEntry = manifest[id] || 
                          Object.values(manifest).find(entry => entry.src === id);

package/plugin/loader/css-loader.ts

@@ -0,0 +1,96 @@
+import { readFile } from 'fs/promises';
+import { basename } from 'path';
+import postcss from 'postcss';
+import type { MessagePort } from 'node:worker_threads';
+import type { CssFileMessage } from '../worker/types.js';
+import type { LoadHookContext } from 'node:module';
+
+type LoaderContext = {
+  data?: { port: MessagePort };
+};
+// Store port globally for CSS loader
+let cssLoaderPort: MessagePort | undefined;
+
+// Initialize hook
+export async function initialize(data: { port: MessagePort }) {
+  cssLoaderPort = data.port;  // Store port
+  data.port.postMessage({ type: 'INITIALIZED' });
+  data.port.unref();
+}
+
+// CSS file tracking per page
+const cssFilesByPage = new Map<string, Set<string>>();
+let currentPage: string | null = null;
+
+export function setCurrentPage(page: string | null) {
+  currentPage = page;
+  if (page && !cssFilesByPage.has(page)) {
+    cssFilesByPage.set(page, new Set());
+  }
+}
+
+export function getCssFilesForPage(page: string): string[] {
+  return Array.from(cssFilesByPage.get(page) || []);
+}
+
+// Modify the CSS handling in the load function
+export async function load(url: string, context: LoadHookContext & LoaderContext, defaultLoad: any) {
+  // Handle CSS files
+  if(url.endsWith(".css")) {
+    const source = await readFile(new URL(url), 'utf-8');
+    
+    // Process CSS with PostCSS
+    const result = await postcss().process(source, {
+      from: url,
+      to: url,
+      map: {
+        inline: false,
+        annotation: false
+      }
+    });
+
+    // Generate both transformed CSS and class mappings
+    const moduleName = basename(url, '.css').replace('.', '_');
+    const classes: Record<string, string> = {};
+
+    // Transform selectors
+    result.root.walkRules(rule => {
+      const selector = rule.selector.replace('.', '');
+      const className = `${moduleName}_${selector}`;
+      classes[selector] = className;
+      rule.selector = `.${className}`;
+    });
+
+    // Get transformed CSS using root.toString()
+    const transformedCss = result.root.toString();
+
+    // Send processed CSS to worker
+    if (cssLoaderPort) {
+      cssLoaderPort.postMessage({
+        type: 'CSS_FILE',
+        id: url,
+        cssFile: transformedCss
+      } satisfies CssFileMessage);
+    }
+    
+    // Return CSS module
+    const moduleSource = `
+      const styles = ${JSON.stringify(classes)};
+      export default styles;
+      export const css = ${JSON.stringify(transformedCss)};
+    `;
+
+    return {
+      format: 'module',
+      source: moduleSource,
+      shortCircuit: true
+    };
+  }
+  return defaultLoad(url, context, defaultLoad);
+}
+
+export function resolve(specifier: string, context: any, defaultResolve: any) {
+  return defaultResolve(specifier, context, defaultResolve);
+}
+
+