feat: rolldownConfig

src/build/rolldown/config.ts

@@ -70,7 +70,11 @@ export const getRolldownConfig = async (
     },
   } satisfies RolldownOptions;
 
-  config = defu(nitro.options.rollupConfig as any, config);
+  config = defu(
+    nitro.options.rolldownConfig,
+    nitro.options.rollupConfig as RolldownOptions,
+    config
+  );
 
   const outputConfig = config.output as OutputOptions;
   if (outputConfig.inlineDynamicImports || outputConfig.format === "iife") {

src/build/vite/bundler.ts

@@ -0,0 +1,110 @@
+import { defu } from "defu";
+import { baseBuildConfig, type BaseBuildConfig } from "../config.ts";
+import { getChunkName, libChunkName, NODE_MODULES_RE } from "../chunks.ts";
+import { baseBuildPlugins } from "../plugins.ts";
+
+import type { RolldownConfig, RollupConfig } from "nitro/types";
+import type { Plugin as RollupPlugin } from "rollup";
+import type { NitroPluginContext } from "./types.ts";
+
+export const getBundlerConfig = async (
+  ctx: NitroPluginContext
+): Promise<{
+  base: BaseBuildConfig;
+  rollupConfig?: RollupConfig;
+  rolldownConfig?: RolldownConfig;
+}> => {
+  const nitro = ctx.nitro!;
+  const base = baseBuildConfig(nitro);
+
+  const commonConfig = {
+    input: nitro.options.entry,
+    external: [...base.env.external],
+    plugins: [...(await baseBuildPlugins(nitro, base))].filter(
+      Boolean
+    ) as RollupPlugin[],
+    treeshake: {
+      moduleSideEffects(id) {
+        return nitro.options.moduleSideEffects.some((p) => id.startsWith(p));
+      },
+    },
+    onwarn(warning, warn) {
+      if (!base.ignoreWarningCodes.has(warning.code || "")) {
+        warn(warning);
+      }
+    },
+    output: {
+      dir: nitro.options.output.serverDir,
+      format: "esm",
+      entryFileNames: "index.mjs",
+      chunkFileNames: (chunk: { name: string; moduleIds: string[] }) =>
+        getChunkName(chunk, nitro),
+      inlineDynamicImports: nitro.options.inlineDynamicImports,
+      sourcemapIgnoreList: (id) => id.includes("node_modules"),
+    },
+  } satisfies RollupConfig & RolldownConfig;
+
+  if (ctx._isRolldown) {
+    // Rolldown
+    const rolldownConfig = {
+      transform: {
+        inject: base.env.inject as Record<string, string>,
+      },
+      output: {
+        codeSplitting: {
+          groups: [
+            {
+              test: NODE_MODULES_RE,
+              name: (id: string) => libChunkName(id),
+            },
+          ],
+        },
+      },
+    } satisfies RolldownConfig;
+
+    return {
+      base,
+      rollupConfig: undefined,
+      rolldownConfig: defu(
+        rolldownConfig,
+        nitro.options.rolldownConfig,
+        nitro.options.rollupConfig as RolldownConfig, // Added for backward compatibility
+        commonConfig satisfies RolldownConfig
+      ),
+    };
+  } else {
+    // Rollup
+    const inject = (
+      (await import("@rollup/plugin-inject")) as unknown as typeof import("@rollup/plugin-inject")
+    ).default;
+    const alias = (
+      (await import("@rollup/plugin-alias")) as unknown as typeof import("@rollup/plugin-alias")
+    ).default;
+
+    const rollupConfig: RollupConfig = {
+      plugins: [inject(base.env.inject), alias({ entries: base.aliases })],
+      output: {
+        sourcemapExcludeSources: true,
+        generatedCode: {
+          constBindings: true,
+        },
+        manualChunks(id: string) {
+          if (NODE_MODULES_RE.test(id)) {
+            return libChunkName(id);
+          }
+        },
+      },
+    } satisfies RollupConfig;
+
+    return {
+      base,
+      rolldownConfig: undefined,
+      rollupConfig: defu(
+        rollupConfig,
+        nitro.options.rolldownConfig as RollupConfig, // Added for backward compatibility
+        nitro.options.rollupConfig,
+        commonConfig
+      ),
+    };
+  }
+};

src/build/vite/env.ts

@@ -7,7 +7,6 @@ import { runtimeDependencies, runtimeDir } from "nitro/meta";
 import { resolveModulePath } from "exsolve";
 import { createFetchableDevEnvironment } from "./dev.ts";
 import { isAbsolute } from "pathe";
-import type { RolldownOptions } from "rolldown";
 
 export function getEnvRunner(ctx: NitroPluginContext) {
   return (ctx._envRunner ??= new NodeEnvRunner({
@@ -23,7 +22,8 @@ export function createNitroEnvironment(
   return {
     consumer: "server",
     build: {
-      rollupOptions: ctx.rollupConfig!.config as RolldownOptions /* TODO */,
+      rollupOptions: ctx.bundlerConfig!.rollupConfig as any,
+      rolldownOptions: ctx.bundlerConfig!.rolldownConfig,
       minify: ctx.nitro!.options.minify,
       emptyOutDir: false,
       sourcemap: ctx.nitro!.options.sourcemap,
@@ -34,7 +34,7 @@ export function createNitroEnvironment(
         ? [
             /^nitro$/, // i have absolutely no idea why and how it fixes issues!
             new RegExp(`^(${runtimeDependencies.join("|")})$`), // virtual resolutions in vite skip plugin hooks
-            ...ctx.rollupConfig!.base.noExternal,
+            ...ctx.bundlerConfig!.base.noExternal,
           ]
         : true, // production build is standalone
       conditions: ctx.nitro!.options.exportConditions,

src/build/vite/plugin.ts

@@ -10,7 +10,7 @@ import type { InputOption } from "rollup";
 import type { NitroPluginConfig, NitroPluginContext } from "./types.ts";
 import { resolve, join } from "pathe";
 import { createNitro, prepare } from "../../builder.ts";
-import { getViteRollupConfig } from "./rollup.ts";
+import { getBundlerConfig } from "./bundler.ts";
 import { buildEnvironments, prodSetup } from "./prod.ts";
 import {
   getEnvRunner,
@@ -74,7 +74,11 @@ function nitroInit(ctx: NitroPluginContext): VitePlugin {
     applyToEnvironment(env) {
       if (env.name === "nitro" && ctx.nitro?.options.dev) {
         debug("[init] Adding rollup plugins for dev");
-        return [...((ctx.rollupConfig?.config.plugins as VitePlugin[]) || [])];
+        const plugins =
+          (ctx.bundlerConfig?.rolldownConfig?.plugins as VitePlugin[]) ||
+          (ctx.bundlerConfig?.rollupConfig?.plugins as VitePlugin[]) ||
+          [];
+        return [...(plugins || [])];
       }
     },
   };
@@ -177,15 +181,15 @@ function nitroMain(ctx: NitroPluginContext): VitePlugin {
 
     async config(userConfig, _configEnv) {
       debug("[main] Extending config (appType, resolve, server)");
-      if (!ctx.rollupConfig) {
-        throw new Error("Nitro rollup config is not initialized yet.");
+      if (!ctx.bundlerConfig) {
+        throw new Error("Bundler config is not initialized yet!");
       }
       return {
         appType: userConfig.appType || "custom",
         resolve: {
           // TODO: environment specific aliases not working
           // https://github.com/vitejs/vite/pull/17583 (seems not effective)
-          alias: ctx.rollupConfig.base.aliases,
+          alias: ctx.bundlerConfig.base.aliases,
         },
         builder: {
           sharedConfigBuild: true,
@@ -441,13 +445,13 @@ async function setupNitroContext(
   await ctx.nitro.hooks.callHook("build:before", ctx.nitro);
 
   // Resolve common rollup options
-  ctx.rollupConfig = await getViteRollupConfig(ctx);
+  ctx.bundlerConfig = await getBundlerConfig(ctx);
 
   // Call rollup:before hook to allow modifying rollup config
   await ctx.nitro.hooks.callHook(
     "rollup:before",
     ctx.nitro,
-    ctx.rollupConfig.config
+    ctx.bundlerConfig.rollupConfig || (ctx.bundlerConfig.rolldownConfig as any)
   );
 
   // Warm up env runner for dev

src/build/vite/types.ts

@@ -1,4 +1,4 @@
-import type { getViteRollupConfig } from "./rollup.ts";
+import type { getBundlerConfig } from "./bundler.ts";
 import type { EnvRunner, Nitro, NitroConfig, NitroModule } from "nitro/types";
 import type { NitroDevApp } from "../../dev/app.ts";
 
@@ -51,7 +51,7 @@ export interface ServiceConfig {
 export interface NitroPluginContext {
   nitro?: Nitro;
   pluginConfig: NitroPluginConfig;
-  rollupConfig?: Awaited<ReturnType<typeof getViteRollupConfig>>;
+  bundlerConfig?: Awaited<ReturnType<typeof getBundlerConfig>>;
   devApp?: NitroDevApp;
   services: Record<string, ServiceConfig>;
 

src/config/defaults.ts

@@ -66,7 +66,7 @@ export const NitroDefaults: NitroConfig = {
     routes: [],
   },
 
-  // Rollup
+  // Builder
   builder: undefined,
   moduleSideEffects: ["unenv/polyfill/"],
   replace: {},

src/types/rollup.ts → src/types/build.ts

@@ -2,30 +2,22 @@ import type {
   InputOptions as RollupInputOptions,
   OutputOptions as RollupOutputOptions,
 } from "rollup";
+import type {
+  InputOptions as RolldownInputOptions,
+  OutputOptions as RolldownOutputOptions,
+} from "rolldown";
 import type { MinifyOptions } from "oxc-minify";
 import type { JsxOptions, TransformOptions } from "oxc-transform";
 
 export type RollupConfig = RollupInputOptions & {
   output: RollupOutputOptions;
 };
 
-export type VirtualModule = string | (() => string | Promise<string>);
-
-export interface RollupVirtualOptions {
-  [id: string]: VirtualModule;
-}
+export type RolldownConfig = RolldownInputOptions & {
+  output: RolldownOutputOptions;
+};
 
 export interface OXCOptions {
   minify?: MinifyOptions;
   transform?: Omit<TransformOptions, "jsx"> & { jsx?: JsxOptions };
 }
-
-export interface ServerAssetOptions {
-  inline: boolean;
-  dirs: {
-    [assetdir: string]: {
-      dir: string;
-      meta?: boolean;
-    };
-  };
-}

src/types/config.ts

@@ -34,8 +34,8 @@ import type { NitroFrameworkInfo } from "./nitro.ts";
 import type { NitroOpenAPIConfig } from "./openapi.ts";
 export type { NitroOpenAPIConfig } from "./openapi.ts";
 import type { NitroPreset } from "./preset.ts";
-import type { OXCOptions } from "./rollup.ts";
-import type { RollupConfig } from "./rollup.ts";
+import type { OXCOptions, RolldownConfig } from "./build.ts";
+import type { RollupConfig } from "./build.ts";
 import type { NitroRouteConfig, NitroRouteRules } from "./route-rules.ts";
 
 type RollupCommonJSOptions = NonNullable<
@@ -235,6 +235,7 @@ export interface NitroOptions extends PresetOptions {
   // Rollup
   builder?: "rollup" | "rolldown" | "vite";
   rollupConfig?: RollupConfig;
+  rolldownConfig?: RolldownConfig;
   entry: string;
   unenv: UnenvPreset[];
   alias: Record<string, string>;

src/types/hooks.ts

@@ -2,7 +2,7 @@ import type { EnvRunnerData } from "../runner/node.ts";
 import type { NitroConfig } from "./config.ts";
 import type { Nitro, NitroTypes } from "./nitro.ts";
 import type { PrerenderRoute } from "./prerender.ts";
-import type { RollupConfig } from "./rollup.ts";
+import type { RollupConfig } from "./build.ts";
 
 type HookResult = void | Promise<void>;
 

src/types/index.ts

@@ -20,6 +20,6 @@ export * from "./module.ts";
 export * from "./nitro.ts";
 export * from "./prerender.ts";
 export * from "./preset.ts";
-export * from "./rollup.ts";
+export * from "./build.ts";
 export * from "./route-rules.ts";
 export * from "./srvx.ts";