feat: support output.compareBeforeEmit (#8245)

crates/node_binding/binding.d.ts

@@ -1690,6 +1690,7 @@ export interface RawOutputOptions {
   workerPublicPath: string
   scriptType: "module" | "text/javascript" | "false"
   environment: RawEnvironment
+  compareBeforeEmit: boolean
 }
 
 export interface RawParserOptions {

crates/rspack_binding_options/src/options/raw_output.rs

@@ -107,6 +107,7 @@ pub struct RawOutputOptions {
   #[napi(ts_type = r#""module" | "text/javascript" | "false""#)]
   pub script_type: String,
   pub environment: RawEnvironment,
+  pub compare_before_emit: bool,
 }
 
 impl TryFrom<RawOutputOptions> for OutputOptions {
@@ -160,6 +161,7 @@ impl TryFrom<RawOutputOptions> for OutputOptions {
       environment: value.environment.into(),
       charset: value.charset,
       chunk_load_timeout: value.chunk_load_timeout,
+      compare_before_emit: value.compare_before_emit,
     })
   }
 }

crates/rspack_core/src/compiler/mod.rs

@@ -4,7 +4,7 @@ mod make;
 mod module_executor;
 use std::sync::Arc;
 
-use rspack_error::Result;
+use rspack_error::{error, Result};
 use rspack_fs::{
   AsyncNativeFileSystem, AsyncWritableFileSystem, NativeFileSystem, ReadableFileSystem,
 };
