fix: Avoid Promise.all() because of possible race conditions.

Author: chriseppstein

packages/@css-blocks/core/src/Analyzer/Analysis.ts

@@ -14,6 +14,7 @@ import {
 import { ObjectDictionary, objectValues } from "@opticss/util";
 import { IdentGenerator } from "opticss";
 
+import { allDone } from "../util";
 import { BlockFactory } from "../BlockParser";
 import { DEFAULT_EXPORT } from "../BlockSyntax";
 import { Block, Style } from "../BlockTree";
@@ -354,7 +355,7 @@ export class Analysis<K extends keyof TemplateTypes> {
       });
       blockPromises.push(promise);
     });
-    let values = await Promise.all(blockPromises);
+    let values = await allDone(blockPromises);
 
     // Create a temporary block so we can take advantage of `Block.lookup`
     // to easily resolve all BlockPaths referenced in the serialized analysis.

packages/@css-blocks/core/src/BlockParser/features/export-blocks.ts

@@ -3,6 +3,7 @@ import { postcss } from "opticss";
 import { BLOCK_EXPORT, CLASS_NAME_IDENT, DEFAULT_EXPORT, RESERVED_BLOCK_NAMES } from "../../BlockSyntax";
 import { Block } from "../../BlockTree";
 import * as errors from "../../errors";
+import { allDone } from "../../util";
 import { sourceRange } from "../../SourceLocation";
 import { BlockFactory } from "../index";
 import { parseBlockNames, stripQuotes } from "../utils";
@@ -114,6 +115,6 @@ export async function exportBlocks(block: Block, factory: BlockFactory, file: st
   }
 
   // After all export promises have resolved, resolve the decorated Block.
-  await Promise.all(exportPromises);
+  await allDone(exportPromises);
   return block;
 }

packages/@css-blocks/core/src/BlockParser/features/import-blocks.ts

@@ -5,6 +5,7 @@ import { BLOCK_IMPORT, CLASS_NAME_IDENT, DEFAULT_EXPORT, isBlockNameReserved } f
 import { Block } from "../../BlockTree";
 import * as errors from "../../errors";
 import { sourceRange } from "../../SourceLocation";
+import { allDone } from "../../util";
 import { BlockFactory } from "../index";
 import { parseBlockNames, stripQuotes } from "../utils";
 
@@ -96,9 +97,9 @@ export async function importBlocks(block: Block, factory: BlockFactory, file: st
 
     // When all import promises have resolved, save the block references and
     // resolve.
-    let results;
+    let results: Array<[string, string, postcss.AtRule, Block]>;
     try {
-      results = await Promise.all(namedBlockReferences);
+      results = await allDone(namedBlockReferences);
       let localNames: ObjectDictionary<string> = {};
       results.forEach(([localName, importPath, atRule, otherBlock]) => {
         if (localNames[localName]) {

packages/@css-blocks/core/src/index.ts

@@ -15,3 +15,4 @@ export * from "./importing";
 export * from "./Analyzer";
 export * from "./TemplateRewriter";
 export * from "./configuration";
+export * from "./util";

packages/@css-blocks/core/src/util/allDone.ts

@@ -0,0 +1,27 @@
+/**
+ * This behaves like Promise.all() but it doesn't resolve or reject until
+ * all the work is done.
+ *
+ * Note: if multiple promises reject, the error returned is based on the order
+ * of the promises passed in (the reason from promise with the lowest index is
+ * returned).
+ * @template T What each promise returns.
+ * @param promises The promises to wait for.
+ * @returns An array of results or rejects with the first error that it encounters.
+ */
+export async function allDone<T>(promises: Array<Promise<T>>): Promise<Array<T>> {
+  let results = new Array<T>();
+  let firstError = null;
+  for (let p of promises) {
+    try {
+      results.push(await p);
+    } catch (e) {
+      if (!firstError) firstError = e;
+    }
+  }
+  if (firstError) {
+    throw firstError;
+  } else {
+    return results;
+  }
+}

packages/@css-blocks/core/src/util/index.ts

@@ -0,0 +1,2 @@
+export { allDone } from "./allDone";
+export { unionInto } from "./unionInto";

packages/@css-blocks/glimmer/src/Analyzer.ts

@@ -61,7 +61,6 @@ export class GlimmerAnalyzer extends Analyzer<TEMPLATE_TYPE> {
 
   async analyze(dir: string, componentNames: string[]): Promise<GlimmerAnalyzer> {
     let components = new Set<string>(componentNames);
-    let analysisPromises: Promise<GlimmerAnalysis>[] = [];
     this.debug(`Analyzing all templates starting with: ${componentNames}`);
 
     for (let component of components) {
@@ -73,10 +72,9 @@ export class GlimmerAnalyzer extends Analyzer<TEMPLATE_TYPE> {
     this.debug(`Analyzing all components: ${[...components].join(", ")}`);
 
     for (let component of components) {
-      analysisPromises.push(this.analyzeTemplate(dir, component));
+      await this.analyzeTemplate(dir, component);
     }
 
-    await Promise.all(analysisPromises);
     return this;
   }