Use an AsyncGenerator for the public API (#36)

Author: kristoferbaxter

.prettierrc

@@ -1,5 +1,5 @@
 {
-  "printWidth": 150,
+  "printWidth": 120,
   "trailingComma": "all",
   "parser": "typescript",
   "singleQuote": true

package.json

@@ -4,7 +4,7 @@
   "description": "Audit the filesize of items specified in package.json.",
   "author": "Kristofer Baxter",
   "license": "Apache-2.0",
-  "main": "dist/filesize",
+  "main": "dist/api.js",
   "module": "dist/api.mjs",
   "files": [
     "dist"
@@ -88,5 +88,8 @@
       "pre-push": "yarn npm-run-all clean build test",
       "pre-commit": "lint-staged"
     }
+  },
+  "publishConfig": {
+    "access": "public"
   }
 }

src/api.ts

@@ -19,7 +19,10 @@ import Config from './validation/Config';
 import { Context, SizeMap } from './validation/Condition';
 import compress from './compress';
 
-export async function report(projectPath: string): Promise<[SizeMap, SizeMap]> {
+export async function* report(
+  projectPath: string,
+  fileModifier: ((contents: string) => string) | null,
+): AsyncGenerator<[SizeMap, SizeMap]> {
   const conditions = [Project, Config];
   let context: Context = {
     projectPath,
@@ -31,6 +34,8 @@ export async function report(projectPath: string): Promise<[SizeMap, SizeMap]> {
     compressed: new Map(),
     // Stores the basis of comparison.
     comparison: new Map(),
+    fileModifier,
+    fileContents: new Map(),
   };
 
   for (const condition of conditions) {
@@ -40,6 +45,11 @@ export async function report(projectPath: string): Promise<[SizeMap, SizeMap]> {
     }
   }
 
-  await compress(context);
+  const compressResults = compress(context, false);
+  let nextResult = await compressResults.next();
+  while (!nextResult.done) {
+    yield [context.compressed, context.comparison];
+    nextResult = await compressResults.next();
+  }
   return [context.compressed, context.comparison];
 }

src/compress.ts

@@ -48,7 +48,13 @@ interface CompressionItem {
  * @param error Error from compressing an Item
  * @param size actual size for this comparison
  */
-function store(report: Report | null, context: Context, item: CompressionItem, error: Error | null, size: number): boolean {
+function store(
+  report: Report | null,
+  context: Context,
+  item: CompressionItem,
+  error: Error | null,
+  size: number,
+): boolean {
   if (error !== null) {
     LogError(`Could not compress '${item.path}' with '${item.compression}'.`);
     return false;
@@ -70,46 +76,64 @@ function store(report: Report | null, context: Context, item: CompressionItem, e
 }
 
 /**
- * Given a context, compress all Items within splitting work eagly per cpu core to achieve some concurrency.
- * @param context Finalized Valid Context from Configuration
+ * Compress an Item and report status to the console.
+ * @param item Configuration for an Item.
  */
-export default async function compress(context: Context): Promise<boolean> {
-  /**
-   * Compress an Item and report status to the console.
-   * @param item Configuration for an Item.
-   */
-  async function compressor(item: CompressionItem): Promise<boolean> {
-    const contents = await readFile(item.path);
-    if (contents) {
-      const buffer = Buffer.from(contents, 'utf8');
+async function compressor(report: Report | null, context: Context, item: CompressionItem): Promise<boolean> {
+  const contents = context.fileContents.get(item.path);
+  if (contents) {
+    const buffer = Buffer.from(contents, 'utf8');
 
-      switch (item.compression) {
-        case 'brotli':
-          return new Promise(resolve =>
-            brotliCompress(buffer, BROTLI_OPTIONS, (error: Error | null, result: Buffer) =>
-              resolve(store(report, context, item, error, result.byteLength)),
-            ),
-          );
-        case 'gzip':
-          return new Promise(resolve =>
-            gzip(buffer, GZIP_OPTIONS, (error: Error | null, result: Buffer) => resolve(store(report, context, item, error, result.byteLength))),
-          );
-        default:
-          return store(report, context, item, null, buffer.byteLength);
-      }
+    switch (item.compression) {
+      case 'brotli':
+        return new Promise(resolve =>
+          brotliCompress(buffer, BROTLI_OPTIONS, (error: Error | null, result: Buffer) =>
+            resolve(store(report, context, item, error, result.byteLength)),
+          ),
+        );
+      case 'gzip':
+        return new Promise(resolve =>
+          gzip(buffer, GZIP_OPTIONS, (error: Error | null, result: Buffer) =>
+            resolve(store(report, context, item, error, result.byteLength)),
+          ),
+        );
+      default:
+        return store(report, context, item, null, buffer.byteLength);
     }
+  }
 
-    return false;
+  return false;
+}
+
+/**
+ * Store the original content so it isn't retrieved from FileSystem for each compression.
+ * @param context
+ * @param path
+ */
+async function storeOriginalFileContents(context: Context, path: string): Promise<void> {
+  if (!context.fileContents.has(path)) {
+    let content = await readFile(path);
+    if (context.fileModifier !== null && content !== null) {
+      content = context.fileModifier(content);
+    }
+    context.fileContents.set(path, content || '');
   }
+}
 
-  let report: Report | null = null;
+/**
+ * Find all items to compress, and store them for future compression.
+ * @param context
+ * @param findDefaultSize
+ */
+async function findItemsToCompress(context: Context, findDefaultSize: boolean): Promise<Array<CompressionItem>> {
   const toCompress: Array<CompressionItem> = [];
   for (const [path, sizeMapValue] of context.compressed) {
     for (let iterator: number = 0; iterator < OrderedCompressionValues.length; iterator++) {
       const compression: Compression = OrderedCompressionValues[iterator] as Compression;
       const [size, maxSize] = sizeMapValue[iterator];
-      if (compression === 'none') {
-        await compressor({ path, compression, maxSize });
+      await storeOriginalFileContents(context, path);
+      if (findDefaultSize && compression === 'none') {
+        await compressor(null, context, { path, compression, maxSize });
       }
       if (size !== undefined) {
         toCompress.push({
@@ -121,18 +145,35 @@ export default async function compress(context: Context): Promise<boolean> {
     }
   }
 
-  report = stdout.isTTY && toCompress.length < 30 ? new TTYReport(context) : new Report(context);
+  return toCompress;
+}
+
+/**
+ * Given a context, compress all Items within splitting work eagly per cpu core to achieve some concurrency.
+ * @param context Finalized Valid Context from Configuration
+ */
+export default async function* compress(context: Context, outputReport: boolean): AsyncGenerator<boolean, boolean> {
+  const toCompress: Array<CompressionItem> = await findItemsToCompress(context, true);
+  const report: Report | null = outputReport
+    ? null
+    : stdout.isTTY && toCompress.length < 30
+    ? new TTYReport(context)
+    : new Report(context);
   let success: boolean = true;
+
   for (let iterator: number = 0; iterator < toCompress.length; iterator += COMPRESSION_CONCURRENCY) {
     if (iterator === 0) {
-      report.update(context);
+      report?.update(context);
     }
-    let itemsSuccessful = await Promise.all(toCompress.slice(iterator, iterator + COMPRESSION_CONCURRENCY).map(compressor));
+    let itemsSuccessful = await Promise.all(
+      toCompress.slice(iterator, iterator + COMPRESSION_CONCURRENCY).map(item => compressor(report, context, item)),
+    );
     if (itemsSuccessful.includes(false)) {
       success = false;
     }
+    yield success;
   }
 
-  report.end();
+  report?.end();
   return success;
 }

src/index.ts

@@ -43,6 +43,8 @@ const args = mri(process.argv.slice(2), {
     compressed: new Map(),
     // Stores the basis of comparison.
     comparison: new Map(),
+    fileModifier: null,
+    fileContents: new Map(),
   };
 
   let errorOccured: boolean = false;
@@ -56,7 +58,17 @@ const args = mri(process.argv.slice(2), {
   }
 
   if (!errorOccured) {
-    if (!(await compress(context))) {
+    const compressResults = compress(context, false);
+    let successful: boolean = true;
+    let nextResult: IteratorResult<boolean, boolean> = await compressResults.next();
+    while (!nextResult.done) {
+      if (!nextResult.value) {
+        successful = false;
+      }
+      nextResult = await compressResults.next();
+    }
+
+    if (!successful) {
       shutdown(6);
     }
   }

src/validation/Condition.ts

@@ -47,6 +47,8 @@ export const SizeMapValueIndex = {
 };
 export type SizeMap = Map<path, SizeMapValue>;
 
+export type FileContentsMap = Map<path, string>;
+
 export interface Context {
   projectPath: string;
   packagePath: string;
@@ -57,4 +59,8 @@ export interface Context {
   compressed: SizeMap;
   // Stores the basis of comparison.
   comparison: SizeMap;
+  // Allows the API to specify a method that alters content before analysis.
+  fileModifier: ((contents: string) => string) | null;
+  // Stores the contents of files, to avoid reading from disk per compression type.
+  fileContents: FileContentsMap;
 }

test/config-validation/config-validation.test.ts

@@ -27,6 +27,8 @@ test('missing package.json should fail', async t => {
     compressed: new Map(),
     comparison: new Map(),
     silent: false,
+    fileModifier: null,
+    fileContents: new Map(),
   };
   const message = await Config(context)();
 
@@ -42,6 +44,8 @@ test('unparseable package.json should fail', async t => {
     compressed: new Map(),
     comparison: new Map(),
     silent: false,
+    fileModifier: null,
+    fileContents: new Map(),
   };
   const message = await Config(context)();
 
@@ -57,6 +61,8 @@ test("missing 'filesize' key from package.json should fail", async t => {
     compressed: new Map(),
     comparison: new Map(),
     silent: false,
+    fileModifier: null,
+    fileContents: new Map(),
   };
   const message = await Config(context)();
 
@@ -72,6 +78,8 @@ test("missing path from item in 'filesize' should fail", async t => {
     compressed: new Map(),
     comparison: new Map(),
     silent: false,
+    fileModifier: null,
+    fileContents: new Map(),
   };
   const message = await Config(context)();
 
@@ -87,6 +95,8 @@ test("missing maxSize from item in 'filesize' should fail", async t => {
     compressed: new Map(),
     comparison: new Map(),
     silent: false,
+    fileModifier: null,
+    fileContents: new Map(),
   };
   const message = await Config(context)();
 
@@ -102,6 +112,8 @@ test("missing compression from item in 'filesize' should fail", async t => {
     compressed: new Map(),
     comparison: new Map(),
     silent: false,
+    fileModifier: null,
+    fileContents: new Map(),
   };
   const message = await Config(context)();
 

test/config-validation/track.test.ts

@@ -29,6 +29,8 @@ test('including trackable items should succeed', async t => {
     compressed: new Map(),
     comparison: new Map(),
     silent: false,
+    fileModifier: null,
+    fileContents: new Map(),
   };
   const message = await Config(context)();
 
@@ -44,6 +46,12 @@ test('trackable items uses glob to find files', async t => {
   const expected: SizeMap = new Map();
   expected.set(resolve('test/config-validation/fixtures/track-standalone/index.js'), sizes);
 
-  const results = await report('test/config-validation/fixtures/track-standalone');
-  t.deepEqual(results[0], expected);
+  const values = report('test/config-validation/fixtures/track-standalone', null);
+  let next = await values.next();
+  let results: SizeMap | undefined = undefined;
+  while (!next.done) {
+    results = next.value[0];
+    next = await values.next();
+  }
+  t.deepEqual(results, expected);
 });