Update CLI output format

Author: kristoferbaxter

compress.ts

@@ -14,12 +14,11 @@
  * limitations under the License.
  */
 
-import { Context, ItemConfig, Compression } from './validation/Condition';
+import { Context, ItemConfig, Compression, OrderedCompressionMap, CompressionMap } from './validation/Condition';
 import { cpus } from 'os';
-import bytes from 'bytes';
 import { constants as brotliConstants, brotliCompress, gzip, ZlibOptions } from 'zlib';
 import { readFile } from './fs';
-import { LogError, LogPassingOutput, LogFailingOutput } from './log';
+import { LogError, LogReport } from './log';
 
 const COMPRESSION_CONCURRENCY = cpus().length;
 const BROTLI_OPTIONS = {
@@ -32,26 +31,37 @@ const BROTLI_OPTIONS = {
 const GZIP_OPTIONS: ZlibOptions = {
   level: 9,
 };
+const reported: Map<ItemConfig['path'], CompressionMap> = new Map();
+
+/**
+ * Pre-populate the report map
+ * @param configurations
+ */
+function initReport(configurations: Context['config']) {
+  for (const config of configurations) {
+    if (!reported.get(config.originalPath)) {
+      reported.set(config.originalPath, new Map(OrderedCompressionMap));
+    }
+  }
+}
 
 /**
  * Use the given configuration and actual size to report item filesize.
  * @param item Configuration for an Item
  * @param error Error from compressing an Item
  * @param size actual size for this comparison
  */
-function report(item: ItemConfig, error: Error | null, size: number): boolean {
+function store(item: ItemConfig, error: Error | null, size: number): boolean {
   if (error !== null) {
     LogError(`Could not compress '${item.path}' with '${item.compression}'.`);
     return false;
   }
 
-  if (item.maxSize >= size) {
-    LogPassingOutput(`${item.path} ${bytes(size)} <= ${bytes(item.maxSize)}`);
-    return true;
+  let compressionMap: CompressionMap | undefined;
+  if ((compressionMap = reported.get(item.originalPath))) {
+    compressionMap.set(item.compression, [size, item.maxSize]);
   }
-
-  LogFailingOutput(`${item.path} ${bytes(size)} > ${bytes(item.maxSize)}`);
-  return false;
+  return size < item.maxSize;
 }
 
 /**
@@ -66,15 +76,15 @@ async function compressor(item: ItemConfig): Promise<boolean> {
     switch (item.compression) {
       case Compression.BROTLI:
         return new Promise(resolve =>
-          brotliCompress(buffer, BROTLI_OPTIONS, (error: Error | null, result: Buffer) => resolve(report(item, error, result.byteLength))),
+          brotliCompress(buffer, BROTLI_OPTIONS, (error: Error | null, result: Buffer) => resolve(store(item, error, result.byteLength))),
         );
       case Compression.GZIP:
         return new Promise(resolve =>
-          gzip(buffer, GZIP_OPTIONS, (error: Error | null, result: Buffer) => resolve(report(item, error, result.byteLength))),
+          gzip(buffer, GZIP_OPTIONS, (error: Error | null, result: Buffer) => resolve(store(item, error, result.byteLength))),
         );
       case Compression.NONE:
       default:
-        return report(item, null, buffer.byteLength);
+        return store(item, null, buffer.byteLength);
     }
   }
 
@@ -86,6 +96,8 @@ async function compressor(item: ItemConfig): Promise<boolean> {
  * @param context Finalized Valid Context from Configuration
  */
 export default async function compress(context: Context): Promise<boolean> {
+  initReport(context.config);
+
   let success: boolean = true;
   for (let iterator: number = 0; iterator < context.config.length; iterator += COMPRESSION_CONCURRENCY) {
     let itemsSuccessful = await Promise.all(context.config.slice(iterator, iterator + COMPRESSION_CONCURRENCY).map(compressor));
@@ -94,5 +106,6 @@ export default async function compress(context: Context): Promise<boolean> {
     }
   }
 
+  LogReport(reported);
   return success;
 }

log.ts

@@ -15,10 +15,15 @@
  */
 
 const kleur = require('kleur');
+import bytes from 'bytes';
+import { ItemConfig, CompressionMap } from './validation/Condition';
 
 // Disable output colors for test runs.
 kleur.enabled = !('AVA_PATH' in process.env);
 
+// Aliases to colors used.
+const { red, grey, green, bold } = kleur;
+
 /**
  * Format output as an error message.
  * @param output
@@ -36,17 +41,56 @@ export function LogError(output: string): void {
 }
 
 /**
- * Display output as a success message on the console.
- * @param output
+ * Format size into more human readable string.
+ * @param size
  */
-export function LogPassingOutput(output: string): void {
-  console.log(`${kleur.green('success')} ${kleur.white(output)}`);
+function prettyBytes(size: number): string {
+  return bytes(size, { unit: 'kb', fixedDecimals: true, unitSeparator: ' ' });
 }
 
 /**
- * Display output as a failure message on the console.
- * @param output
+ * Given a compression type, format it to a human readable file extension.
+ * @param compression
+ */
+function compressedExtension(compression: string): string {
+  if (compression === 'none') {
+    return ''.padEnd(3);
+  }
+  return '.' + compression.substring(0, 2);
+}
+
+/**
+ * Display report to the console.
+ * @param report
  */
-export function LogFailingOutput(output: string): void {
-  console.log(`${kleur.red('failure')} ${kleur.white(output)}`);
+export function LogReport(report: Map<ItemConfig['path'], CompressionMap>) {
+  let success: number = 0;
+  let failure: number = 0;
+
+  if ([...report.keys()].length > 0) {
+    console.log(bold('\nFilesize Report'));
+    for (const [originalPath, values] of report) {
+      console.log(grey(`\npath: ${originalPath}`));
+      for (const [compression, compressionResults] of values) {
+        const [size, maxSize] = compressionResults;
+        const compressedPath = originalPath + grey(compressedExtension(compression));
+        if (size === null || maxSize === null) {
+          continue;
+        } else if (size < maxSize) {
+          success++;
+          console.log(`  ✔️  ${compressedPath} ${prettyBytes(size)} ${green('<')} ${prettyBytes(maxSize)}`);
+        } else {
+          failure++;
+          console.log(`  ❌ ${compressedPath} ${prettyBytes(size)} ${red('>')} ${prettyBytes(maxSize)}`);
+        }
+      }
+    }
+    if (success > 0 || failure > 0) {
+      console.log('\n  ' + green(success + ` ${success === 1 ? 'check' : 'checks'} passed`));
+      console.log('  ' + red(failure + ` ${failure === 1 ? 'check' : 'checks'} failed`) + (failure === 0 ? ' 🎉' : ''));
+    }
+    console.log();
+  } else {
+    MakeError('No report available.');
+  }
 }

package.json

@@ -30,6 +30,7 @@
     "mri": "1.1.4"
   },
   "devDependencies": {
+    "@ampproject/rollup-plugin-closure-compiler": "0.20.0",
     "@rollup/plugin-commonjs": "11.0.1",
     "@rollup/plugin-node-resolve": "7.0.0",
     "@rollup/plugin-typescript": "2.1.0",
@@ -57,17 +58,22 @@
     {
       "path": "./dist/filesize",
       "compression": "brotli",
-      "maxSize": "4.5 kB"
+      "maxSize": "3.5 kB"
     },
     {
       "path": "./dist/filesize",
       "compression": "gzip",
-      "maxSize": "6 kB"
+      "maxSize": "3.6 kB"
     },
     {
       "path": "./dist/filesize",
       "compression": "none",
       "maxSize": "20 kB"
+    },
+    {
+      "path": "./dist/index.js",
+      "compression": "brotli",
+      "maxSize": "4 kB"
     }
   ],
   "ava": {

rollup.config.js

@@ -17,6 +17,7 @@
 import resolve from '@rollup/plugin-node-resolve';
 import typescript from '@rollup/plugin-typescript';
 import commonjs from '@rollup/plugin-commonjs';
+import compiler from '@ampproject/rollup-plugin-closure-compiler';
 import MagicString from 'magic-string';
 
 function makeExecutable() {
@@ -32,6 +33,15 @@ function makeExecutable() {
   };
 }
 
+const external = ['os', 'zlib', 'path', 'fs'];
+const plugins = executable => [
+  resolve({ preferBuiltins: true }),
+  commonjs({ include: 'node_modules/**' }),
+  typescript({ include: '**/*.ts' }),
+  compiler(),
+  executable ? makeExecutable() : null,
+];
+
 export default [
   {
     input: 'index.ts',
@@ -40,8 +50,8 @@ export default [
       format: 'cjs',
       sourcemap: true,
     },
-    external: ['os', 'zlib', 'path', 'fs'],
-    plugins: [resolve({ preferBuiltins: true }), commonjs({ include: 'node_modules/**' }), typescript({ include: '**/*.ts' }), makeExecutable()],
+    external,
+    plugins: plugins(true),
   },
   {
     input: 'index.ts',
@@ -50,7 +60,7 @@ export default [
       format: 'cjs',
       sourcemap: true,
     },
-    external: ['os', 'zlib', 'path', 'fs'],
-    plugins: [resolve({ preferBuiltins: true }), commonjs({ include: 'node_modules/**' }), typescript({ include: '**/*.ts' })],
+    external,
+    plugins: plugins(false),
   },
 ];

validation/Condition.ts

@@ -17,12 +17,19 @@
 export type ValidationResponse = [boolean, string | null];
 
 export enum Compression {
-  NONE = '',
+  NONE = 'none',
   GZIP = 'gzip',
   BROTLI = 'brotli',
 }
+const OrderedCompressionValues = [Compression.BROTLI, Compression.GZIP, Compression.NONE];
+
+export type CompressionMapValue = [number | null, number | null];
+export type CompressionMap = Map<string, CompressionMapValue>;
+export const OrderedCompressionMap: CompressionMap = new Map(OrderedCompressionValues.map(value => [value, [null, null]]));
+export const CompressionDisplayLength = OrderedCompressionValues.sort((a, b) => b.length - a.length)[0].length;
 
 export interface ItemConfig {
+  originalPath: string;
   path: string;
   compression: string;
   maxSize: number;

validation/File.ts

@@ -24,7 +24,7 @@ const READABLE_KEY_NAMES = ['path', 'compression', 'maxSize'];
 
 /**
  * Format input string to a known Compression Enum Value.
- * @param fsValue 
+ * @param fsValue
  */
 function compressionValue(fsValue: string): { compression: Compression; error: string | null } {
   switch (fsValue.toLowerCase()) {
@@ -42,7 +42,7 @@ function compressionValue(fsValue: string): { compression: Compression; error: s
 
 /**
  * Ensure a File config entry contains all the necessary keys.
- * @param bundle 
+ * @param bundle
  */
 export function FileConfigContainsKeys(fileConfig: { [key: string]: string }): { success: boolean; invalid: number | null } {
   const mandatoryValues = READABLE_KEY_NAMES.map(key => fileConfig[key]);
@@ -53,8 +53,8 @@ export function FileConfigContainsKeys(fileConfig: { [key: string]: string }): {
 
 /**
  * Validate a File config contains necessary keys and valid values.
- * @param fileConfig 
- * @param index 
+ * @param fileConfig
+ * @param index
  */
 export default async function ValidateFileConfig(
   fileConfig: { path: string; compression: string; maxSize: string },
@@ -71,13 +71,14 @@ export default async function ValidateFileConfig(
     return {
       success: false,
       config: null,
-      error:
-        MakeError(`${fileConfig.path ? `'${fileConfig.path}'` : `#${index}`} configuration is invalid. ${valueErrorMapping[invalidValue]}`),    };
+      error: MakeError(`${fileConfig.path ? `'${fileConfig.path}'` : `#${index}`} configuration is invalid. ${valueErrorMapping[invalidValue]}`),
+    };
   }
 
   return {
     success: true,
     config: {
+      originalPath: fileConfig.path,
       path,
       compression,
       maxSize,