vite-plugin-react-server 0.3.9 → 0.3.11

package/plugin/config/resolveOptions.ts

@@ -1,16 +1,235 @@
+import type { PreRenderedAsset } from "rollup";
+import type { PreRenderedChunk } from "rollup";
 import type { StreamPluginOptions, ResolvedUserOptions } from "../types.js";
 import { DEFAULT_CONFIG } from "./defaults.js";
+import { join } from "path";
+import { createModuleIdGenerator } from "./createModuleIdGenerator.js";
+
+const resolveAutoDiscoverMatcher = (
+  options: undefined | string | RegExp | ((path: string) => boolean),
+  fallback: RegExp | ((path: string) => boolean)
+) => {
+  if (!options) {
+    if (typeof fallback === "function") {
+      return fallback;
+    } else {
+      return (path: string) => fallback.test(path);
+    }
+  }
+  if (typeof options === "string") {
+    const matcher = new RegExp(options);
+    return (path: string) => matcher.test(path);
+  } else if (typeof options === "function") {
+    return options;
+  } else {
+    return (path: string) => options.test(path);
+  }
+};
 
 export const resolveOptions = (
-  options: StreamPluginOptions
+  options: StreamPluginOptions,
+  isClient: boolean = false
 ):
   | { type: "success"; userOptions: ResolvedUserOptions }
   | { type: "error"; error: Error } => {
   const projectRoot = options.projectRoot ?? process.cwd();
+  const { pageExportName = DEFAULT_CONFIG.PAGE_EXPORT, propsExportName = DEFAULT_CONFIG.PROPS_EXPORT } = options;
+  const pages =
+    typeof options.build?.pages === "function"
+      ? options.build.pages
+      : Array.isArray(options.build?.pages)
+      ? options.build.pages
+      : DEFAULT_CONFIG.BUILD.pages;
+  let client = options.build?.client ?? DEFAULT_CONFIG.BUILD.client;
+  let server = options.build?.server ?? DEFAULT_CONFIG.BUILD.server;
+
+  const api = options.build?.api ?? DEFAULT_CONFIG.BUILD.api;
+  const staticBuild = options.build?.static ?? DEFAULT_CONFIG.BUILD.static;
+  const outDir = options.build?.outDir ?? DEFAULT_CONFIG.BUILD.outDir;
+  const assetsDir =
+    options.build?.assetsDir ??
+    `${DEFAULT_CONFIG.CLIENT_ASSETS_DIR}`;
+
+  const ensureModuleBase = (n: string | null) => {
+    if(!n) return '';
+    return n.startsWith(moduleBase + "/") ? n.slice(moduleBase.length + 1) : n;
+  }
+
+  const testModulePattern = resolveAutoDiscoverMatcher(
+    options.autoDiscover?.modulePattern,
+    DEFAULT_CONFIG.AUTO_DISCOVER.modulePattern
+  );
+
+  const testJson = resolveAutoDiscoverMatcher(
+    options.autoDiscover?.jsonPattern,
+    DEFAULT_CONFIG.AUTO_DISCOVER.jsonPattern
+  );
+
+  const testCss = resolveAutoDiscoverMatcher(
+    options.autoDiscover?.cssPattern,
+    DEFAULT_CONFIG.AUTO_DISCOVER.cssPattern
+  );
+  const testHtml = resolveAutoDiscoverMatcher(
+    options.autoDiscover?.htmlPattern,
+    DEFAULT_CONFIG.AUTO_DISCOVER.htmlPattern
+  );
+  const testClientComponents = resolveAutoDiscoverMatcher(
+    options.autoDiscover?.clientComponents,
+    DEFAULT_CONFIG.AUTO_DISCOVER.clientComponents
+  );
+  const testServerFunctions = resolveAutoDiscoverMatcher(
+    options.autoDiscover?.serverFunctions,
+    DEFAULT_CONFIG.AUTO_DISCOVER.serverFunctions
+  );
+  const testPropsPattern = resolveAutoDiscoverMatcher(
+    options.autoDiscover?.propsPattern,
+    DEFAULT_CONFIG.AUTO_DISCOVER.propsPattern
+  );
+  const testPagePattern = resolveAutoDiscoverMatcher(
+    options.autoDiscover?.pagePattern,
+    DEFAULT_CONFIG.AUTO_DISCOVER.pagePattern
+  );
+  const testCssModule = resolveAutoDiscoverMatcher(
+    options.autoDiscover?.cssModulePattern,
+    DEFAULT_CONFIG.AUTO_DISCOVER.cssModulePattern
+  );
+  const testVendor = resolveAutoDiscoverMatcher(
+    options.autoDiscover?.vendorPattern,
+    DEFAULT_CONFIG.AUTO_DISCOVER.vendorPattern
+  );
+  const preserveModulesRoot = options.build?.preserveModulesRoot ?? DEFAULT_CONFIG.BUILD.preserveModulesRoot;
+  const hashOption = typeof options.build?.hash === "string" ? options.build.hash : DEFAULT_CONFIG.BUILD.hash
+  const hashString = hashOption === '' ? '' : `-[${hashOption}]`;
+  const hash = (n: string | null) => {
+    if(!n) return '';
+    if(hashString === '' || (!isClient && !testClientComponents(n))) return n;
+    const extensionIndex = n.lastIndexOf('.') 
+    if(extensionIndex !== -1 && !testClientComponents(n)) {
+      // put hash between extension and filename
+      const extension = n.slice(extensionIndex)
+      const filename = n.slice(0, extensionIndex)
+      return filename + hashString + extension;
+    } else {
+      return n + hashString;
+    }
+  }
+
+  const getOutputPath = (n: string | null) => {
+    if(!n) return '';
+    // Remove src/ prefix if present
+    const path = n.startsWith(moduleBase + "/")
+      ? n.slice(moduleBase.length + 1)
+      : n;
 
-  const build = options.build ?? DEFAULT_CONFIG.BUILD;
+    if (testClientComponents(path)) {
+      return `${assetsDir}/${path}`; 
+    }
+    if (testCss(path)) {
+      return `${path}`; 
+    }
+    if(testHtml(path)) {
+      if(options.autoDiscover?.htmlPattern && typeof options.autoDiscover.htmlPattern !== "function") {
+        // if it's not a function, use it as an option for replace
+        return `${path.replace(options.autoDiscover.htmlPattern, '.js')}`;
+      } else {
+        return `${path.replace('.html', '')}`; 
+      }
+    }
+    if(testJson(path)) {
+      if(options.autoDiscover?.jsonPattern && typeof options.autoDiscover.jsonPattern !== "function") {
+        // if it's not a function, use it as an option for replace
+        return `${path.replace(options.autoDiscover.jsonPattern, '.js')}`;
+      } else {
+        return `${path}`; 
+      }
+    }
+    if (testPropsPattern(path)) {
+      return `${path}`; 
+    }
+    if (testPagePattern(path)) {
+      return `${path}`; 
+    }
+    if (testServerFunctions(path)) {
+      return `${api}/${path}`; // 
+    }
+    if(testCssModule(path)) {
+      if(options.autoDiscover?.cssModulePattern && typeof options.autoDiscover.cssModulePattern !== "function") {
+        // if it's not a function, use it as an option for replace
+        return `${path.replace(options.autoDiscover.cssModulePattern, '.js')}`;
+      } else {
+        return `${path.replace('.css.js', '.js')}`;
+      }
+    }
+    if(testVendor(path)) {
+      return `vendor`;
+    }
+    return `${path}`;
+  };
 
-  const moduleBase = typeof options.moduleBase === "string" ? options.moduleBase : DEFAULT_CONFIG.MODULE_BASE;
+  const entryFile = (n: PreRenderedChunk) => {
+    if(testCss(n.name)) {
+      // this is the css.js chunk for ssr, which (if we keep the .css) would go into client, this prevents that.
+      const result = `${hash(getOutputPath(ensureModuleBase(n.name + '.js')))}`;
+      return result;
+    }
+    const result = `${hash(getOutputPath(ensureModuleBase(n.name)))}.js`;
+    return result;
+  }
+
+  const chunkFile = (n: PreRenderedChunk) => {
+    const result = `${hash(getOutputPath(ensureModuleBase(n.name)))}.js`;
+    return result;
+  }
+
+  const assetFile = (n: PreRenderedAsset) => {
+    const result = `${hash(getOutputPath(ensureModuleBase(n.names[0])))}`;
+    return result;
+  }
+
+  const build =
+    typeof options.build === "object" && options.build !== null
+      ? {
+          pages,
+          client,
+          server,
+          static: staticBuild,
+          outDir,
+          assetsDir,
+          api,
+          hash: hashOption,
+          preserveModulesRoot,
+          entryFile:
+            typeof options.build?.entryFile === "function"
+              ? options.build.entryFile
+              : entryFile,
+          chunkFile:
+            typeof options.build?.chunkFile === "function"
+              ? options.build.chunkFile
+              : chunkFile,
+          assetFile:
+            typeof options.build?.assetFile === "function"
+              ? options.build.assetFile
+              : assetFile,
+        }
+      : {
+          pages,
+          client,
+          server,
+          static: staticBuild,
+          outDir,
+          assetsDir,
+          api,
+          hash: hashOption,
+          preserveModulesRoot,
+          entryFile,
+          chunkFile,
+          assetFile,
+        };
+
+  const moduleBase =
+    typeof options.moduleBase === "string"
+      ? options.moduleBase
+      : DEFAULT_CONFIG.MODULE_BASE;
   const moduleBasePath =
     typeof options.moduleBasePath === "string"
       ? options.moduleBasePath
@@ -21,28 +240,47 @@ export const resolveOptions = (
     typeof options.moduleBaseURL === "string"
       ? options.moduleBaseURL
       : moduleBasePath ?? DEFAULT_CONFIG.MODULE_BASE_URL;
+  
+  const autoDiscover = {
+    modulePattern: testModulePattern,
+    cssPattern: testCss,
+    jsonPattern: testJson,
+    clientComponents: testClientComponents,
+    serverFunctions: testServerFunctions,
+    propsPattern: testPropsPattern,
+    pagePattern: testPagePattern,
+    cssModulePattern: testCssModule,
+    vendorPattern: testVendor,
+  };
+
+  const moduleId = typeof options.moduleId === "function" ? options.moduleId : createModuleIdGenerator({
+    isProduction: process.env['NODE_ENV'] === "production",
+    inputRoot: projectRoot,
+    client: client,
+    server: server,
+    moduleBase: moduleBase,
+    preserveModulesRoot: preserveModulesRoot,
+    removeExtension: DEFAULT_CONFIG.FILE_REGEX,
+    imports: {},
+  });
+
   try {
     return {
       type: "success",
       userOptions: {
         projectRoot,
+        moduleId,
         moduleBase,
         moduleBasePath,
         moduleBaseURL,
-        build: {
-          pages: build.pages ?? DEFAULT_CONFIG.BUILD.pages,
-          client: build.client ?? DEFAULT_CONFIG.BUILD.client,
-          server: build.server ?? DEFAULT_CONFIG.BUILD.server,
-          static: build.static ?? DEFAULT_CONFIG.BUILD.static,
-        },
+        build: build,
         Page: options.Page ?? DEFAULT_CONFIG.PAGE,
         props: options.props ?? DEFAULT_CONFIG.PROPS,
         Html: options.Html ?? DEFAULT_CONFIG.HTML,
-        pageExportName: options.pageExportName ?? DEFAULT_CONFIG.PAGE_EXPORT,
-        propsExportName: options.propsExportName ?? DEFAULT_CONFIG.PROPS_EXPORT,
+        pageExportName: pageExportName,
+        propsExportName: propsExportName,
         collectCss: options.collectCss ?? DEFAULT_CONFIG.COLLECT_CSS,
         collectAssets: options.collectAssets ?? DEFAULT_CONFIG.COLLECT_ASSETS,
-        assetsDir: options.assetsDir ?? DEFAULT_CONFIG.CLIENT_ASSETS_DIR,
         htmlWorkerPath:
           options.htmlWorkerPath ?? DEFAULT_CONFIG.HTML_WORKER_PATH,
         rscWorkerPath: options.rscWorkerPath ?? DEFAULT_CONFIG.RSC_WORKER_PATH,
@@ -50,19 +288,9 @@ export const resolveOptions = (
         clientEntry: options.clientEntry ?? DEFAULT_CONFIG.CLIENT_ENTRY,
         serverEntry: options.serverEntry ?? DEFAULT_CONFIG.SERVER_ENTRY,
         moduleBaseExceptions: options.moduleBaseExceptions ?? [],
-        autoDiscover: {
-          pagePattern:
-            options.autoDiscover?.pagePattern ??
-            DEFAULT_CONFIG.AUTO_DISCOVER.pagePattern,
-          propsPattern:
-            options.autoDiscover?.propsPattern ??
-            DEFAULT_CONFIG.AUTO_DISCOVER.propsPattern,
-          clientComponents:
-            options.autoDiscover?.clientComponents ??
-            DEFAULT_CONFIG.AUTO_DISCOVER.clientComponents,
-          serverFunctions:
-            options.autoDiscover?.serverFunctions ??
-            DEFAULT_CONFIG.AUTO_DISCOVER.serverFunctions,
+        autoDiscover: autoDiscover,
+        pipableStreamOptions: options.pipableStreamOptions ?? {
+          bootstrapModules: [options.clientEntry ?? DEFAULT_CONFIG.CLIENT_ENTRY],
         },
       },
     };

package/plugin/config/resolvePages.ts

@@ -2,7 +2,7 @@ import type { ResolvedUserOptions } from '../types.js';
 
 export async function resolvePages(
   pages: ResolvedUserOptions["build"]["pages"]
-): Promise<{ type: "success"; pages: string[] } | { type: "error"; error: Error }> {
+): Promise<{ type: "success"; error?:never; pages: string[] } | { type: "error"; error: Error; pages?:never }> {
   if (!pages) {
     return { type: "success", pages: [] };
   }

package/plugin/config/resolveUserConfig.ts

@@ -1,96 +1,231 @@
 import type { ConfigEnv, UserConfig } from "vite";
-import type { CheckFilesExistReturn, ResolvedUserConfig, ResolvedUserOptions } from "../types.js";
-import { DEFAULT_CONFIG } from "./defaults.js";
+import type {
+  CheckFilesExistReturn,
+  ResolvedUserConfig,
+  ResolvedUserOptions,
+} from "../types.js";
 import { createInputNormalizer } from "../helpers/inputNormalizer.js";
-
+import { join } from "path";
+// @ts-ignore
+import { globSync } from "fs";
+import type { OutputOptions } from "rollup";
 export type ResolveUserConfigProps = {
-  condition: "react-client" | "react-server" | "";
+  isClient?: boolean;
   config: UserConfig;
   configEnv: ConfigEnv;
   userOptions: ResolvedUserOptions;
   files?: CheckFilesExistReturn;
 };
 
-export type ResolveUserConfigReturn = 
+export type ResolveUserConfigReturn =
   | { type: "success"; userConfig: ResolvedUserConfig }
   | { type: "error"; error: Error };
 
 export function resolveUserConfig({
-  condition,
+  isClient = false,
   config,
   configEnv,
   userOptions,
-  files
+  files,
 }: ResolveUserConfigProps): ResolveUserConfigReturn {
-
-
   try {
     // Get existing inputs
     const root = config.root ?? userOptions.projectRoot ?? process.cwd();
-    const existingInput = config.build?.rollupOptions?.input || {};
-    const currentInputs = typeof existingInput === 'string' ? { default: existingInput } : existingInput;
-    const normalizer = createInputNormalizer(root);
 
-    const serverEntry = userOptions.serverEntry ? [userOptions.serverEntry, userOptions.serverEntry] : [];
-    // Add inputs based on condition
-    const inputs = {
-      ...currentInputs,
-      ...(condition === 'react-server' && files ? {
-        'index.html': '/index.html',
-        ...Object.fromEntries([
-          ...serverEntry,
-          ...Array.from(files.pageMap.entries()),
-          ...Array.from(files.propsMap.entries())
-        ].map(normalizer))
-      } : {
-        client: userOptions.clientEntry
-      })
-    };
+    const normalizer = createInputNormalizer({
+      root,
+      preserveModulesRoot: undefined,
+    });
 
-    const userConfig = {
-      ...config,
-      root: root,
-      mode: configEnv.command === 'build' ? 'production' : 'development',
-      build: {
-        ...config.build,
-        outDir: condition === 'react-server' ? userOptions.build.server : userOptions.build.client,
-        assetsDir: condition === 'react-server' ? "" : DEFAULT_CONFIG.CLIENT_ASSETS_DIR,
-        ssr: condition === 'react-server',
-        target: condition === 'react-server' ? 'node18' : 'es2020',
-        minify: condition === 'react-server' ? false : true,
-        manifest: true,
-        ssrManifest: false,
-        ssrEmitAssets: true,
-        rollupOptions: {
-          ...config.build?.rollupOptions,
-          input: inputs,
-          preserveEntrySignatures: 'strict',
-          output: condition === 'react-server' ? {
-            preserveModules: true,
-            entryFileNames: '[name].js',
-            assetFileNames: '[name].[ext]',
-            chunkFileNames: '[name].[ext]',
-            format: 'esm',
-            exports: 'named',
-            hoistTransitiveImports: false,
-            generatedCode: {
-              constBindings: true,
-              objectShorthand: true
-            },
-            interop: 'auto'
-          } : undefined
+    const serverEntry = userOptions.serverEntry
+      ? Object.fromEntries([
+          normalizer([userOptions.serverEntry, userOptions.serverEntry]),
+        ])
+      : null;
+    const clientEntry = userOptions.clientEntry
+      ? Object.fromEntries(
+          [
+            [userOptions.clientEntry, userOptions.clientEntry],
+            ["index.html", "index.html"],
+          ].map(normalizer)
+        )
+      : { "index.html": "index.html" };
+
+    const autoDiscoveredClientFiles = (inputs: Record<string, string>) => {
+      const allFiles = globSync(`**/*.client.*`, {
+        cwd: join(root, userOptions.moduleBase),
+      });
+      for (const [key, value] of Object.entries(allFiles).map(([n, path]) => {
+        if (typeof path !== "string") {
+          throw new Error(`Invalid path: ${JSON.stringify(path)}`);
+        }
+        const [key, value] = normalizer(join(userOptions.moduleBase, path));
+        return [key, value];
+      })) {
+        // check if not already in the inputs
+        if (!inputs[key]) {
+          inputs[key] = value;
+        }
+      }
+      return inputs;
+    };
+    const autoDiscoveredServerFiles = (inputs: Record<string, string>) => {
+      const allFiles = globSync(`${userOptions.moduleBase}/**/*.server.*`, {
+        cwd: join(root, userOptions.moduleBase),
+      });
+      for (const [key, value] of Object.entries(allFiles).map(normalizer)) {
+        if (!inputs[key]) {
+          inputs[key] = value;
         }
       }
+      return inputs;
+    };
+    const autoDiscoveredFiles = (inputs: Record<string, string>) => {
+      if(!files) {
+        return inputs;
+      }
+      for (const [key, value] of Object.entries( Array.from(files.pageMap.entries())).map(normalizer)) {
+        if (!inputs[key]) {
+          inputs[key] = value;
+        }
+      }
+      for (const [key, value] of Object.entries( Array.from(files.propsMap.entries())).map(normalizer)) {
+        if (!inputs[key]) {
+          inputs[key] = value;
+        }
+      }
+      return inputs;
     };
 
+    // Add inputs based on condition
+    let inputs = isClient
+      ? autoDiscoveredClientFiles(clientEntry)
+      : autoDiscoveredServerFiles(autoDiscoveredFiles(serverEntry ?? {}));
+
+    if (userOptions.build.preserveModulesRoot) {
+      inputs = Object.fromEntries(
+        Object.entries(inputs).map(([key, value]) => {
+          if (key.startsWith(userOptions.moduleBase + "/")) {
+            return [key.slice(userOptions.moduleBase.length + 1), value];
+          }
+          return [key, value];
+        })
+      );
+    }
+
+    const envDir = isClient
+      ? userOptions.build.client
+      : userOptions.build.server;
+    if (isClient) {
+      return {
+        type: "success",
+        userConfig: {
+          ...config,
+          root: root,
+          mode: configEnv.command === "build" ? "production" : "development",
+          resolve: {
+            external: ["react", "react-dom"],
+            alias: {
+              [userOptions.moduleBasePath]: join(root, userOptions.moduleBasePath),
+              [userOptions.moduleBase]: join(root, userOptions.moduleBase),
+              ['index.html']: join(root, 'index.html')
+            }
+          },
+          ssr: {
+            target: "node",
+            external: ["react", "react-dom", "react-server-dom-esm/client.browser"],
+            resolve: {
+              conditions: ["react-server"],
+              externalConditions: ["react-server"],
+            },
+          },
+          build: {
+            ...config.build,
+            emptyOutDir: config.build?.emptyOutDir ?? true,
+            outDir: join(userOptions.build.outDir, envDir),
+            assetsDir: userOptions.build.assetsDir,
+            // modern browsers
+            target: ["esnext"],
+            minify: true,
+            ssr: true,
+            manifest: config.build?.manifest ?? `.vite/manifest.json`,
+            ssrManifest: config.build?.ssrManifest ?? `.vite/ssr-manifest.json`,
+            ssrEmitAssets: true,
+            rollupOptions: {
+              ...config.build?.rollupOptions,
+              input: inputs,
+              output: {
+                ...config.build?.rollupOptions?.output,
+                preserveModulesRoot: userOptions.build.preserveModulesRoot
+                  ? userOptions.moduleBase
+                  : undefined,
+              },
+            },
+          },
+        },
+      };
+    }
+    const mergeOutputArray = (Array.isArray(config.build?.rollupOptions?.output)) 
+    const pluginOutput =  {
+      preserveModules: true,
+      preserveModulesRoot: userOptions.build.preserveModulesRoot
+        ? userOptions.moduleBase
+        : undefined,
+      entryFileNames: userOptions.build.entryFile,
+      assetFileNames: userOptions.build.assetFile,
+      chunkFileNames: userOptions.build.chunkFile,
+      format: "esm",
+      exports: "named",
+      hoistTransitiveImports: false,
+      generatedCode: {
+        constBindings: true,
+        objectShorthand: true,
+      },
+      interop: "auto",
+    } satisfies OutputOptions;
+    const newOutput = Array.isArray(config.build?.rollupOptions?.output) ? 
+      [...config.build?.rollupOptions?.output, pluginOutput]
+      : typeof config.build?.rollupOptions?.output === 'object' && config.build?.rollupOptions?.output !== null ?
+        [config.build?.rollupOptions?.output, pluginOutput]
+        : pluginOutput
     return {
       type: "success",
-      userConfig: userConfig as ResolvedUserConfig
+      userConfig: {
+        ...config,
+        root: root,
+        mode: configEnv.command === "build" ? "production" : "development",
+        resolve: {
+          alias: {
+            [userOptions.moduleBasePath]: join(root, userOptions.moduleBasePath),
+            [userOptions.moduleBase]: join(root, userOptions.moduleBase),
+            ['index.html']: join(root, 'index.html')
+          }
+        },
+        build: {
+          ...config.build,
+          emptyOutDir: config.build?.emptyOutDir ?? true,
+          outDir: join(userOptions.build.outDir, envDir),
+          target: "node18",
+          minify: true,
+          ssr: true,
+          manifest: config.build?.manifest ?? `.vite/manifest.json`,
+          ssrManifest: config.build?.ssrManifest ?? `.vite/ssr-manifest.json`,
+          ssrEmitAssets: true,
+          assetsDir: config.build?.assetsDir ?? userOptions.build.assetsDir,
+          rollupOptions:  {
+            ...config.build?.rollupOptions,
+            input: inputs,
+            preserveEntrySignatures: "strict",
+            output: newOutput,
+          },
+        },
+      },
     };
   } catch (error) {
     return {
       type: "error",
-      error: error instanceof Error ? error : new Error("Failed to resolve config")
+      error:
+        error instanceof Error ? error : new Error("Failed to resolve config"),
     };
   }
-} 
+}

package/plugin/helpers/getBundleManifest.ts

@@ -0,0 +1,75 @@
+import type {
+  NormalizedOutputOptions,
+  OutputBundle,
+  PluginContext,
+} from "rollup";
+import { createInputNormalizer } from "./inputNormalizer.js";
+import { join } from "path";
+
+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: PluginContext,
+  bundle: OutputBundle,
+  preserveModulesRoot: string | undefined
+): Record<string, BundleManifestEntry> {
+
+  const normalizer = createInputNormalizer({
+    root: pluginContext.environment.config.root,
+    removeExtension: false,
+    preserveModulesRoot:
+      typeof preserveModulesRoot === "string" ? preserveModulesRoot : undefined,
+  });
+
+  if (!bundle) {
+    return {};
+  }
+
+  return Object.fromEntries(
+    Object.entries(bundle)
+      .map(([fileName, chunk]) => {
+        if (chunk.type !== "chunk") return null as never;
+
+        // Normalize both the module ID and file path
+        const [moduleId, sourcePath] = normalizer(
+          chunk.facadeModuleId || chunk.moduleIds[0] || fileName
+        );
+        return [
+          moduleId,
+          {
+            file: join( pluginContext.environment.config.build.outDir, fileName),
+            name: moduleId,
+            src: sourcePath.startsWith(pluginContext.environment.config.root) ? sourcePath.slice(pluginContext.environment.config.root.length + 1) : sourcePath,
+            isEntry: chunk.isEntry,
+            ...(Object.keys(chunk.imports).length > 0
+              ? { imports: chunk.imports }
+              : {}),
+            ...(Object.keys(chunk.dynamicImports).length > 0
+              ? { dynamicImports: chunk.dynamicImports }
+              : {}),
+            ...(chunk.viteMetadata?.importedCss
+              ? {
+                  css: Array.from(chunk.viteMetadata.importedCss),
+                }
+              : {}),
+          },
+        ];
+      })
+      .filter(Boolean)
+  );
+}