Add support for also displaying Brotli compressed size (#47)

Co-authored-by: Sindre Sorhus <[email protected]>

Author: jonatanlinden

index.js

@@ -6,22 +6,45 @@ const chalk = require('chalk');
 const prettyBytes = require('pretty-bytes');
 const StreamCounter = require('stream-counter');
 const gzipSize = require('gzip-size');
+const brotliSize = require('brotli-size');
 
-module.exports = options => {
+function hasSize(sizes) {
+	return [...sizes.values()].some(size => size > 0);
+}
+
+function promisify(stream, property, event = 'end') {
+	return new Promise((resolve, reject) => {
+		stream.on(event, () => resolve(stream[property]))
+			.on('error', error => reject(error));
+	});
+}
+
+module.exports = (options = {}) => {
 	options = {
 		pretty: true,
 		showTotal: true,
+		uncompressed: options.uncompressed || !(options.gzip || options.brotli),
 		...options
 	};
 
-	let totalSize = 0;
 	let fileCount = 0;
+	const totalSize = new Map();
 
-	function log(what, size) {
+	const description = new Map([
+		['uncompressed', ''],
+		['gzip', ' (gzipped)'],
+		['brotli', ' (brotli)']
+	]);
+
+	function log(what, sizes) {
 		let {title} = options;
 		title = title ? chalk.cyan(title) + ' ' : '';
-		size = options.pretty ? prettyBytes(size) : (size + ' B');
-		fancyLog(title + what + ' ' + chalk.magenta(size) + (options.gzip ? chalk.gray(' (gzipped)') : ''));
+		const sizeStrings = [...sizes].map(([key, size]) => {
+			size = options.pretty ? prettyBytes(size) : (size + ' B');
+			return chalk.magenta(size) + chalk.gray(description.get(key));
+		});
+
+		fancyLog(title + what + ' ' + sizeStrings.join(chalk.magenta(', ')));
 	}
 
 	return through.obj((file, encoding, callback) => {
@@ -30,56 +53,67 @@ module.exports = options => {
 			return;
 		}
 
-		const finish = (error, size) => {
+		const finish = (error, sizes) => {
 			if (error) {
 				callback(new PluginError('gulp-size', error));
 				return;
 			}
 
-			totalSize += size;
+			for (const [key, size] of sizes) {
+				totalSize.set(key, size + (totalSize.get(key) || 0));
+			}
 
-			if (options.showFiles === true && size > 0) {
-				log(chalk.blue(file.relative), size);
+			if (options.showFiles === true && hasSize(sizes)) {
+				log(chalk.blue(file.relative), sizes);
 			}
 
 			fileCount++;
 			callback(null, file);
 		};
 
+		const selectedSizes = new Map();
 		if (file.isStream()) {
+			if (options.uncompressed) {
+				selectedSizes.set('uncompressed', promisify(file.contents.pipe(new StreamCounter()), 'bytes', 'finish'));
+			}
+
 			if (options.gzip) {
-				file.contents.pipe(gzipSize.stream())
-					.on('error', finish)
-					.on('end', function () {
-						finish(null, this.gzipSize);
-					});
-			} else {
-				file.contents.pipe(new StreamCounter())
-					.on('error', finish)
-					.on('finish', function () {
-						finish(null, this.bytes);
-					});
+				selectedSizes.set('gzip', promisify(file.contents.pipe(gzipSize.stream()), 'gzipSize'));
 			}
 
-			return;
+			if (options.brotli) {
+				selectedSizes.set('brotli', promisify(file.contents.pipe(brotliSize.stream()), 'brotliSize'));
+			}
 		}
 
-		if (options.gzip) {
-			(async () => {
-				try {
-					finish(null, await gzipSize(file.contents));
-				} catch (error) {
-					finish(error);
-				}
-			})();
-		} else {
-			finish(null, file.contents.length);
+		if (file.isBuffer()) {
+			if (options.uncompressed) {
+				selectedSizes.set('uncompressed', file.contents.length);
+			}
+
+			if (options.gzip) {
+				selectedSizes.set('gzip', gzipSize(file.contents));
+			}
+
+			if (options.brotli) {
+				selectedSizes.set('brotli', brotliSize.default(file.contents));
+			}
 		}
-	}, function (callback) {
-		this.size = totalSize;
-		this.prettySize = prettyBytes(totalSize);
 
-		if (!(fileCount === 1 && options.showFiles) && totalSize > 0 && fileCount > 0 && options.showTotal) {
+		(async () => {
+			try {
+				// We want to keep the names
+				const sizes = await Promise.all([...selectedSizes].map(async ([key, size]) => [key, await size]));
+
+				finish(null, new Map(sizes));
+			} catch (error) {
+				finish(error);
+			}
+		})();
+	}, function (callback) {
+		this.size = totalSize.values().next().value;
+		this.prettySize = prettyBytes(this.size);
+		if (!(fileCount === 1 && options.showFiles) && hasSize(totalSize) && fileCount > 0 && options.showTotal) {
 			log(chalk.green('all files'), totalSize);
 		}
 

package.json

@@ -27,9 +27,11 @@
 		"measure",
 		"inspect",
 		"debug",
-		"gzip"
+		"gzip",
+		"brotli"
 	],
 	"dependencies": {
+		"brotli-size": "^4.0.0",
 		"chalk": "^2.3.0",
 		"fancy-log": "^1.3.2",
 		"gzip-size": "^5.1.1",

readme.md

@@ -48,7 +48,21 @@ Give it a title so it's possible to distinguish the output of multiple instances
 Type: `boolean`<br>
 Default: `false`
 
-Displays the gzipped size instead.
+Displays the gzipped size.
+
+##### brotli
+
+Type: `boolean`<br>
+Default: `false`
+
+Displays the brotli compressed size.
+
+##### uncompressed
+
+Type: `boolean`<br>
+Default: `false` if either of gzip or brotli is `true`, otherwise `true`
+
+Displays the uncompressed size.
 
 ##### pretty
 

test.js

@@ -92,6 +92,51 @@ it('should have `gzip` option', callback => {
 	stream.end();
 });
 
+it('should have `brotli` option', callback => {
+	const out = process.stdout.write.bind(process.stdout);
+	const stream = size({brotli: true});
+
+	process.stdout.write = string => {
+		out(string);
+
+		if (/brotli/.test(string)) {
+			assert(true);
+			process.stdout.write = out;
+			callback();
+		}
+	};
+
+	stream.write(new Vinyl({
+		path: path.join(__dirname, 'fixture.js'),
+		contents: Buffer.from('unicorn world')
+	}));
+
+	stream.end();
+});
+
+it('should show `uncompressed`, `gzip` and `brotli` size', callback => {
+	const out = process.stdout.write.bind(process.stdout);
+	const stream = size({uncompressed: true, gzip: true, brotli: true});
+
+	process.stdout.write = string => {
+		out(string);
+
+		// Name of compressions protocols and three numbers
+		if (/gzipped.*brotli/.test(string) && /(?:.*\b\d+){3}/.test(string)) {
+			assert(true);
+			process.stdout.write = out;
+			callback();
+		}
+	};
+
+	stream.write(new Vinyl({
+		path: path.join(__dirname, 'fixture.js'),
+		contents: Buffer.from('unicorn world')
+	}));
+
+	stream.end();
+});
+
 it('should not show prettified size when `pretty` option is false', callback => {
 	const out = process.stdout.write.bind(process.stdout);
 	const stream = size({pretty: false});
@@ -170,3 +215,23 @@ it('should handle stream contents with `gzip` option', callback => {
 
 	stream.end();
 });
+
+it('should handle stream contents with `brotli` option', callback => {
+	const contents = through();
+	const stream = size({brotli: true});
+
+	stream.on('finish', () => {
+		assert.strictEqual(stream.size, 17);
+		assert.strictEqual(stream.prettySize, '17 B');
+		callback();
+	});
+
+	stream.write(new Vinyl({
+		path: path.join(__dirname, 'fixture.js'),
+		contents
+	}));
+
+	contents.end(Buffer.from('unicorn world'));
+
+	stream.end();
+});