fix: Only raise MultipleCssBlockErrors if there's more than one.

Author: chriseppstein

packages/@css-blocks/core/src/BlockTree/Block.ts

@@ -199,8 +199,10 @@ export class Block
    * @returns true if the block is valid else throws the errors on the block
    */
   assertValid(): Block {
-    if (this._blockErrors.length) {
+    if (this._blockErrors.length > 1) {
       throw new MultipleCssBlockErrors(this._blockErrors);
+    } else if (this._blockErrors.length === 1) {
+      throw this._blockErrors[0];
     }
     return this;
   }

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

@@ -133,23 +133,30 @@ export class BlockPathError extends CssBlockError {
  * clear errors
  */
 export class MultipleCssBlockErrors extends CssBlockError {
-  static prefix = "MultipleCssBlocksError";
+  static prefix = "MultipleCssBlockErrors";
   private _errors: CssBlockError[] = [];
 
   constructor(errors: CssBlockError[], location?: ErrorLocation, details?: string) {
     super(MultipleCssBlockErrors.prefix, location);
     for (let err of errors) {
       if (err instanceof MultipleCssBlockErrors) {
-        // flatten all MultpleCssBlockErrors
-        // This normally happens if there is a transtive error
+        // flatten all MultipleCssBlockErrors
+        // This normally happens if there is a transitive error
         for (let e of err.errors) {
           this._errors.push(e);
         }
       } else {
         this._errors.push(err);
       }
     }
-    if (details) { this.message += `\n${details}`; }
+    if (!details) {
+      details = ":";
+      let i = 0;
+      for (let err of this._errors) {
+        details += `\n\t${++i}. ${err}`;
+      }
+    }
+    this.message += details;
   }
 
   add(error: CssBlockError) {

packages/@css-blocks/core/test/util/assertError.ts

@@ -1,7 +1,7 @@
 import { assert } from "chai";
 import { postcss } from "opticss";
 
-import { MultipleCssBlockErrors } from "../../src";
+import { CssBlockError, MultipleCssBlockErrors } from "../../src";
 import cssBlocks from ".././util/postcss-helper";
 
 export interface ErrorTypeMessage {
@@ -39,12 +39,16 @@ export function assertMultipleErrors(errors: ErrorTypeMessage[], promise: postcs
     (multipleErrorsError: MultipleCssBlockErrors) => assertMultipleErrorsWithoutPromise(multipleErrorsError, errors));
 }
 
-export function assertMultipleErrorsWithoutPromise(multipleErrorsError: MultipleCssBlockErrors, errors: ErrorTypeMessage[]) {
-  if (multipleErrorsError.errors.length !== errors.length) {
-    assert(false, "The number of errors thrown and expected does not match");
+export function assertMultipleErrorsWithoutPromise(mainError: CssBlockError, errors: ErrorTypeMessage[]) {
+  if (mainError instanceof MultipleCssBlockErrors) {
+    assert.equal(mainError.errors.length, errors.length, "The number of errors thrown and expected does not match");
+    errors.forEach((error, idx) => {
+      assert(mainError.errors[idx] instanceof error.type, "Error raised was not of the type expected.");
+      assert.deepEqual(mainError.errors[idx].message.split(error.type.prefix + ":")[1].trim(), error.message);
+    });
+  } else {
+    assert.equal(1, errors.length, "The number of errors thrown and expected does not match");
+    assert(mainError instanceof errors[0].type, "Error raised was not of the type expected.");
+    assert.deepEqual(mainError.message.split(errors[0].type.prefix + ":")[1].trim(), errors[0].message);
   }
-  return errors.forEach((error, idx) => {
-    assert(error.type.name, typeof multipleErrorsError.errors[idx]);
-    assert.deepEqual(multipleErrorsError.errors[idx].message.split(error.type.prefix + ":")[1].trim(), error.message);
-  });
 }