feat(rust): should create bundler with InputOptions and `OutputOpti…

…ons` together (#596)

<!-- Thank you for contributing! -->

### Description

This does not affects the API of node side.

<!-- Please insert your description here and provide especially info about the "what" this PR is solving -->

### Test Plan

<!-- e.g. is there anything you'd like reviewers to focus on? -->

---

crates/bench/benches/threejs.rs

@@ -25,14 +25,17 @@ fn criterion_benchmark(c: &mut Criterion) {
     group.bench_function(scan_id, |b| {
       b.iter(|| {
         tokio::runtime::Runtime::new().unwrap().block_on(async {
-          let mut rolldown_bundler = rolldown::Bundler::new(InputOptions {
-            input: vec![rolldown::InputItem {
-              name: Some(item.name.to_string()),
-              import: item.entry_path.to_string_lossy().to_string(),
-            }],
-            cwd: join_by_repo_root("crates/benches"),
-            ..Default::default()
-          });
+          let mut rolldown_bundler = rolldown::Bundler::new(
+            InputOptions {
+              input: vec![rolldown::InputItem {
+                name: Some(item.name.to_string()),
+                import: item.entry_path.to_string_lossy().to_string(),
+              }],
+              cwd: join_by_repo_root("crates/benches"),
+              ..Default::default()
+            },
+            Default::default(),
+          );
           rolldown_bundler.scan().await.unwrap();
         })
       });
@@ -55,15 +58,18 @@ fn criterion_benchmark(c: &mut Criterion) {
     group.bench_function(bundle_id, |b| {
       b.iter(|| {
         tokio::runtime::Runtime::new().unwrap().block_on(async {
-          let mut rolldown_bundler = rolldown::Bundler::new(InputOptions {
-            input: vec![rolldown::InputItem {
-              name: Some(item.name.to_string()),
-              import: item.entry_path.to_string_lossy().to_string(),
-            }],
-            cwd: join_by_repo_root("crates/bench"),
-            ..Default::default()
-          });
-          rolldown_bundler.write(Default::default()).await.unwrap();
+          let mut rolldown_bundler = rolldown::Bundler::new(
+            InputOptions {
+              input: vec![rolldown::InputItem {
+                name: Some(item.name.to_string()),
+                import: item.entry_path.to_string_lossy().to_string(),
+              }],
+              cwd: join_by_repo_root("crates/bench"),
+              ..Default::default()
+            },
+            Default::default(),
+          );
+          rolldown_bundler.write().await.unwrap();
         })
       });
     });

crates/bench/src/lib.rs

@@ -20,17 +20,20 @@ pub fn repo_root() -> PathBuf {
 }
 
 pub async fn run_fixture(fixture_path: PathBuf) {
-  let mut bundler = Bundler::new(InputOptions {
-    input: vec![InputItem { name: Some("main".to_string()), import: "./main.js".to_string() }],
-    cwd: fixture_path.clone(),
-    ..Default::default()
-  });
+  let mut bundler = Bundler::new(
+    InputOptions {
+      input: vec![InputItem { name: Some("main".to_string()), import: "./main.js".to_string() }],
+      cwd: fixture_path.clone(),
+      ..Default::default()
+    },
+    OutputOptions::default(),
+  );
 
   if fixture_path.join("dist").is_dir() {
     std::fs::remove_dir_all(fixture_path.join("dist")).unwrap();
   }
 
-  bundler.write(OutputOptions::default()).await.unwrap();
+  bundler.write().await.unwrap();
 }
 
 pub fn join_by_repo_root(path: &str) -> PathBuf {

crates/rolldown/examples/basic.rs

@@ -10,15 +10,18 @@ async fn main() {
       .unwrap_or(std::env::current_dir().unwrap().display().to_string()),
   );
   let cwd = root.join("./examples").into_normalize();
-  let mut bundler = Bundler::new(InputOptions {
-    input: vec![
-      InputItem { name: Some("react-dom".to_string()), import: "react-dom".to_string() },
-      InputItem { name: Some("react".to_string()), import: "react".to_string() },
-    ],
-    cwd,
-    ..Default::default()
-  });
+  let mut bundler = Bundler::new(
+    InputOptions {
+      input: vec![
+        InputItem { name: Some("react-dom".to_string()), import: "react-dom".to_string() },
+        InputItem { name: Some("react".to_string()), import: "react".to_string() },
+      ],
+      cwd,
+      ..Default::default()
+    },
+    OutputOptions::default(),
+  );
 
-  let _outputs = bundler.write(OutputOptions::default()).await.unwrap();
+  let _outputs = bundler.write().await.unwrap();
   // println!("{outputs:#?}");
 }

crates/rolldown/src/bundler.rs

@@ -23,27 +23,39 @@ use crate::{
 
 pub struct Bundler<T: BundlerFileSystem> {
   pub(crate) input_options: SharedInputOptions,
+  pub(crate) output_options: OutputOptions,
   pub(crate) plugin_driver: SharedPluginDriver,
   pub(crate) fs: T,
   pub(crate) resolver: SharedResolver<T>,
 }
 
 impl Bundler<OsFileSystem> {
-  pub fn new(input_options: InputOptions) -> Self {
-    BundlerBuilder::default().with_input_options(input_options).build()
+  pub fn new(input_options: InputOptions, output_options: OutputOptions) -> Self {
+    BundlerBuilder::default()
+      .with_input_options(input_options)
+      .with_output_options(output_options)
+      .build()
   }
 
-  pub fn with_plugins(input_options: InputOptions, plugins: Vec<BoxPlugin>) -> Self {
-    BundlerBuilder::default().with_input_options(input_options).with_plugins(plugins).build()
+  pub fn with_plugins(
+    input_options: InputOptions,
+    output_options: OutputOptions,
+    plugins: Vec<BoxPlugin>,
+  ) -> Self {
+    BundlerBuilder::default()
+      .with_input_options(input_options)
+      .with_output_options(output_options)
+      .with_plugins(plugins)
+      .build()
   }
 }
 
 impl<T: BundlerFileSystem> Bundler<T> {
-  pub async fn write(&mut self, output_options: OutputOptions) -> BatchedResult<RolldownOutput> {
+  pub async fn write(&mut self) -> BatchedResult<RolldownOutput> {
     let dir =
-      self.input_options.cwd.as_path().join(&output_options.dir).to_string_lossy().to_string();
+      self.input_options.cwd.as_path().join(&self.output_options.dir).to_string_lossy().to_string();
 
-    let output = self.bundle_up(output_options, true).await?;
+    let output = self.bundle_up(true).await?;
 
     self.plugin_driver.write_bundle(&output.assets).await?;
 
@@ -69,8 +81,8 @@ impl<T: BundlerFileSystem> Bundler<T> {
     Ok(output)
   }
 
-  pub async fn generate(&mut self, output_options: OutputOptions) -> BatchedResult<RolldownOutput> {
-    self.bundle_up(output_options, false).await
+  pub async fn generate(&mut self) -> BatchedResult<RolldownOutput> {
+    self.bundle_up(false).await
   }
 
   pub async fn scan(&mut self) -> BatchedResult<()> {
@@ -132,19 +144,15 @@ impl<T: BundlerFileSystem> Bundler<T> {
   }
 
   #[tracing::instrument(skip_all)]
-  async fn bundle_up(
-    &mut self,
-    output_options: OutputOptions,
-    is_write: bool,
-  ) -> BatchedResult<RolldownOutput> {
+  async fn bundle_up(&mut self, is_write: bool) -> BatchedResult<RolldownOutput> {
     tracing::trace!("InputOptions {:#?}", self.input_options);
-    tracing::trace!("OutputOptions: {output_options:#?}",);
+    tracing::trace!("OutputOptions: {:#?}", self.output_options);
     let mut link_stage_output = self.try_build().await?;
 
     let mut bundle_stage = BundleStage::new(
       &mut link_stage_output,
       &self.input_options,
-      &output_options,
+      &self.output_options,
       &self.plugin_driver,
     );
 

crates/rolldown/src/bundler_builder.rs

@@ -5,10 +5,12 @@ use rolldown_resolver::Resolver;
 
 use crate::{
   plugin_driver::PluginDriver, types::bundler_fs::BundlerFileSystem, Bundler, InputOptions,
+  OutputOptions,
 };
 
 pub struct BundlerBuilder<Fs: BundlerFileSystem> {
   input_options: InputOptions,
+  output_options: OutputOptions,
   fs: Fs,
   plugins: Vec<BoxPlugin>,
 }
@@ -25,6 +27,7 @@ impl<Fs: BundlerFileSystem> BundlerBuilder<Fs> {
       .into(),
       plugin_driver: Arc::new(PluginDriver::new(self.plugins)),
       input_options: Arc::new(self.input_options),
+      output_options: self.output_options,
       fs: self.fs,
     }
   }
@@ -41,13 +44,29 @@ impl<Fs: BundlerFileSystem> BundlerBuilder<Fs> {
     self
   }
 
+  #[must_use]
+  pub fn with_output_options(mut self, output_options: OutputOptions) -> Self {
+    self.output_options = output_options;
+    self
+  }
+
   pub fn with_file_system<NewFs: BundlerFileSystem>(self, fs: NewFs) -> BundlerBuilder<NewFs> {
-    BundlerBuilder { input_options: self.input_options, fs, plugins: self.plugins }
+    BundlerBuilder {
+      input_options: self.input_options,
+      fs,
+      plugins: self.plugins,
+      output_options: self.output_options,
+    }
   }
 }
 
 impl<Fs: BundlerFileSystem> Default for BundlerBuilder<Fs> {
   fn default() -> Self {
-    Self { input_options: InputOptions::default(), fs: Fs::default(), plugins: vec![] }
+    Self {
+      input_options: InputOptions::default(),
+      fs: Fs::default(),
+      plugins: vec![],
+      output_options: OutputOptions::default(),
+    }
   }
 }

crates/rolldown/tests/common/fixture.rs

@@ -92,44 +92,45 @@ impl Fixture {
       test_config.input.input = Some(vec![default_test_input_item()]);
     }
 
-    let mut bundler = Bundler::new(InputOptions {
-      input: test_config
-        .input
-        .input
-        .map(|items| {
-          items
-            .into_iter()
-            .map(|item| rolldown::InputItem { name: Some(item.name), import: item.import })
-            .collect()
-        })
-        .unwrap(),
-      cwd: fixture_path.to_path_buf(),
-      external: test_config.input.external.map(External::ArrayString).unwrap_or_default(),
-      treeshake: test_config.input.treeshake.unwrap_or(true),
-      resolve: test_config.input.resolve.map(|value| rolldown_resolver::ResolverOptions {
-        alias: value.alias.map(|alias| alias.into_iter().collect::<Vec<_>>()),
-        alias_fields: value.alias_fields,
-        condition_names: value.condition_names,
-        exports_fields: value.exports_fields,
-        extensions: value.extensions,
-        main_fields: value.main_fields,
-        main_files: value.main_files,
-        modules: value.modules,
-        symlinks: value.symlinks,
-      }),
-    });
+    let mut bundler = Bundler::new(
+      InputOptions {
+        input: test_config
+          .input
+          .input
+          .map(|items| {
+            items
+              .into_iter()
+              .map(|item| rolldown::InputItem { name: Some(item.name), import: item.import })
+              .collect()
+          })
+          .unwrap(),
+        cwd: fixture_path.to_path_buf(),
+        external: test_config.input.external.map(External::ArrayString).unwrap_or_default(),
+        treeshake: test_config.input.treeshake.unwrap_or(true),
+        resolve: test_config.input.resolve.map(|value| rolldown_resolver::ResolverOptions {
+          alias: value.alias.map(|alias| alias.into_iter().collect::<Vec<_>>()),
+          alias_fields: value.alias_fields,
+          condition_names: value.condition_names,
+          exports_fields: value.exports_fields,
+          extensions: value.extensions,
+          main_fields: value.main_fields,
+          main_files: value.main_files,
+          modules: value.modules,
+          symlinks: value.symlinks,
+        }),
+      },
+      OutputOptions {
+        entry_file_names: FileNameTemplate::from("[name].mjs".to_string()),
+        chunk_file_names: FileNameTemplate::from("[name].mjs".to_string()),
+        ..Default::default()
+      },
+    );
 
     if fixture_path.join("dist").is_dir() {
       std::fs::remove_dir_all(fixture_path.join("dist")).unwrap();
     }
 
-    let value = bundler
-      .write(OutputOptions {
-        entry_file_names: FileNameTemplate::from("[name].mjs".to_string()),
-        chunk_file_names: FileNameTemplate::from("[name].mjs".to_string()),
-        ..Default::default()
-      })
-      .await?;
+    let value = bundler.write().await?;
     Ok(value)
   }
 }