chore: Refactor some promise chains into await statements.

Author: chriseppstein

Diff for: packages/@css-blocks/core/src/BlockParser/BlockParser.ts

@@ -43,13 +43,13 @@ export class BlockParser {
     this.factory = factory;
   }
 
-  public parseSource(source: ParsedSource): Promise<Block> {
+  public async parseSource(source: ParsedSource): Promise<Block> {
     let root = source.parseResult;
-
-    return this.parse(root, source.identifier, source.defaultName).then(block => {
-      source.dependencies.forEach(block.addDependency);
-      return block;
-    });
+    let block = await this.parse(root, source.identifier, source.defaultName);
+    for (let dependency of source.dependencies) {
+      block.addDependency(dependency);
+    }
+    return block;
   }
 
   /**

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

@@ -103,5 +103,6 @@ export async function exportBlocks(block: Block, factory: BlockFactory, file: st
   });
 
   // After all export promises have resolved, resolve the decorated Block.
-  return Promise.all(exportPromises).then(() => block);
+  await Promise.all(exportPromises);
+  return block;
 }

Diff for: packages/@css-blocks/core/test/attribute-container-test.ts

@@ -11,18 +11,17 @@ import { setupImporting } from "./util/setupImporting";
 
 @suite("Attribute container")
 export class AttributeContainerTest extends BEMProcessor {
-  assertError(errorType: typeof cssBlocks.CssBlockError, message: string, promise: postcss.LazyResult) {
-    return promise.then(
-      () => {
-        assert(false, `Error ${errorType.name} was not raised.`);
-      },
-      (reason) => {
-        assert(reason instanceof errorType, reason.toString());
-        assert.deepEqual(reason.message, message);
-      });
+  async assertError(errorType: typeof cssBlocks.CssBlockError, message: string, promise: postcss.LazyResult) {
+    try {
+      await promise;
+      assert(false, `Error ${errorType.name} was not raised.`);
+    } catch (reason) {
+      assert(reason instanceof errorType, reason.toString());
+      assert.deepEqual(reason.message, message);
+    }
   }
 
-  @test "finds boolean attributes"() {
+  @test async "finds boolean attributes"() {
     let { imports, importer, config, factory } = setupImporting();
     let filename = "foo/bar/a-block.css";
     imports.registerSource(
@@ -32,22 +31,21 @@ export class AttributeContainerTest extends BEMProcessor {
        .foo[state|small] { font-size: 5px; }`,
     );
 
-    return factory.getBlock(importer.identifier(null, filename, config)).then(block => {
-      let attr = block.rootClass.getAttributeValue("[state|large]");
-      typedAssert.isNotNull(attr).and((attr) => {
-        assert.equal(attr.isPresenceRule, true);
-      });
-      let classObj = block.getClass("foo");
-      typedAssert.isNotNull(classObj).and(classObj => {
-        let classAttr = classObj.getAttributeValue("[state|small]");
-        typedAssert.isNotNull(classAttr).and(classAttr => {
-          assert.equal(classAttr.isPresenceRule, true);
-        });
+    let block = await factory.getBlock(importer.identifier(null, filename, config));
+    let attr = block.rootClass.getAttributeValue("[state|large]");
+    typedAssert.isNotNull(attr).and((attr) => {
+      assert.equal(attr.isPresenceRule, true);
+    });
+    let classObj = block.getClass("foo");
+    typedAssert.isNotNull(classObj).and(classObj => {
+      let classAttr = classObj.getAttributeValue("[state|small]");
+      typedAssert.isNotNull(classAttr).and(classAttr => {
+        assert.equal(classAttr.isPresenceRule, true);
       });
     });
   }
 
-  @test "finds attribute groups"() {
+  @test async "finds attribute groups"() {
     let { imports, importer, config, factory } = setupImporting();
     let filename = "foo/bar/a-block.css";
     imports.registerSource(
@@ -59,26 +57,24 @@ export class AttributeContainerTest extends BEMProcessor {
        .foo[state|mode=minimized] { display: block; max-height: 100px; }
        .foo[state|mode=expanded] { display: block; }`,
     );
-
-    return factory.getBlock(importer.identifier(null, filename, config)).then(block => {
-      let sizeGroup: Array<AttrValue> = block.rootClass.getAttributeValues("[state|size]");
-      assert.equal(sizeGroup.length, 2);
-      assert.includeMembers(sizeGroup.map(s => s.value), ["large", "small"]);
-      let attrGroup: Array<AttrValue> = block.rootClass.getAttributeValues("[state|size]", "large");
-      assert.equal(attrGroup.length, 1);
-      assert.includeMembers(attrGroup.map(s => s.value), ["large"]);
-      let missingGroup: Array<AttrValue> = block.rootClass.getAttributeValues("[state|asdf]");
-      assert.equal(missingGroup.length, 0);
-      let noAttr: Array<AttrValue> = block.rootClass.getAttributeValues("[state|size]", "tiny");
-      assert.equal(noAttr.length, 0);
-      typedAssert.isNotNull(block.getClass("foo")).and(classObj => {
-        let modeGroup: Array<AttrValue> = classObj.getAttributeValues("[state|mode]");
-        assert.equal(modeGroup.length, 3);
-        assert.includeMembers(modeGroup.map(s => s.value), ["collapsed", "minimized", "expanded"]);
-      });
+    let block = await factory.getBlock(importer.identifier(null, filename, config));
+    let sizeGroup: Array<AttrValue> = block.rootClass.getAttributeValues("[state|size]");
+    assert.equal(sizeGroup.length, 2);
+    assert.includeMembers(sizeGroup.map(s => s.value), ["large", "small"]);
+    let attrGroup: Array<AttrValue> = block.rootClass.getAttributeValues("[state|size]", "large");
+    assert.equal(attrGroup.length, 1);
+    assert.includeMembers(attrGroup.map(s => s.value), ["large"]);
+    let missingGroup: Array<AttrValue> = block.rootClass.getAttributeValues("[state|asdf]");
+    assert.equal(missingGroup.length, 0);
+    let noAttr: Array<AttrValue> = block.rootClass.getAttributeValues("[state|size]", "tiny");
+    assert.equal(noAttr.length, 0);
+    typedAssert.isNotNull(block.getClass("foo")).and(classObj => {
+      let modeGroup: Array<AttrValue> = classObj.getAttributeValues("[state|mode]");
+      assert.equal(modeGroup.length, 3);
+      assert.includeMembers(modeGroup.map(s => s.value), ["collapsed", "minimized", "expanded"]);
     });
   }
-  @test "resolves inherited attribute groups"() {
+  @test async "resolves inherited attribute groups"() {
     let { imports, importer, config, factory } = setupImporting();
     let filename = "foo/bar/sub-block.block.css";
     imports.registerSource(
@@ -98,20 +94,19 @@ export class AttributeContainerTest extends BEMProcessor {
        .foo[state|mode=minimized] { display: block; max-height: 200px; }`,
     );
 
-    return factory.getBlock(importer.identifier(null, filename, config)).then(block => {
-      let sizeGroup = block.rootClass.resolveAttributeValues("[state|size]");
-      assert.equal(sizeGroup.size, 3);
-      assert.includeMembers([...sizeGroup.keys()], ["large", "small", "tiny"]);
-      typedAssert.isNotNull(block.getClass("foo")).and(classObj => {
-        let modeGroup = classObj.resolveAttributeValues("[state|mode]");
-        assert.equal(modeGroup.size, 3);
-        typedAssert.isDefined(modeGroup).and(modeGroup => {
-          typedAssert.isDefined(modeGroup.get("collapsed")).and(attr => {
-            assert.equal(attr.block, block.base);
-          });
-          typedAssert.isDefined(modeGroup.get("minimized")).and(attr => {
-            assert.equal(attr.block, block);
-          });
+    let block = await factory.getBlock(importer.identifier(null, filename, config));
+    let sizeGroup = block.rootClass.resolveAttributeValues("[state|size]");
+    assert.equal(sizeGroup.size, 3);
+    assert.includeMembers([...sizeGroup.keys()], ["large", "small", "tiny"]);
+    typedAssert.isNotNull(block.getClass("foo")).and(classObj => {
+      let modeGroup = classObj.resolveAttributeValues("[state|mode]");
+      assert.equal(modeGroup.size, 3);
+      typedAssert.isDefined(modeGroup).and(modeGroup => {
+        typedAssert.isDefined(modeGroup.get("collapsed")).and(attr => {
+          assert.equal(attr.block, block.base);
+        });
+        typedAssert.isDefined(modeGroup.get("minimized")).and(attr => {
+          assert.equal(attr.block, block);
         });
       });
     });

Diff for: packages/@css-blocks/jsx/src/Analyzer/visitors/importer.ts

@@ -142,15 +142,12 @@ export function importVisitor(
       }
 
       // When block parsing is done, add to analysis object.
-      res.then((block): Block => {
+      let blockPromise = res.then((block): Block => {
         analysis.addBlock(localName, block);
         return block;
-      })
-
-      // Failures handled upstream by Promise.all() in `parseWith` method. Swallow error.
-      .catch(() => {});
+      });
 
-      blockPromises.push(res);
+      blockPromises.push(blockPromise);
 
     },