@@ -21,7 +21,8 @@ pub use self::module_executor::{ExecuteModuleId, ExecutedRuntimeModule, ModuleEx
 use crate::incremental::IncrementalPasses;
 use crate::old_cache::Cache as OldCache;
 use crate::{
-  fast_set, BoxPlugin, CompilerOptions, Logger, PluginDriver, ResolverFactory, SharedPluginDriver,
+  fast_set, include_hash, BoxPlugin, CompilerOptions, Logger, PluginDriver, ResolverFactory,
+  SharedPluginDriver,
 };
 use crate::{ContextModuleFactory, NormalModuleFactory};
 
@@ -340,9 +341,7 @@ impl Compiler {
     asset: &CompilationAsset,
   ) -> Result<()> {
     if let Some(source) = asset.get_source() {
-      let filename = filename
-        .split_once('?')
-        .map_or(filename, |(filename, _query)| filename);
+      let (filename, query) = filename.split_once('?').unwrap_or((filename, ""));
       let file_path = output_path.join(filename);
       self
         .output_filesystem
@@ -353,12 +352,49 @@ impl Compiler {
         )
         .await?;
 
-      self
-        .output_filesystem
-        .write(&file_path, source.buffer().as_ref())
-        .await?;
+      let content = source.buffer();
 
-      self.compilation.emitted_assets.insert(filename.to_string());
+      let mut immutable = asset.info.immutable.unwrap_or(false);
+      if !query.is_empty() {
+        immutable = immutable
+          && (include_hash(filename, &asset.info.content_hash)
+            || include_hash(filename, &asset.info.chunk_hash)
+            || include_hash(filename, &asset.info.full_hash));
+      }
+
+      let need_write = if !self.options.output.compare_before_emit {
+        // write when compare_before_emit is false
+        true
+      } else if !file_path.exists() {
+        // write when file not exist
+        true
+      } else if immutable {
+        // do not write when asset is immutable and the file exists
+        false
+      } else {
+        // TODO: webpack use outputFileSystem to get metadata and file content
+        // should also use outputFileSystem after aligning with webpack
+        let metadata = self
+          .input_filesystem
+          .metadata(file_path.as_path().as_ref())
+          .map_err(|e| error!("failed to read metadata: {e}"))?;
+        if (content.len() as u64) == metadata.len() {
+          match self.input_filesystem.read(file_path.as_path().as_ref()) {
+            // write when content is different
+            Ok(c) => content != c,
+            // write when file can not be read
+            Err(_) => true,
+          }
+        } else {
+          // write if content length is different
+          true
+        }
+      };
+
+      if need_write {
+        self.output_filesystem.write(&file_path, &content).await?;
+        self.compilation.emitted_assets.insert(filename.to_string());
+      }
 
       let info = AssetEmittedInfo {
         output_path: output_path.to_owned(),

crates/rspack_core/src/options/output.rs

@@ -63,6 +63,7 @@ pub struct OutputOptions {
   pub worker_public_path: String,
   pub script_type: String,
   pub environment: Environment,
+  pub compare_before_emit: bool,
 }
 
 impl From<&OutputOptions> for RspackHash {

crates/rspack_core/src/utils/hash.rs

@@ -2,6 +2,8 @@ use std::borrow::Cow;
 use std::collections::hash_map::DefaultHasher;
 use std::hash::{Hash, Hasher};
 
+use rustc_hash::FxHashSet as HashSet;
+
 pub fn calc_hash<T: Hash>(t: &T) -> u64 {
   let mut s = DefaultHasher::new();
   t.hash(&mut s);
@@ -29,6 +31,10 @@ pub fn extract_hash_pattern(pattern: &str, key: &str) -> Option<ExtractedHashPat
   })
 }
 
+pub fn include_hash(filename: &str, hashes: &HashSet<String>) -> bool {
+  hashes.iter().any(|hash| filename.contains(hash))
+}
+
 pub trait Replacer {
   fn get_replacer(&mut self, hash_len: Option<usize>) -> Cow<'_, str>;
 }

packages/rspack-test-tools/tests/__snapshots__/Defaults.test.js.snap

@@ -262,6 +262,7 @@ Object {
     chunkLoading: jsonp,
     chunkLoadingGlobal: webpackChunk_rspack_test_tools,
     clean: false,
+    compareBeforeEmit: true,
     crossOriginLoading: false,
     cssChunkFilename: [name].css,
     cssFilename: [name].css,

packages/rspack-test-tools/tests/compilerCases/compare-before-emit-disable.js

@@ -0,0 +1,36 @@
+const path = require("path");
+const fs = require("fs");
+const rimraf = require("rimraf");
+
+let first_asset_mtime;
+
+/** @type {import('../../dist').TCompilerCaseConfig} */
+module.exports = {
+  description: "should write same content to same file",
+  options(context) {
+    return {
+      output: {
+        path: context.getDist(),
+        filename: "main.js",
+        compareBeforeEmit: false
+      },
+      context: context.getSource(),
+      entry: "./d",
+    };
+  },
+  async build(context, compiler) {
+    rimraf.sync(context.getDist());
+    await new Promise(resolve => {
+      compiler.run(() => {
+        first_asset_mtime = fs.statSync(path.join(context.getDist("main.js")))?.mtime;
+        compiler.run(() => {
+          resolve();
+        });
+      });
+    });
+  },
+  async check(context) {
+    let second_asset_mtime = fs.statSync(path.join(context.getDist("main.js")))?.mtime;
+    expect(first_asset_mtime).not.toEqual(second_asset_mtime);
+  }
+};

packages/rspack-test-tools/tests/compilerCases/compare-before-emit.js

@@ -0,0 +1,35 @@
+const path = require("path");
+const fs = require("fs");
+const rimraf = require("rimraf");
+
+let first_asset_mtime;
+
+/** @type {import('../..').TCompilerCaseConfig} */
+module.exports = {
+  description: "should write emit same content to same file",
+  options(context) {
+    return {
+      output: {
+        path: context.getDist(),
+        filename: "main.js",
+      },
+      context: context.getSource(),
+      entry: "./d",
+    };
+  },
+  async build(context, compiler) {
+    rimraf.sync(context.getDist());
+    await new Promise(resolve => {
+      compiler.run(() => {
+        first_asset_mtime = fs.statSync(path.join(context.getDist("main.js")))?.mtime;
+        compiler.run(() => {
+          resolve();
+        });
+      });
+    });
+  },
+  async check(context) {
+    let second_asset_mtime = fs.statSync(path.join(context.getDist("main.js")))?.mtime;
+    expect(first_asset_mtime).toEqual(second_asset_mtime);
+  }
+};

packages/rspack-test-tools/tests/statsOutputCases/filename/rspack.config.js

@@ -4,7 +4,6 @@ const path = require("path");
 module.exports = {
 	entry: "./index",
 	output: {
-		path: path.join(__dirname, './dist'),
 		filename: "[id].xxxx.js",
 		chunkFilename: "[id].xxxx.js"
 	}

packages/rspack/etc/core.api.md

@@ -3878,6 +3878,7 @@ export type Output = {
     chunkLoadTimeout?: number;
     charset?: boolean;
     environment?: Environment;
+    compareBeforeEmit?: boolean;
 };
 
 // @public (undocumented)
@@ -3930,6 +3931,8 @@ export interface OutputNormalized {
     // (undocumented)
     clean?: Clean;
     // (undocumented)
+    compareBeforeEmit?: boolean;
+    // (undocumented)
     crossOriginLoading?: CrossOriginLoading;
     // (undocumented)
     cssChunkFilename?: CssChunkFilename;
@@ -5507,6 +5510,7 @@ export const rspackOptions: z.ZodObject<{
             templateLiteral?: boolean | undefined;
             asyncFunction?: boolean | undefined;
         }>>;
+        compareBeforeEmit: z.ZodOptional<z.ZodBoolean>;
     }, "strict", z.ZodTypeAny, {
         module?: boolean | undefined;
         filename?: string | ((args_0: PathData, args_1: JsAssetInfo | undefined, ...args: unknown[]) => string) | undefined;
@@ -5599,6 +5603,7 @@ export const rspackOptions: z.ZodObject<{
         charset?: boolean | undefined;
         chunkLoadTimeout?: number | undefined;
         cssHeadDataCompression?: boolean | undefined;
+        compareBeforeEmit?: boolean | undefined;
         libraryExport?: string | string[] | undefined;
         libraryTarget?: string | undefined;
         strictModuleExceptionHandling?: boolean | undefined;
@@ -5694,6 +5699,7 @@ export const rspackOptions: z.ZodObject<{
         charset?: boolean | undefined;
         chunkLoadTimeout?: number | undefined;
         cssHeadDataCompression?: boolean | undefined;
+        compareBeforeEmit?: boolean | undefined;
         libraryExport?: string | string[] | undefined;
         libraryTarget?: string | undefined;
         strictModuleExceptionHandling?: boolean | undefined;
@@ -8151,6 +8157,7 @@ export const rspackOptions: z.ZodObject<{
         charset?: boolean | undefined;
         chunkLoadTimeout?: number | undefined;
         cssHeadDataCompression?: boolean | undefined;
+        compareBeforeEmit?: boolean | undefined;
         libraryExport?: string | string[] | undefined;
         libraryTarget?: string | undefined;
         strictModuleExceptionHandling?: boolean | undefined;
@@ -8755,6 +8762,7 @@ export const rspackOptions: z.ZodObject<{
         charset?: boolean | undefined;
         chunkLoadTimeout?: number | undefined;
         cssHeadDataCompression?: boolean | undefined;
+        compareBeforeEmit?: boolean | undefined;
         libraryExport?: string | string[] | undefined;
         libraryTarget?: string | undefined;
         strictModuleExceptionHandling?: boolean | undefined;

packages/rspack/src/config/adapter.ts

@@ -257,7 +257,8 @@ function getRawOutput(output: OutputNormalized): RawOptions["output"] {
 		scriptType: output.scriptType === false ? "false" : output.scriptType!,
 		charset: output.charset!,
 		chunkLoadTimeout: output.chunkLoadTimeout!,
-		environment: output.environment!
+		environment: output.environment!,
+		compareBeforeEmit: output.compareBeforeEmit!
 	};
 }
 

packages/rspack/src/config/defaults.ts

@@ -580,6 +580,7 @@ const applyOutputDefaults = (
 	D(output, "cssHeadDataCompression", !development);
 	D(output, "assetModuleFilename", "[hash][ext][query]");
 	D(output, "webassemblyModuleFilename", "[hash].module.wasm");
+	D(output, "compareBeforeEmit", true);
 	F(output, "path", () => path.join(process.cwd(), "dist"));
 	F(output, "pathinfo", () => development);
 	D(

packages/rspack/src/config/normalization.ts

@@ -214,7 +214,8 @@ export const getNormalizedRspackOptions = (
 					output.devtoolFallbackModuleFilenameTemplate,
 				chunkLoadTimeout: output.chunkLoadTimeout,
 				charset: output.charset,
-				environment: cloneObject(output.environment)
+				environment: cloneObject(output.environment),
+				compareBeforeEmit: output.compareBeforeEmit
 			};
 		}),
 		resolve: nestedConfig(config.resolve, resolve => ({
@@ -519,6 +520,7 @@ export interface OutputNormalized {
 	charset?: boolean;
 	chunkLoadTimeout?: number;
 	cssHeadDataCompression?: boolean;
+	compareBeforeEmit?: boolean;
 }
 
 export interface ModuleOptionsNormalized {

packages/rspack/src/config/types.ts

@@ -633,6 +633,11 @@ export type Output = {
 
 	/** Tell Rspack what kind of ES-features may be used in the generated runtime-code. */
 	environment?: Environment;
+
+	/**
+	 * Check if to be emitted file already exists and have the same content before writing to output filesystem.
+	 */
+	compareBeforeEmit?: boolean;
 };
 
 //#endregion

packages/rspack/src/config/zod.ts

@@ -364,7 +364,8 @@ const output = z.strictObject({
 		devtoolFallbackModuleFilenameTemplate.optional(),
 	chunkLoadTimeout: z.number().optional(),
 	charset: z.boolean().optional(),
-	environment: environment.optional()
+	environment: environment.optional(),
+	compareBeforeEmit: z.boolean().optional()
 }) satisfies z.ZodType<t.Output>;
 //#endregion
 

tests/plugin-test/copy-plugin/helpers/getCompiler.js

@@ -8,6 +8,7 @@ module.exports = (config = {}) => {
 		context: path.resolve(__dirname, "../fixtures"),
 		entry: path.resolve(__dirname, "../helpers/enter.js"),
 		output: {
+			compareBeforeEmit: false,
 			path: path.resolve(__dirname, "../build")
 		},
 		module: {

website/docs/en/config/output.mdx

@@ -168,6 +168,28 @@ module.exports = {
 };
 ```
 
+## output.compareBeforeEmit
+
+<ApiMeta addedVersion={'1.1.0'} />
+
+- **Type:** `boolean`
+- **Default:** `true`
+
+Tells Rspack to check if to be emitted file already exists and has the same content before writing to the output file system.
+
+:::warning
+Rspack will not write output file when file already exists on disk with the same content.
+:::
+
+```js title="rspack.config.js"
+module.exports = {
+  //...
+  output: {
+    compareBeforeEmit: false,
+  },
+};
+```
+
 ## output.crossOriginLoading
 
 - **Type:** `false | 'anonymous' | 'use-credentials'`