feat: implement output.clean.keep: Option<string>

crates/node_binding/binding.d.ts

@@ -518,6 +518,17 @@ export interface JsChunkGroupOrigin {
   request?: string
 }
 
+/**
+ * File clean filter object
+ *
+ * This clean filter matches with:
+ * - keep:
+ *   - If a string, keep the files under this path
+ */
+export interface JsCleanFilter {
+  keep?: string
+}
+
 export interface JsCodegenerationResult {
   sources: Record<string, string>
 }
@@ -1729,7 +1740,7 @@ export interface RawOptions {
 export interface RawOutputOptions {
   path: string
   pathinfo: boolean | "verbose"
-  clean: boolean
+  clean: boolean | JsCleanFilter
   publicPath: "auto" | JsFilename
   assetModuleFilename: JsFilename
   wasmLoading: string

crates/rspack_binding_options/src/options/raw_output.rs

@@ -1,7 +1,7 @@
 use napi::Either;
 use napi_derive::napi;
 use rspack_binding_values::library::JsLibraryOptions;
-use rspack_binding_values::JsFilename;
+use rspack_binding_values::{JsCleanOptions, JsFilename};
 use rspack_core::{CrossOriginLoading, Environment, PathInfo};
 use rspack_core::{OutputOptions, TrustedTypes};
 
@@ -64,7 +64,8 @@ pub struct RawOutputOptions {
   pub path: String,
   #[napi(ts_type = "boolean | \"verbose\"")]
   pub pathinfo: Either<bool, String>,
-  pub clean: bool,
+  #[napi(ts_type = "boolean | JsCleanFilter")]
+  pub clean: JsCleanOptions,
   #[napi(ts_type = "\"auto\" | JsFilename")]
   pub public_path: JsFilename,
   pub asset_module_filename: JsFilename,
@@ -120,9 +121,9 @@ impl TryFrom<RawOutputOptions> for OutputOptions {
     };
 
     Ok(OutputOptions {
-      path: value.path.into(),
+      path: value.path.clone().into(),
       pathinfo,
-      clean: value.clean,
+      clean: value.clean.to_clean_options(value.path),
       public_path: value.public_path.into(),
       asset_module_filename: value.asset_module_filename.into(),
       wasm_loading: value.wasm_loading.as_str().into(),

crates/rspack_binding_values/src/clean_options.rs

@@ -0,0 +1,78 @@
+use std::path::Path;
+
+use napi::bindgen_prelude::{FromNapiValue, ToNapiValue};
+use napi::Either;
+use napi_derive::napi;
+use rspack_core::CleanOptions;
+use rspack_napi::napi;
+
+/// File clean options
+///
+/// A file filter is an option whether the file should be kept after clean up
+///
+/// TS Type:
+///
+/// ```typescript
+/// // in the future, we should support the following types, just like webpack
+/// // type CleanOptions = boolean | { dry?: boolean, keep?: RegExp | string | ((filename: string) => boolean) }
+///
+/// type CleanOptions = boolean | { keep?: string }
+/// ```
+#[derive(Debug)]
+pub struct JsCleanOptions(Either<bool, JsCleanFilter>);
+
+impl ToNapiValue for JsCleanOptions {
+  unsafe fn to_napi_value(
+    env: napi::sys::napi_env,
+    val: Self,
+  ) -> napi::Result<napi::sys::napi_value> {
+    Either::to_napi_value(env, val.0)
+  }
+}
+
+impl FromNapiValue for JsCleanOptions {
+  unsafe fn from_napi_value(
+    env: napi::sys::napi_env,
+    napi_val: napi::sys::napi_value,
+  ) -> napi::Result<Self> {
+    let val = Either::from_napi_value(env, napi_val);
+    Ok(Self(val?))
+  }
+}
+
+/// File clean filter object
+///
+/// This clean filter matches with:
+/// - keep:
+///   - If a string, keep the files under this path
+#[napi(object)]
+#[derive(Debug)]
+pub struct JsCleanFilter {
+  pub keep: Option<String>,
+  // todo:
+  // - support RegExp type
+  //   if path match the RegExp, keep the file
+  // - support function type
+  //    if the fn returns true on path str, keep the file
+}
+
+impl JsCleanFilter {
+  pub fn to_clean_options<T: AsRef<Path>>(&self, working_dir: T) -> CleanOptions {
+    let wd = working_dir.as_ref();
+    let keep = self.keep.as_ref().map(|p| wd.join(p));
+    if let Some(path) = keep {
+      CleanOptions::KeepPath(path)
+    } else {
+      CleanOptions::Boolean(false)
+    }
+  }
+}
+
+impl JsCleanOptions {
+  pub fn to_clean_options<T: AsRef<Path>>(&self, working_dir: T) -> CleanOptions {
+    match &self.0 {
+      Either::A(b) => CleanOptions::Boolean(*b),
+      Either::B(f) => f.to_clean_options(working_dir),
+    }
+  }
+}

crates/rspack_binding_values/src/lib.rs

@@ -4,6 +4,7 @@ mod asset_condition;
 mod chunk;
 mod chunk_graph;
 mod chunk_group;
+mod clean_options;
 mod codegen_result;
 mod compilation;
 mod context_module_factory;
@@ -30,6 +31,7 @@ pub use asset_condition::*;
 pub use chunk::*;
 pub use chunk_graph::*;
 pub use chunk_group::*;
+pub use clean_options::*;
 pub use codegen_result::*;
 pub use compilation::*;
 pub use context_module_factory::*;

crates/rspack_core/src/compiler/mod.rs

@@ -20,8 +20,8 @@ use crate::cache::{new_cache, Cache};
 use crate::incremental::IncrementalPasses;
 use crate::old_cache::Cache as OldCache;
 use crate::{
-  fast_set, include_hash, BoxPlugin, CompilerOptions, Logger, PluginDriver, ResolverFactory,
-  SharedPluginDriver,
+  fast_set, include_hash, BoxPlugin, CleanOptions, CompilerOptions, Logger, PluginDriver,
+  ResolverFactory, SharedPluginDriver,
 };
 use crate::{ContextModuleFactory, NormalModuleFactory};
 
@@ -264,32 +264,7 @@ impl Compiler {
 
   #[instrument(name = "emit_assets", skip_all)]
   pub async fn emit_assets(&mut self) -> Result<()> {
-    if self.options.output.clean {
-      if self.emitted_asset_versions.is_empty() {
-        self
-          .output_filesystem
-          .remove_dir_all(&self.options.output.path)
-          .await?;
-      } else {
-        // clean unused file
-        let assets = self.compilation.assets();
-        let _ = self
-          .emitted_asset_versions
-          .iter()
-          .filter_map(|(filename, _version)| {
-            if !assets.contains_key(filename) {
-              let filename = filename.to_owned();
-              Some(async {
-                let filename = Utf8Path::new(&self.options.output.path).join(filename);
-                let _ = self.output_filesystem.remove_file(&filename).await;
-              })
-            } else {
-              None
-            }
-          })
-          .collect::<FuturesResults<_>>();
-      }
-    }
+    self.run_clean_options().await?;
 
     self
       .plugin_driver
@@ -421,6 +396,42 @@ impl Compiler {
     Ok(())
   }
 
+  async fn run_clean_options(&mut self) -> Result<()> {
+    let clean_options = &self.options.output.clean;
+    if let CleanOptions::Boolean(false) = clean_options {
+      return Ok(());
+    }
+
+    if self.emitted_asset_versions.is_empty() {
+      self
+        .output_filesystem
+        .remove_dir_all(&self.options.output.path)
+        .await?;
+      return Ok(());
+    }
+
+    let assets = self.compilation.assets();
+    let _ = self
+      .emitted_asset_versions
+      .iter()
+      .filter_map(|(filename, _version)| {
+        if !assets.contains_key(filename) {
+          let filename = filename.to_owned();
+          Some(async {
+            let filename = Utf8Path::new(&self.options.output.path).join(filename);
+            if !clean_options.keep(filename.as_str()) {
+              let _ = self.output_filesystem.remove_file(&filename).await;
+            }
+          })
+        } else {
+          None
+        }
+      })
+      .collect::<FuturesResults<_>>();
+
+    Ok(())
+  }
+
   fn new_compilation_params(&self) -> CompilationParams {
     CompilationParams {
       normal_module_factory: Arc::new(NormalModuleFactory::new(

crates/rspack_core/src/options/clean_options.rs

@@ -0,0 +1,43 @@
+use std::{path::PathBuf, str::FromStr};
+
+/// rust representation of the clean options
+// TODO: support RegExp and function type
+#[derive(Debug)]
+pub enum CleanOptions {
+  // if true, clean all files
+  Boolean(bool),
+  // keep the files under this path
+  KeepPath(PathBuf),
+}
+
+impl CleanOptions {
+  pub fn keep(&self, path: &str) -> bool {
+    match self {
+      Self::Boolean(value) => !*value,
+      Self::KeepPath(value) => {
+        let path = PathBuf::from(path);
+        path.starts_with(value)
+      }
+    }
+  }
+}
+
+impl From<bool> for CleanOptions {
+  fn from(value: bool) -> Self {
+    Self::Boolean(value)
+  }
+}
+
+impl From<&'_ str> for CleanOptions {
+  fn from(value: &str) -> Self {
+    let pb = PathBuf::from_str(value).expect("should be a valid path");
+    Self::KeepPath(pb)
+  }
+}
+
+impl From<String> for CleanOptions {
+  fn from(value: String) -> Self {
+    let pb = PathBuf::from_str(&value).expect("should be a valid path");
+    Self::KeepPath(pb)
+  }
+}

crates/rspack_core/src/options/mod.rs

@@ -31,3 +31,5 @@ mod node;
 pub use node::*;
 mod filename;
 pub use filename::*;
+mod clean_options;
+pub use clean_options::*;

crates/rspack_core/src/options/output.rs

@@ -9,6 +9,7 @@ use rspack_macros::MergeFrom;
 use rspack_paths::{AssertUtf8, Utf8Path, Utf8PathBuf};
 use sugar_path::SugarPath;
 
+use super::CleanOptions;
 use crate::{Chunk, ChunkGroupByUkey, ChunkKind, Compilation, Filename, FilenameTemplate};
 
 #[derive(Debug)]
@@ -21,7 +22,7 @@ pub enum PathInfo {
 pub struct OutputOptions {
   pub path: Utf8PathBuf,
   pub pathinfo: PathInfo,
-  pub clean: bool,
+  pub clean: CleanOptions,
   pub public_path: PublicPath,
   pub asset_module_filename: Filename,
   pub wasm_loading: WasmLoading,

packages/rspack-test-tools/package.json

@@ -50,6 +50,7 @@
     "@babel/template": "7.22.15",
     "@babel/traverse": "7.23.2",
     "@babel/types": "7.23.0",
+    "cross-env": "^7.0.3",
     "csv-to-markdown-table": "^1.3.0",
     "deepmerge": "^4.3.1",
     "filenamify": "4.3.0",

packages/rspack-test-tools/tests/configCases/clean/enabled/index.js

@@ -0,0 +1,2 @@
+
+it("should compiles", () => { })

packages/rspack-test-tools/tests/configCases/clean/enabled/readdir.js

@@ -0,0 +1,38 @@
+const fs = require('fs');
+const path = require('path');
+
+function handlePath(path) {
+	return path.replace(/\\/g, "/");
+}
+
+module.exports = function readDir(from) {
+	const collectedFiles = [];
+	const collectedDirectories = [];
+	const stack = [from];
+	let cursor;
+
+	while ((cursor = stack.pop())) {
+		const stat = fs.statSync(cursor);
+
+		if (stat.isDirectory()) {
+			const items = fs.readdirSync(cursor);
+
+			if (from !== cursor) {
+				const relative = path.relative(from, cursor);
+				collectedDirectories.push(handlePath(relative));
+			}
+
+			for (let i = 0; i < items.length; i++) {
+				stack.push(path.join(cursor, items[i]));
+			}
+		} else {
+			const relative = path.relative(from, cursor);
+			collectedFiles.push(handlePath(relative));
+		}
+	}
+
+	return {
+		files: collectedFiles,
+		directories: collectedDirectories
+	};
+}