perf: avoid extra calculation for hash updates

Author: alexander-akait

.github/workflows/test.yml

@@ -59,3 +59,4 @@ jobs:
       - uses: codecov/codecov-action@v5
         with:
           flags: integration
+          token: ${{ secrets.CODECOV_TOKEN }}

lib/OriginalSource.js

@@ -32,7 +32,9 @@ class OriginalSource extends Source {
 	 */
 	constructor(value, name) {
 		super();
+
 		const isBuffer = Buffer.isBuffer(value);
+
 		/**
 		 * @private
 		 * @type {undefined | string}
@@ -184,7 +186,11 @@ class OriginalSource extends Source {
 	 */
 	updateHash(hash) {
 		hash.update("OriginalSource");
-		hash.update(this.buffer());
+		hash.update(
+			this._valueAsBuffer
+				? /** @type {Buffer} */ (this._valueAsBuffer)
+				: /** @type {string} */ (this._value)
+		);
 		hash.update(this._name || "");
 	}
 }

lib/RawSource.js

@@ -128,7 +128,11 @@ class RawSource extends Source {
 	 */
 	updateHash(hash) {
 		hash.update("RawSource");
-		hash.update(this.buffer());
+		hash.update(
+			this._valueAsBuffer
+				? /** @type {Buffer} */ (this._valueAsBuffer)
+				: /** @type {string} */ (this._valueAsString)
+		);
 	}
 }
 

lib/SourceMapSource.js

@@ -346,8 +346,22 @@ class SourceMapSource extends Source {
 	 */
 	updateHash(hash) {
 		hash.update("SourceMapSource");
-		hash.update(this.buffer());
-		hash.update(this._sourceMapBuffer());
+		hash.update(
+			this._valueAsBuffer
+				? this._valueAsBuffer
+				: typeof this._valueAsString === "string"
+				? this._valueAsString
+				: // Fallback when memory optimization enabled
+				  this.buffer()
+		);
+		hash.update(
+			this._sourceMapAsBuffer
+				? this._sourceMapAsBuffer
+				: typeof this._sourceMapAsString === "string"
+				? this._sourceMapAsString
+				: // Fallback when memory optimization enabled
+				  this._sourceMapBuffer()
+		);
 
 		if (this._hasOriginalSource) {
 			hash.update(

package.json

@@ -35,7 +35,8 @@
     "source-map": "^0.7.3",
     "sourcemap-validator": "^2.1.0",
     "tooling": "webpack/tooling#v1.23.9",
-    "typescript": "^5.3.3"
+    "typescript": "^5.3.3",
+    "webpack": "^5.99.9"
   },
   "files": [
     "lib/",

test/OriginalSource.js

@@ -1,5 +1,10 @@
 "use strict";
 
+const crypto = require("crypto");
+const BatchedHash = require("webpack/lib/util/hash/BatchedHash");
+const createMd4 = require("webpack/lib/util/hash/md4");
+const createXXHash64 = require("webpack/lib/util/hash/xxhash64");
+
 /** @typedef {import("../lib/Source").RawSourceMap} RawSourceMap */
 
 jest.mock("./__mocks__/createMappingsSerializer");
@@ -123,4 +128,26 @@ describe.each([
 			(source.sourceAndMap({ columns: false }).map).mappings
 		).toBe(expected2);
 	});
+
+	for (const hash of [
+		["md5", [crypto.createHash("md5"), crypto.createHash("md5")]],
+		["md4", [new BatchedHash(createMd4()), new BatchedHash(createMd4())]],
+		[
+			"xxhash64",
+			[new BatchedHash(createXXHash64()), new BatchedHash(createXXHash64())]
+		]
+	]) {
+		it(`should have the same hash (${hash[0]}) for string and Buffer`, () => {
+			const sourceString = new OriginalSource("Text", "file.js");
+			const sourceBuffer = new OriginalSource(Buffer.from("Text"), "file.js");
+
+			expect(sourceString.source()).toBe("Text");
+			expect(sourceString.source()).toBe(sourceBuffer.source());
+
+			sourceString.updateHash(hash[1][0]);
+			sourceBuffer.updateHash(hash[1][1]);
+
+			expect(hash[1][0].digest("hex")).toBe(hash[1][1].digest("hex"));
+		});
+	}
 });

test/RawSource.js

@@ -1,6 +1,10 @@
 "use strict";
 
 const RawSource = require("../").RawSource;
+const crypto = require("crypto");
+const BatchedHash = require("webpack/lib/util/hash/BatchedHash");
+const createMd4 = require("webpack/lib/util/hash/md4");
+const createXXHash64 = require("webpack/lib/util/hash/xxhash64");
 const {
 	enableDualStringBufferCaching,
 	enterStringInterningRange,
@@ -29,6 +33,50 @@ describe("RawSource", () => {
 		expect.assertions(3);
 	});
 
+	for (const hash of [
+		["md5", [crypto.createHash("md5"), crypto.createHash("md5")]],
+		["md4", [new BatchedHash(createMd4()), new BatchedHash(createMd4())]],
+		[
+			"xxhash64",
+			[new BatchedHash(createXXHash64()), new BatchedHash(createXXHash64())]
+		]
+	]) {
+		it(`should have the same hash (${hash[0]}) for string and Buffer`, () => {
+			const sourceString = new RawSource("Text");
+			const sourceBuffer = new RawSource(Buffer.from("Text"));
+
+			expect(sourceString.source()).toBe("Text");
+			expect(sourceString.buffer()).toEqual(sourceBuffer.buffer());
+
+			sourceString.updateHash(hash[1][0]);
+			sourceBuffer.updateHash(hash[1][1]);
+
+			expect(hash[1][0].digest("hex")).toBe(hash[1][1].digest("hex"));
+		});
+	}
+
+	for (const hash of [
+		["md5", [crypto.createHash("md5"), crypto.createHash("md5")]],
+		["md4", [new BatchedHash(createMd4()), new BatchedHash(createMd4())]],
+		[
+			"xxhash64",
+			[new BatchedHash(createXXHash64()), new BatchedHash(createXXHash64())]
+		]
+	]) {
+		it(`should have the same hash (${hash[0]}) for string and Buffer (convert to string)`, () => {
+			const sourceString = new RawSource("Text", true);
+			const sourceBuffer = new RawSource(Buffer.from("Text"), true);
+
+			expect(sourceString.source()).toBe("Text");
+			expect(sourceString.buffer()).toEqual(sourceBuffer.buffer());
+
+			sourceString.updateHash(hash[1][0]);
+			sourceBuffer.updateHash(hash[1][1]);
+
+			expect(hash[1][0].digest("hex")).toBe(hash[1][1].digest("hex"));
+		});
+	}
+
 	describe("memory optimizations are enabled", () => {
 		beforeEach(() => {
 			disableDualStringBufferCaching();

test/SourceMapSource.js

@@ -21,6 +21,10 @@ const {
 	exitStringInterningRange,
 	disableDualStringBufferCaching
 } = require("../lib/helpers/stringBufferUtils");
+const crypto = require("crypto");
+const BatchedHash = require("webpack/lib/util/hash/BatchedHash");
+const createMd4 = require("webpack/lib/util/hash/md4");
+const createXXHash64 = require("webpack/lib/util/hash/xxhash64");
 
 describe.each([
 	{
@@ -508,4 +512,46 @@ describe.each([
 		const buffer2 = sourceMapSource.buffer();
 		expect(buffer2).toBe(buffer1);
 	});
+
+	for (const hash of [
+		["md5", [crypto.createHash("md5"), crypto.createHash("md5")]],
+		["md4", [new BatchedHash(createMd4()), new BatchedHash(createMd4())]],
+		[
+			"xxhash64",
+			[new BatchedHash(createXXHash64()), new BatchedHash(createXXHash64())]
+		]
+	]) {
+		it(`should have the same hash (${hash[0]}) for string and Buffer`, () => {
+			const sourceString = new SourceMapSource("hello world\n", "hello.txt", {
+				version: 3,
+				sources: ["hello-source.txt"],
+				sourcesContent: ["hello world\n"],
+				mappings: "AAAA",
+				names: [],
+				file: ""
+			});
+			const sourceBuffer = new SourceMapSource(
+				Buffer.from("hello world\n"),
+				"hello.txt",
+				Buffer.from(
+					JSON.stringify({
+						version: 3,
+						sources: ["hello-source.txt"],
+						sourcesContent: ["hello world\n"],
+						mappings: "AAAA",
+						names: [],
+						file: ""
+					})
+				)
+			);
+
+			expect(sourceString.source()).toBe("hello world\n");
+			expect(sourceString.buffer()).toEqual(sourceBuffer.buffer());
+
+			sourceString.updateHash(hash[1][0]);
+			sourceBuffer.updateHash(hash[1][1]);
+
+			expect(hash[1][0].digest("hex")).toBe(hash[1][1].digest("hex"));
+		});
+	}
 });