feat: use module runner to import the config

packages/vite/index.cjs

@@ -21,6 +21,7 @@ const asyncFunctions = [
   'loadConfigFromFile',
   'preprocessCSS',
   'createBuilder',
+  'inlineImport',
 ]
 asyncFunctions.forEach((name) => {
   module.exports[name] = (...args) =>

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

@@ -12,7 +12,7 @@ import {
 import type { ModuleEvaluator, ModuleRunnerContext } from './types'
 
 export class ESModulesEvaluator implements ModuleEvaluator {
-  startOffset = getAsyncFunctionDeclarationPaddingLineCount()
+  public readonly startOffset = getAsyncFunctionDeclarationPaddingLineCount()
 
   async runInlinedModule(
     context: ModuleRunnerContext,

packages/vite/src/node/__tests__/fixtures/inline-import/basic.ts

@@ -0,0 +1,7 @@
+interface Test {
+  field: true
+}
+
+export const test: Test = {
+  field: true,
+}

packages/vite/src/node/__tests__/fixtures/inline-import/cjs.js

@@ -0,0 +1 @@
+module.exports = {}

packages/vite/src/node/__tests__/fixtures/inline-import/plugin.ts

@@ -0,0 +1,7 @@
+import { Plugin } from 'vite'
+
+export default function testPlugin(): Plugin {
+  return {
+    name: 'test',
+  }
+}

packages/vite/src/node/__tests__/fixtures/inline-import/vite.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from 'vite'
+import plugin from './plugin'
+
+export default defineConfig({
+  root: './test',
+  plugins: [plugin()],
+})

packages/vite/src/node/__tests__/inlineImport.spec.ts

@@ -0,0 +1,41 @@
+import { resolve } from 'node:path'
+import { describe, expect, test } from 'vitest'
+import { inlineImport } from '../ssr/inlineImport'
+import { slash } from '../../shared/utils'
+
+describe('importing files using inlined environment', () => {
+  const fixture = (name: string) =>
+    resolve(import.meta.dirname, './fixtures/inline-import', name)
+
+  test('importing a basic file works', async () => {
+    const { module } = await inlineImport<
+      typeof import('./fixtures/inline-import/basic')
+    >(fixture('basic'))
+    expect(module.test).toEqual({
+      field: true,
+    })
+  })
+
+  test("cannot import cjs, 'inlineImport' doesn't support CJS syntax at all", async () => {
+    await expect(() =>
+      inlineImport<typeof import('./fixtures/inline-import/basic')>(
+        fixture('cjs.js'),
+      ),
+    ).rejects.toThrow('module is not defined')
+  })
+
+  test('can import vite config', async () => {
+    const { module, dependencies } = await inlineImport<
+      typeof import('./fixtures/inline-import/vite.config')
+    >(fixture('vite.config'))
+    expect(module.default).toEqual({
+      root: './test',
+      plugins: [
+        {
+          name: 'test',
+        },
+      ],
+    })
+    expect(dependencies).toEqual([slash(fixture('plugin.ts'))])
+  })
+})

packages/vite/src/node/cli.ts

@@ -23,6 +23,7 @@ interface GlobalCLIOptions {
   l?: LogLevel
   logLevel?: LogLevel
   clearScreen?: boolean
+  configLoader?: string
   d?: boolean | string
   debug?: boolean | string
   f?: string
@@ -87,6 +88,7 @@ function cleanGlobalCLIOptions<Options extends GlobalCLIOptions>(
   delete ret.l
   delete ret.logLevel
   delete ret.clearScreen
+  delete ret.configLoader
   delete ret.d
   delete ret.debug
   delete ret.f
@@ -151,6 +153,10 @@ cli
   })
   .option('-l, --logLevel <level>', `[string] info | warn | error | silent`)
   .option('--clearScreen', `[boolean] allow/disable clear screen when logging`)
+  .option(
+    '--bundleConfig',
+    `[boolean] should the config be bundled or evaluated with a module runner when importing`,
+  )
   .option('-d, --debug [feat]', `[string | boolean] show debug logs`)
   .option('-f, --filter <filter>', `[string] filter debug logs`)
   .option('-m, --mode <mode>', `[string] set env mode`)
@@ -180,6 +186,7 @@ cli
         base: options.base,
         mode: options.mode,
         configFile: options.config,
+        configLoader: options.configLoader as undefined,
         logLevel: options.logLevel,
         clearScreen: options.clearScreen,
         optimizeDeps: { force: options.force },
@@ -304,6 +311,7 @@ cli
           base: options.base,
           mode: options.mode,
           configFile: options.config,
+          configLoader: options.configLoader as undefined,
           logLevel: options.logLevel,
           clearScreen: options.clearScreen,
           build: buildOptions,
@@ -340,6 +348,7 @@ cli
             root,
             base: options.base,
             configFile: options.config,
+            configLoader: options.configLoader as undefined,
             logLevel: options.logLevel,
             mode: options.mode,
           },
@@ -382,6 +391,7 @@ cli
           root,
           base: options.base,
           configFile: options.config,
+          configLoader: options.configLoader as undefined,
           logLevel: options.logLevel,
           mode: options.mode,
           build: {

packages/vite/src/node/config.ts

@@ -1,15 +1,15 @@
 import fs from 'node:fs'
-import fsp from 'node:fs/promises'
 import path from 'node:path'
+import fsp from 'node:fs/promises'
 import { pathToFileURL } from 'node:url'
 import { promisify } from 'node:util'
 import { performance } from 'node:perf_hooks'
 import { builtinModules, createRequire } from 'node:module'
 import colors from 'picocolors'
 import type { Alias, AliasOptions } from 'dep-types/alias'
-import { build } from 'esbuild'
 import type { RollupOptions } from 'rollup'
 import picomatch from 'picomatch'
+import { build } from 'esbuild'
 import type { AnymatchFn } from '../types/anymatch'
 import { withTrailingSlash } from '../shared/utils'
 import {
@@ -81,12 +81,12 @@ import {
   resolvePlugins,
 } from './plugins'
 import type { ESBuildOptions } from './plugins/esbuild'
-import type {
-  EnvironmentResolveOptions,
-  InternalResolveOptions,
-  ResolveOptions,
+import {
+  type EnvironmentResolveOptions,
+  type InternalResolveOptions,
+  type ResolveOptions,
+  tryNodeResolve,
 } from './plugins/resolve'
-import { tryNodeResolve } from './plugins/resolve'
 import type { LogLevel, Logger } from './logger'
 import { createLogger } from './logger'
 import type { DepOptimizationOptions } from './optimizer'
@@ -98,6 +98,7 @@ import type { ResolvedSSROptions, SSROptions } from './ssr'
 import { resolveSSROptions, ssrConfigDefaults } from './ssr'
 import { PartialEnvironment } from './baseEnvironment'
 import { createIdResolver } from './idResolver'
+import { inlineImport } from './ssr/inlineImport'
 
 const debug = createDebugger('vite:config', { depth: 10 })
 const promisifiedRealpath = promisify(fs.realpath)
@@ -530,6 +531,7 @@ export interface ResolvedWorkerOptions {
 
 export interface InlineConfig extends UserConfig {
   configFile?: string | false
+  configLoader?: 'bundle' | 'runner'
   envFile?: false
 }
 
@@ -996,6 +998,7 @@ export async function resolveConfig(
       config.root,
       config.logLevel,
       config.customLogger,
+      config.configLoader,
     )
     if (loadResult) {
       config = mergeConfig(loadResult.config, config)
@@ -1635,6 +1638,7 @@ export async function loadConfigFromFile(
   configRoot: string = process.cwd(),
   logLevel?: LogLevel,
   customLogger?: Logger,
+  configLoader = 'bundle',
 ): Promise<{
   path: string
   config: UserConfig
@@ -1665,28 +1669,29 @@ export async function loadConfigFromFile(
     return null
   }
 
-  const isESM =
-    typeof process.versions.deno === 'string' || isFilePathESM(resolvedPath)
-
-  try {
-    const bundled = await bundleConfigFile(resolvedPath, isESM)
-    const userConfig = await loadConfigFromBundledFile(
-      resolvedPath,
-      bundled.code,
-      isESM,
+  if (configLoader !== 'bundle' && configLoader !== 'runner') {
+    throw new Error(
+      `Unsupported configLoader: ${configLoader}. Accepted values are 'bundle' and 'runner'.`,
     )
-    debug?.(`bundled config file loaded in ${getTime()}`)
+  }
 
-    const config = await (typeof userConfig === 'function'
-      ? userConfig(configEnv)
-      : userConfig)
+  try {
+    const resolver =
+      configLoader === 'bundle' ? bundleAndLoadConfigFile : importConfigFile
+    const { configExport, dependencies } = await resolver(resolvedPath)
+    debug?.(`config file loaded in ${getTime()}`)
+
+    const config = await (typeof configExport === 'function'
+      ? configExport(configEnv)
+      : configExport)
     if (!isObject(config)) {
       throw new Error(`config must export or return an object.`)
     }
+
     return {
       path: normalizePath(resolvedPath),
       config,
-      dependencies: bundled.dependencies,
+      dependencies,
     }
   } catch (e) {
     createLogger(logLevel, { customLogger }).error(
@@ -1699,6 +1704,33 @@ export async function loadConfigFromFile(
   }
 }
 
+async function importConfigFile(resolvedPath: string) {
+  const { module, dependencies } = await inlineImport<{
+    default: UserConfigExport
+  }>(resolvedPath, { configFile: false })
+  return {
+    configExport: module.default,
+    dependencies,
+  }
+}
+
+async function bundleAndLoadConfigFile(resolvedPath: string) {
+  const isESM =
+    typeof process.versions.deno === 'string' || isFilePathESM(resolvedPath)
+
+  const bundled = await bundleConfigFile(resolvedPath, isESM)
+  const userConfig = await loadConfigFromBundledFile(
+    resolvedPath,
+    bundled.code,
+    isESM,
+  )
+
+  return {
+    configExport: userConfig,
+    dependencies: bundled.dependencies,
+  }
+}
+
 async function bundleConfigFile(
   fileName: string,
   isESM: boolean,

packages/vite/src/node/index.ts

@@ -31,6 +31,7 @@ export {
   DevEnvironment,
   type DevEnvironmentContext,
 } from './server/environment'
+export { inlineImport } from './ssr/inlineImport'
 export { BuildEnvironment } from './build'
 
 export { fetchModule, type FetchModuleOptions } from './ssr/fetchModule'

packages/vite/src/node/server/environments/runnableEnvironment.ts

@@ -11,7 +11,7 @@ export function createRunnableDevEnvironment(
   name: string,
   config: ResolvedConfig,
   context: RunnableDevEnvironmentContext = {},
-): DevEnvironment {
+): RunnableDevEnvironment {
   if (context.transport == null) {
     context.transport = createServerHotChannel()
   }

packages/vite/src/node/ssr/inlineImport.ts

@@ -0,0 +1,70 @@
+import type { InlineConfig } from '../config'
+import { resolveConfig } from '../config'
+import { createRunnableDevEnvironment } from '../server/environments/runnableEnvironment'
+import { mergeConfig } from '../utils'
+
+interface InlineImportResult<T> {
+  module: T
+  dependencies: string[]
+}
+
+/**
+ * Import any file using the default Vite environment.
+ * @experimental
+ */
+export async function inlineImport<T>(
+  moduleId: string,
+  inlineConfig?: InlineConfig,
+): Promise<InlineImportResult<T>> {
+  const environment = createRunnableDevEnvironment(
+    'inline',
+    // TODO: provide a dummy config?
+    await resolveConfig(
+      mergeConfig(inlineConfig || {}, {
+        environments: {
+          inline: {
+            consumer: 'server',
+            dev: {
+              moduleRunnerTransform: true,
+            },
+            resolve: {
+              external: true,
+            },
+          },
+        },
+      }),
+      'serve',
+    ),
+    {
+      runnerOptions: {
+        hmr: {
+          logger: false,
+        },
+      },
+      hot: false,
+    },
+  )
+  await environment.init()
+  try {
+    const module = await environment.runner.import(moduleId)
+    const modules = [
+      ...environment.runner.evaluatedModules.urlToIdModuleMap.values(),
+    ]
+    const dependencies = modules
+      .filter((m) => {
+        // ignore all externalized modules
+        if (!m.meta || 'externalize' in m.meta) {
+          return false
+        }
+        // ignore the current module
+        return m.exports !== module
+      })
+      .map((m) => m.file)
+    return {
+      module,
+      dependencies,
+    }
+  } finally {
+    await environment.close()
+  }
+}

vitest.config.ts

@@ -13,6 +13,9 @@ export default defineConfig({
       './playground/**/*.*',
       './playground-temp/**/*.*',
     ],
+    deps: {
+      moduleDirectories: ['node_modules', 'packages'],
+    },
     testTimeout: 20000,
     isolate: false,
   },