fix: support cjs globals in default modules evaluator

packages/vite/src/module-runner/esmEvaluator.ts

@@ -11,8 +11,18 @@ import {
 } from './constants'
 import type { ModuleEvaluator, ModuleRunnerContext } from './types'
 
+export interface ESModulesEvaluatorOptions {
+  cjsGlobals?: boolean
+  startOffset?: number
+}
+
 export class ESModulesEvaluator implements ModuleEvaluator {
-  startOffset = getAsyncFunctionDeclarationPaddingLineCount()
+  public readonly startOffset: number
+
+  constructor(private options: ESModulesEvaluatorOptions = {}) {
+    this.startOffset =
+      options.startOffset ?? getAsyncFunctionDeclarationPaddingLineCount()
+  }
 
   async runInlinedModule(
     context: ModuleRunnerContext,
@@ -25,16 +35,22 @@ export class ESModulesEvaluator implements ModuleEvaluator {
       ssrImportKey,
       ssrDynamicImportKey,
       ssrExportAllKey,
+      '__filename',
+      '__dirname',
       // source map should already be inlined by Vite
       '"use strict";' + code,
     )
 
+    const meta = context[ssrImportMetaKey]
+
     await initModule(
       context[ssrModuleExportsKey],
       context[ssrImportMetaKey],
       context[ssrImportKey],
       context[ssrDynamicImportKey],
       context[ssrExportAllKey],
+      this.options.cjsGlobals ? meta.filename : undefined,
+      this.options.cjsGlobals ? meta.dirname : undefined,
     )
 
     Object.seal(context[ssrModuleExportsKey])

packages/vite/src/module-runner/index.ts

@@ -2,7 +2,10 @@
 
 export { EvaluatedModules, type EvaluatedModuleNode } from './evaluatedModules'
 export { ModuleRunner } from './runner'
-export { ESModulesEvaluator } from './esmEvaluator'
+export {
+  ESModulesEvaluator,
+  type ESModulesEvaluatorOptions,
+} from './esmEvaluator'
 
 export { createWebSocketModuleRunnerTransport } from '../shared/moduleRunnerTransport'
 

packages/vite/src/node/config.ts

@@ -6,6 +6,7 @@ import colors from 'picocolors'
 import type { Alias, AliasOptions } from 'dep-types/alias'
 import type { RollupOptions } from 'rollup'
 import picomatch from 'picomatch'
+import { ESModulesEvaluator } from 'vite/module-runner'
 import type { AnymatchFn } from '../types/anymatch'
 import { withTrailingSlash } from '../shared/utils'
 import {
@@ -43,7 +44,6 @@ import {
 import type { ResolvedServerOptions, ServerOptions } from './server'
 import { resolveServerOptions, serverConfigDefaults } from './server'
 import { DevEnvironment } from './server/environment'
-import type { RunnableDevEnvironment } from './server/environments/runnableEnvironment'
 import { createRunnableDevEnvironment } from './server/environments/runnableEnvironment'
 import type { WebSocketServer } from './server/ws'
 import type { PreviewOptions, ResolvedPreviewOptions } from './preview'
@@ -1658,87 +1658,100 @@ export async function loadConfigFromFile(
     return null
   }
 
-  let environment: RunnableDevEnvironment | undefined
-
   try {
-    environment = createRunnableDevEnvironment(
-      'config',
-      await resolveConfig(
-        {
-          configFile: false,
-          environments: {
-            config: {
-              consumer: 'server',
-              dev: {
-                moduleRunnerTransform: true,
-              },
-              resolve: {
-                external: true,
-              },
+    const { userConfig, dependencies } = await importConfig(resolvedPath)
+    debug?.(`config file loaded in ${getTime()}`)
+
+    const config = await (typeof userConfig === 'function'
+      ? userConfig(configEnv)
+      : userConfig)
+    if (!isObject(config)) {
+      throw new Error(`config must export or return an object.`)
+    }
+    return {
+      path: normalizePath(resolvedPath),
+      config,
+      dependencies,
+    }
+  } catch (e) {
+    createLogger(logLevel, { customLogger }).error(
+      colors.red(`failed to load config from ${resolvedPath}`),
+      {
+        error: e,
+      },
+    )
+    throw e
+  }
+}
+
+async function importConfig(resolvedPath: string) {
+  const environment = createRunnableDevEnvironment(
+    'config',
+    // TODO: provide a dummy config?
+    await resolveConfig(
+      {
+        configFile: false,
+        environments: {
+          config: {
+            consumer: 'server',
+            dev: {
+              moduleRunnerTransform: true,
+            },
+            resolve: {
+              external: true,
             },
           },
         },
-        'serve',
-      ),
-      {
-        // options: {
-        //   consumer: 'server',
-        //   dev: {
-        //     moduleRunnerTransform: true,
-        //   },
-        // TODO for some reason this doesn't work, only setting it the config works
-        // resolve: {
-        //   external: true,
-        // },
-        // },
-        runnerOptions: {
-          hmr: {
-            logger: false,
-          },
+      },
+      'serve',
+    ),
+    {
+      // options: {
+      //   consumer: 'server',
+      //   dev: {
+      //     moduleRunnerTransform: true,
+      //   },
+      // TODO for some reason this doesn't work, only setting it the config works
+      // resolve: {
+      //   external: true,
+      // },
+      // },
+      runnerOptions: {
+        hmr: {
+          logger: false,
         },
-        hot: false,
+        evaluator: new ESModulesEvaluator({
+          cjsGlobals: true,
+        }),
       },
-    )
-    await environment.init()
+      hot: false,
+    },
+  )
+  await environment.init()
+  try {
     const { default: userConfig } = (await environment.runner.import(
       resolvedPath,
     )) as {
       default: UserConfigExport
     }
-    debug?.(`config file loaded in ${getTime()}`)
-
-    const config = await (typeof userConfig === 'function'
-      ? userConfig(configEnv)
-      : userConfig)
-    if (!isObject(config)) {
-      throw new Error(`config must export or return an object.`)
-    }
     const modules = [
       ...environment.runner.evaluatedModules.fileToModulesMap.entries(),
     ]
-    await environment.runner.close()
     const dependencies = modules
       .filter(([file, modules]) => {
-        const isExternal = [...modules].some(
+        const isExternal = [...modules].every(
           (m) => !m.meta || 'externalize' in m.meta,
         )
         return !isExternal && file !== resolvedPath
       })
       .map(([file]) => file)
     return {
-      path: normalizePath(resolvedPath),
-      config,
+      userConfig,
       dependencies,
     }
-  } catch (e) {
-    await environment?.runner.close()
-    createLogger(logLevel, { customLogger }).error(
-      colors.red(`failed to load config from ${resolvedPath}`),
-      {
-        error: e,
-      },
-    )
-    throw e
+  } catch (err) {
+    await environment.close()
+    throw err
   }
 }