refactor: runtime deprecate optimizeDeps.rollupOptions

packages/vite/src/node/build.ts

@@ -448,7 +448,7 @@ export function resolveBuildEnvironmentOptions(
     } satisfies BuildEnvironmentOptions,
     raw,
   )
-  setupRollupOptionCompat(merged)
+  setupRollupOptionCompat(merged, 'build')
   merged.rolldownOptions = {
     platform: consumer === 'server' ? 'node' : 'browser',
     ...merged.rolldownOptions,

packages/vite/src/node/config.ts

@@ -798,7 +798,7 @@ const configDefaults = Object.freeze({
     exclude: [],
     needsInterop: [],
     // esbuildOptions
-    rollupOptions: {},
+    rolldownOptions: {},
     /** @experimental */
     extensions: [],
     /** @deprecated @experimental */
@@ -1094,6 +1094,12 @@ function resolveDepOptimizationOptions(
   consumer: 'client' | 'server' | undefined,
   logger: Logger,
 ): DepOptimizationOptions {
+  if (
+    optimizeDeps?.rolldownOptions &&
+    optimizeDeps?.rolldownOptions === optimizeDeps?.rollupOptions
+  ) {
+    delete optimizeDeps?.rollupOptions
+  }
   const merged = mergeWithDefaults(
     {
       ...configDefaults.optimizeDeps,
@@ -1103,10 +1109,10 @@ function resolveDepOptimizationOptions(
     },
     optimizeDeps ?? {},
   )
-  setupRollupOptionCompat(merged)
+  setupRollupOptionCompat(merged, 'optimizeDeps')
 
-  const rollupOptions = merged.rollupOptions as Exclude<
-    DepOptimizationOptions['rollupOptions'],
+  const rolldownOptions = merged.rolldownOptions as Exclude<
+    DepOptimizationOptions['rolldownOptions'],
     undefined
   >
 
@@ -1116,80 +1122,80 @@ function resolveDepOptimizationOptions(
         `You or a plugin you are using have set \`optimizeDeps.esbuildOptions\` ` +
           `but this option is now deprecated. ` +
           `Vite now uses Rolldown to optimize the dependencies. ` +
-          `Please use \`optimizeDeps.rollupOptions\` instead.`,
+          `Please use \`optimizeDeps.rolldownOptions\` instead.`,
       ),
     )
 
-    rollupOptions.resolve ??= {}
-    rollupOptions.output ??= {}
-    rollupOptions.transform ??= {}
+    rolldownOptions.resolve ??= {}
+    rolldownOptions.output ??= {}
+    rolldownOptions.transform ??= {}
 
     const setResolveOptions = <
       T extends keyof Exclude<RolldownOptions['resolve'], undefined>,
     >(
       key: T,
       value: Exclude<RolldownOptions['resolve'], undefined>[T],
     ) => {
-      if (value !== undefined && rollupOptions.resolve![key] === undefined) {
-        rollupOptions.resolve![key] = value
+      if (value !== undefined && rolldownOptions.resolve![key] === undefined) {
+        rolldownOptions.resolve![key] = value
       }
     }
 
     if (
       merged.esbuildOptions.minify !== undefined &&
-      rollupOptions.output.minify === undefined
+      rolldownOptions.output.minify === undefined
     ) {
-      rollupOptions.output.minify = merged.esbuildOptions.minify
+      rolldownOptions.output.minify = merged.esbuildOptions.minify
     }
     if (
       merged.esbuildOptions.treeShaking !== undefined &&
-      rollupOptions.treeshake === undefined
+      rolldownOptions.treeshake === undefined
     ) {
-      rollupOptions.treeshake = merged.esbuildOptions.treeShaking
+      rolldownOptions.treeshake = merged.esbuildOptions.treeShaking
     }
     if (
       merged.esbuildOptions.define !== undefined &&
-      rollupOptions.transform.define === undefined
+      rolldownOptions.transform.define === undefined
     ) {
-      rollupOptions.transform.define = merged.esbuildOptions.define
+      rolldownOptions.transform.define = merged.esbuildOptions.define
     }
     if (merged.esbuildOptions.loader !== undefined) {
       const loader = merged.esbuildOptions.loader
-      rollupOptions.moduleTypes ??= {}
+      rolldownOptions.moduleTypes ??= {}
       for (const [key, value] of Object.entries(loader)) {
         if (
-          rollupOptions.moduleTypes[key] === undefined &&
+          rolldownOptions.moduleTypes[key] === undefined &&
           value !== 'copy' &&
           value !== 'css' &&
           value !== 'default' &&
           value !== 'file' &&
           value !== 'local-css'
         ) {
-          rollupOptions.moduleTypes[key] = value
+          rolldownOptions.moduleTypes[key] = value
         }
       }
     }
     if (
       merged.esbuildOptions.preserveSymlinks !== undefined &&
-      rollupOptions.resolve.symlinks === undefined
+      rolldownOptions.resolve.symlinks === undefined
     ) {
-      rollupOptions.resolve.symlinks = !merged.esbuildOptions.preserveSymlinks
+      rolldownOptions.resolve.symlinks = !merged.esbuildOptions.preserveSymlinks
     }
     setResolveOptions('extensions', merged.esbuildOptions.resolveExtensions)
     setResolveOptions('mainFields', merged.esbuildOptions.mainFields)
     setResolveOptions('conditionNames', merged.esbuildOptions.conditions)
     if (
       merged.esbuildOptions.keepNames !== undefined &&
-      rollupOptions.output.keepNames === undefined
+      rolldownOptions.output.keepNames === undefined
     ) {
-      rollupOptions.output.keepNames = merged.esbuildOptions.keepNames
+      rolldownOptions.output.keepNames = merged.esbuildOptions.keepNames
     }
 
     if (
       merged.esbuildOptions.platform !== undefined &&
-      rollupOptions.platform === undefined
+      rolldownOptions.platform === undefined
     ) {
-      rollupOptions.platform = merged.esbuildOptions.platform
+      rolldownOptions.platform = merged.esbuildOptions.platform
     }
 
     // NOTE: the following options cannot be converted
@@ -1232,20 +1238,20 @@ function resolveDepOptimizationOptions(
   merged.esbuildOptions ??= {}
   merged.esbuildOptions.preserveSymlinks ??= preserveSymlinks
 
-  rollupOptions.resolve ??= {}
-  rollupOptions.resolve.symlinks ??= !preserveSymlinks
-  rollupOptions.output ??= {}
-  rollupOptions.output.topLevelVar ??= true
+  rolldownOptions.resolve ??= {}
+  rolldownOptions.resolve.symlinks ??= !preserveSymlinks
+  rolldownOptions.output ??= {}
+  rolldownOptions.output.topLevelVar ??= true
 
   return merged
 }
 
 async function setOptimizeDepsPluginNames(resolvedConfig: ResolvedConfig) {
   await Promise.all(
     Object.values(resolvedConfig.environments).map(async (environment) => {
-      const plugins = environment.optimizeDeps.rollupOptions?.plugins ?? []
+      const plugins = environment.optimizeDeps.rolldownOptions?.plugins ?? []
       const outputPlugins =
-        environment.optimizeDeps.rollupOptions?.output?.plugins ?? []
+        environment.optimizeDeps.rolldownOptions?.output?.plugins ?? []
       const flattenedPlugins = await asyncFlatten([plugins, outputPlugins])
 
       const pluginNames = []
@@ -1264,9 +1270,9 @@ function applyDepOptimizationOptionCompat(resolvedConfig: ResolvedConfig) {
     resolvedConfig.optimizeDeps.esbuildOptions?.plugins &&
     resolvedConfig.optimizeDeps.esbuildOptions.plugins.length > 0
   ) {
-    resolvedConfig.optimizeDeps.rollupOptions ??= {}
-    resolvedConfig.optimizeDeps.rollupOptions.plugins ||= []
-    ;(resolvedConfig.optimizeDeps.rollupOptions.plugins as any[]).push(
+    resolvedConfig.optimizeDeps.rolldownOptions ??= {}
+    resolvedConfig.optimizeDeps.rolldownOptions.plugins ||= []
+    ;(resolvedConfig.optimizeDeps.rolldownOptions.plugins as any[]).push(
       ...resolvedConfig.optimizeDeps.esbuildOptions.plugins.map((plugin) =>
         convertEsbuildPluginToRolldownPlugin(plugin),
       ),
@@ -1296,14 +1302,14 @@ export async function resolveConfig(
 ): Promise<ResolvedConfig> {
   let config = inlineConfig
   config.build ??= {}
-  setupRollupOptionCompat(config.build)
+  setupRollupOptionCompat(config.build, 'build')
   config.worker ??= {}
-  setupRollupOptionCompat(config.worker)
+  setupRollupOptionCompat(config.worker, 'worker')
   config.optimizeDeps ??= {}
-  setupRollupOptionCompat(config.optimizeDeps)
+  setupRollupOptionCompat(config.optimizeDeps, 'optimizeDeps')
   if (config.ssr) {
     config.ssr.optimizeDeps ??= {}
-    setupRollupOptionCompat(config.ssr.optimizeDeps)
+    setupRollupOptionCompat(config.ssr.optimizeDeps, 'ssr.optimizeDeps')
   }
 
   let configFileDependencies: string[] = []
@@ -1735,7 +1741,7 @@ export async function resolveConfig(
     rollupOptions: config.worker?.rollupOptions || {},
     rolldownOptions: config.worker?.rolldownOptions, // will be set by setupRollupOptionCompat if undefined
   }
-  setupRollupOptionCompat(resolvedWorkerOptions)
+  setupRollupOptionCompat(resolvedWorkerOptions, 'worker')
 
   const base = withTrailingSlash(resolvedBase)
 

packages/vite/src/node/optimizer/index.ts

@@ -760,8 +760,8 @@ async function prepareRolldownOptimizerRun(
 
   const { optimizeDeps } = environment.config
 
-  const { plugins: pluginsFromConfig = [], ...rollupOptions } =
-    optimizeDeps.rollupOptions ?? {}
+  const { plugins: pluginsFromConfig = [], ...rolldownOptions } =
+    optimizeDeps.rolldownOptions ?? {}
 
   let jsxLoader = false
   await Promise.all(
@@ -788,11 +788,11 @@ async function prepareRolldownOptimizerRun(
         // as esbuild will replace it automatically when `platform` is `'browser'`
         'process.env.NODE_ENV'
       : JSON.stringify(process.env.NODE_ENV || environment.config.mode),
-    ...rollupOptions.transform?.define,
+    ...rolldownOptions.transform?.define,
   }
 
   const platform =
-    optimizeDeps.rollupOptions?.platform ??
+    optimizeDeps.rolldownOptions?.platform ??
     // We generally don't want to use platform 'neutral', as esbuild has custom handling
     // when the platform is 'node' or 'browser' that can't be emulated by using mainFields
     // and conditions
@@ -812,24 +812,24 @@ async function prepareRolldownOptimizerRun(
   let canceled = false
   async function build() {
     const bundle = await rolldown({
-      ...rollupOptions,
+      ...rolldownOptions,
       input: flatIdDeps,
       logLevel: 'silent',
       plugins,
       platform,
       transform: {
-        ...rollupOptions.transform,
+        ...rolldownOptions.transform,
         target: ESBUILD_BASELINE_WIDELY_AVAILABLE_TARGET,
         define,
       },
       resolve: {
         extensions: ['.tsx', '.ts', '.jsx', '.js', '.css', '.json'],
-        ...rollupOptions.resolve,
+        ...rolldownOptions.resolve,
       },
       // TODO: remove this and enable rolldown's CSS support later
       moduleTypes: {
         '.css': 'js',
-        ...rollupOptions.moduleTypes,
+        ...rolldownOptions.moduleTypes,
         ...(jsxLoader ? { '.js': 'jsx' } : {}),
       },
     })
@@ -839,7 +839,7 @@ async function prepareRolldownOptimizerRun(
     }
     const result = await bundle.write({
       legalComments: 'none',
-      ...rollupOptions.output,
+      ...rolldownOptions.output,
       format: 'esm',
       sourcemap: true,
       dir: processingCacheDir,
@@ -1089,13 +1089,13 @@ export async function extractExportsData(
 
   const { optimizeDeps } = environment.config
 
-  const rollupOptions = optimizeDeps.rollupOptions ?? {}
+  const rolldownOptions = optimizeDeps.rolldownOptions ?? {}
   if (optimizeDeps.extensions?.some((ext) => filePath.endsWith(ext))) {
     // For custom supported extensions, build the entry file to transform it into JS,
     // and then parse with es-module-lexer. Note that the `bundle` option is not `true`,
     // so only the entry file is being transformed.
-    const { plugins: pluginsFromConfig = [], ...remainingRollupOptions } =
-      rollupOptions
+    const { plugins: pluginsFromConfig = [], ...remainingRolldownOptions } =
+      rolldownOptions
     const plugins = await asyncFlatten(arraify(pluginsFromConfig))
     plugins.unshift({
       name: 'externalize',
@@ -1106,17 +1106,17 @@ export async function extractExportsData(
       },
     })
     const build = await rolldown({
-      ...remainingRollupOptions,
+      ...remainingRolldownOptions,
       plugins,
       input: [filePath],
       // TODO: remove this and enable rolldown's CSS support later
       moduleTypes: {
         '.css': 'js',
-        ...remainingRollupOptions.moduleTypes,
+        ...remainingRolldownOptions.moduleTypes,
       },
     })
     const result = await build.generate({
-      ...rollupOptions.output,
+      ...rolldownOptions.output,
       format: 'esm',
       sourcemap: false,
     })
@@ -1134,7 +1134,7 @@ export async function extractExportsData(
   try {
     parseResult = parse(entryContent)
   } catch {
-    const lang = rollupOptions.moduleTypes?.[path.extname(filePath)] || 'jsx'
+    const lang = rolldownOptions.moduleTypes?.[path.extname(filePath)] || 'jsx'
     debug?.(
       `Unable to parse: ${filePath}.\n Trying again with a ${lang} transform.`,
     )
@@ -1274,14 +1274,14 @@ function getConfigHash(environment: Environment): string {
         exclude: optimizeDeps.exclude
           ? unique(optimizeDeps.exclude).sort()
           : undefined,
-        rollupOptions: {
-          ...optimizeDeps.rollupOptions,
+        rolldownOptions: {
+          ...optimizeDeps.rolldownOptions,
           plugins: undefined, // included in optimizeDepsPluginNames
           onLog: undefined,
           onwarn: undefined,
           checks: undefined,
           output: {
-            ...optimizeDeps.rollupOptions?.output,
+            ...optimizeDeps.rolldownOptions?.output,
             plugins: undefined, // included in optimizeDepsPluginNames
           },
         },

packages/vite/src/node/optimizer/scan.ts

@@ -249,8 +249,8 @@ async function prepareRolldownScanner(
   deps: Record<string, string>,
   missing: Record<string, string>,
 ): Promise<{ build: () => Promise<void> }> {
-  const { plugins: pluginsFromConfig = [], ...rollupOptions } =
-    environment.config.optimizeDeps.rollupOptions ?? {}
+  const { plugins: pluginsFromConfig = [], ...rolldownOptions } =
+    environment.config.optimizeDeps.rolldownOptions ?? {}
 
   const plugins = await asyncFlatten(arraify(pluginsFromConfig))
 
@@ -264,7 +264,7 @@ async function prepareRolldownScanner(
   const { tsconfig } = await loadTsconfigJsonForFile(
     path.join(environment.config.root, '_dummy.js'),
   )
-  const transformOptions = deepClone(rollupOptions.transform) ?? {}
+  const transformOptions = deepClone(rolldownOptions.transform) ?? {}
   setOxcTransformOptionsFromTsconfigOptions(
     transformOptions,
     tsconfig.compilerOptions,
@@ -276,7 +276,7 @@ async function prepareRolldownScanner(
 
   async function build() {
     await scan({
-      ...rollupOptions,
+      ...rolldownOptions,
       transform: transformOptions,
       input: entries,
       logLevel: 'silent',