vest 4.1.2 → 4.2.1-dev-ee64be

package/dist/es/vest.development.js

@@ -1,8 +1,6 @@
 export { enforce } from 'n4s';
 import { createContext } from 'context';
 
-var assign = Object.assign;
-
 /**
  * @returns a unique numeric id.
  */
@@ -10,6 +8,90 @@ var genId = (function (n) { return function () {
     return "".concat(n++);
 }; })(0);
 
+function isStringValue(v) {
+    return String(v) === v;
+}
+
+function bindNot(fn) {
+    return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return !fn.apply(void 0, args);
+    };
+}
+
+function isUndefined(value) {
+    return value === undefined;
+}
+
+function shouldUseErrorAsMessage(message, error) {
+    // kind of cheating with this safe guard, but it does the job
+    return isUndefined(message) && isStringValue(error);
+}
+
+function asArray(possibleArg) {
+    return [].concat(possibleArg);
+}
+
+function lengthEquals(value, arg1) {
+    return value.length === Number(arg1);
+}
+
+function longerThan(value, arg1) {
+    return value.length > Number(arg1);
+}
+
+/**
+ * Creates a cache function
+ */
+function createCache(maxSize) {
+    if (maxSize === void 0) { maxSize = 1; }
+    var cacheStorage = [];
+    var cache = function (deps, cacheAction) {
+        var cacheHit = cache.get(deps);
+        // cache hit is not null
+        if (cacheHit)
+            return cacheHit[1];
+        var result = cacheAction();
+        cacheStorage.unshift([deps.concat(), result]);
+        if (longerThan(cacheStorage, maxSize))
+            cacheStorage.length = maxSize;
+        return result;
+    };
+    // invalidate an item in the cache by its dependencies
+    cache.invalidate = function (deps) {
+        var index = findIndex(deps);
+        if (index > -1)
+            cacheStorage.splice(index, 1);
+    };
+    // Retrieves an item from the cache.
+    cache.get = function (deps) {
+        return cacheStorage[findIndex(deps)] || null;
+    };
+    return cache;
+    function findIndex(deps) {
+        return cacheStorage.findIndex(function (_a) {
+            var cachedDeps = _a[0];
+            return lengthEquals(deps, cachedDeps.length) &&
+                deps.every(function (dep, i) { return dep === cachedDeps[i]; });
+        });
+    }
+}
+
+// The module is named "isArrayValue" since it
+// is conflicting with a nested npm dependency.
+// We may need to revisit this in the future.
+function isArray(value) {
+    return Boolean(Array.isArray(value));
+}
+
+function isNull(value) {
+    return value === null;
+}
+var isNotNull = bindNot(isNull);
+
 function isFunction(value) {
     return typeof value === 'function';
 }
@@ -27,120 +109,58 @@ function defaultTo(callback, defaultValue) {
     return (_a = optionalFunctionValue(callback)) !== null && _a !== void 0 ? _a : defaultValue;
 }
 
-/**
- * Throws a timed out error.
- */
-function throwError(devMessage, productionMessage) {
-    throw new Error(devMessage );
-}
-function throwErrorDeferred(devMessage, productionMessage) {
-    setTimeout(function () {
-        throwError(devMessage);
-    }, 0);
+function last(values) {
+    var valuesArray = asArray(values);
+    return valuesArray[valuesArray.length - 1];
 }
 
-// eslint-disable-next-line max-lines-per-function
-function createState(onStateChange) {
-    var state = {
-        references: []
-    };
-    var registrations = [];
-    return {
-        registerStateKey: registerStateKey,
-        reset: reset
-    };
-    /**
-     * Registers a new key in the state, takes the initial value (may be a function that returns the initial value), returns a function.
-     *
-     * @example
-     *
-     * const useColor = state.registerStateKey("blue");
-     *
-     * let [color, setColor] = useColor(); // -> ["blue", Function]
-     *
-     * setColor("green");
-     *
-     * useColor()[0]; -> "green"
-     */
-    function registerStateKey(initialState, onUpdate) {
-        var key = registrations.length;
-        registrations.push([initialState, onUpdate]);
-        return initKey(key, initialState);
-    }
-    function reset() {
-        var prev = current();
-        state.references = [];
-        registrations.forEach(function (_a, index) {
-            var initialValue = _a[0];
-            return initKey(index, initialValue, prev[index]);
-        });
-    }
-    function initKey(key, initialState, prevState) {
-        current().push();
-        set(key, optionalFunctionValue(initialState, prevState));
-        return function useStateKey() {
-            return [
-                current()[key],
-                function (nextState) {
-                    return set(key, optionalFunctionValue(nextState, current()[key]));
-                },
-            ];
-        };
-    }
-    function current() {
-        return state.references;
-    }
-    function set(index, value) {
-        var prevValue = state.references[index];
-        state.references[index] = value;
-        var _a = registrations[index], onUpdate = _a[1];
-        if (isFunction(onUpdate)) {
-            onUpdate(value, prevValue);
+// This is kind of a map/filter in one function.
+// Normally, behaves like a nested-array map,
+// but returning `null` will drop the element from the array
+function transform(array, cb) {
+    var res = [];
+    for (var _i = 0, array_1 = array; _i < array_1.length; _i++) {
+        var v = array_1[_i];
+        if (isArray(v)) {
+            res.push(transform(v, cb));
         }
-        if (isFunction(onStateChange)) {
-            onStateChange();
+        else {
+            var output = cb(v);
+            if (isNotNull(output)) {
+                res.push(output);
+            }
         }
     }
+    return res;
 }
-
-var IsolateTypes;
-(function (IsolateTypes) {
-    IsolateTypes[IsolateTypes["DEFAULT"] = 0] = "DEFAULT";
-    IsolateTypes[IsolateTypes["SUITE"] = 1] = "SUITE";
-    IsolateTypes[IsolateTypes["EACH"] = 2] = "EACH";
-    IsolateTypes[IsolateTypes["SKIP_WHEN"] = 3] = "SKIP_WHEN";
-    IsolateTypes[IsolateTypes["OMIT_WHEN"] = 4] = "OMIT_WHEN";
-    IsolateTypes[IsolateTypes["GROUP"] = 5] = "GROUP";
-})(IsolateTypes || (IsolateTypes = {}));
-
-function createStateRef(state, _a) {
-    var suiteId = _a.suiteId, suiteName = _a.suiteName;
-    return {
-        optionalFields: state.registerStateKey(function () { return ({}); }),
-        suiteId: state.registerStateKey(suiteId),
-        suiteName: state.registerStateKey(suiteName),
-        testCallbacks: state.registerStateKey(function () { return ({
-            fieldCallbacks: {},
-            doneCallbacks: []
-        }); }),
-        testObjects: state.registerStateKey(function (prev) {
-            return {
-                prev: prev ? prev.current : [],
-                current: []
-            };
-        })
-    };
+function valueAtPath(array, path) {
+    return getCurrent(array, path)[last(path)];
 }
-
-function asArray(possibleArg) {
-    return [].concat(possibleArg);
+function setValueAtPath(array, path, value) {
+    var current = getCurrent(array, path);
+    current[last(path)] = value;
+    return array;
 }
-
-function last(values) {
-    var valuesArray = asArray(values);
-    return valuesArray[valuesArray.length - 1];
+function flatten(values) {
+    return asArray(values).reduce(function (acc, value) {
+        if (isArray(value)) {
+            return acc.concat(flatten(value));
+        }
+        return asArray(acc).concat(value);
+    }, []);
+}
+function getCurrent(array, path) {
+    var current = array;
+    for (var _i = 0, _a = path.slice(0, -1); _i < _a.length; _i++) {
+        var p = _a[_i];
+        current[p] = defaultTo(current[p], []);
+        current = current[p];
+    }
+    return current;
 }
 
+var assign = Object.assign;
+
 function createCursor() {
     var storage = {
         cursor: []
@@ -175,6 +195,22 @@ function createCursor() {
     };
 }
 
+var IsolateTypes;
+(function (IsolateTypes) {
+    IsolateTypes[IsolateTypes["DEFAULT"] = 0] = "DEFAULT";
+    IsolateTypes[IsolateTypes["SUITE"] = 1] = "SUITE";
+    IsolateTypes[IsolateTypes["EACH"] = 2] = "EACH";
+    IsolateTypes[IsolateTypes["SKIP_WHEN"] = 3] = "SKIP_WHEN";
+    IsolateTypes[IsolateTypes["OMIT_WHEN"] = 4] = "OMIT_WHEN";
+    IsolateTypes[IsolateTypes["GROUP"] = 5] = "GROUP";
+})(IsolateTypes || (IsolateTypes = {}));
+
+var Modes;
+(function (Modes) {
+    Modes[Modes["ALL"] = 0] = "ALL";
+    Modes[Modes["EAGER"] = 1] = "EAGER";
+})(Modes || (Modes = {}));
+
 var context = createContext(function (ctxRef, parentContext) {
     return parentContext
         ? null
@@ -191,140 +227,11 @@ var context = createContext(function (ctxRef, parentContext) {
                     prev: {}
                 }
             },
+            mode: [Modes.ALL],
             testCursor: createCursor()
         }, ctxRef);
 });
 
-function bindNot(fn) {
-    return function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        return !fn.apply(void 0, args);
-    };
-}
-
-// The module is named "isArrayValue" since it
-// is conflicting with a nested npm dependency.
-// We may need to revisit this in the future.
-function isArray(value) {
-    return Boolean(Array.isArray(value));
-}
-
-function isNull(value) {
-    return value === null;
-}
-var isNotNull = bindNot(isNull);
-
-// This is sort of a map/filter in one function.
-// Normally, behaves like a nested-array map
-// Returning `null` will drop the element from the array
-function transform(array, cb) {
-    var res = [];
-    for (var _i = 0, array_1 = array; _i < array_1.length; _i++) {
-        var v = array_1[_i];
-        if (isArray(v)) {
-            res.push(transform(v, cb));
-        }
-        else {
-            var output = cb(v);
-            if (isNotNull(output)) {
-                res.push(output);
-            }
-        }
-    }
-    return res;
-}
-function valueAtPath(array, path) {
-    return getCurrent(array, path)[last(path)];
-}
-function setValueAtPath(array, path, value) {
-    var current = getCurrent(array, path);
-    current[last(path)] = value;
-    return array;
-}
-function flatten(values) {
-    return asArray(values).reduce(function (acc, value) {
-        if (isArray(value)) {
-            return acc.concat(flatten(value));
-        }
-        return asArray(acc).concat(value);
-    }, []);
-}
-function getCurrent(array, path) {
-    var current = array;
-    for (var _i = 0, _a = path.slice(0, -1); _i < _a.length; _i++) {
-        var p = _a[_i];
-        current[p] = defaultTo(current[p], []);
-        current = current[p];
-    }
-    return current;
-}
-
-function isUndefined(value) {
-    return value === undefined;
-}
-
-function isNullish(value) {
-    return isNull(value) || isUndefined(value);
-}
-
-function isStringValue(v) {
-    return String(v) === v;
-}
-
-function shouldUseErrorAsMessage(message, error) {
-    // kind of cheating with this safe guard, but it does the job
-    return isUndefined(message) && isStringValue(error);
-}
-
-function lengthEquals(value, arg1) {
-    return value.length === Number(arg1);
-}
-
-function longerThan(value, arg1) {
-    return value.length > Number(arg1);
-}
-
-/**
- * Creates a cache function
- */
-function createCache(maxSize) {
-    if (maxSize === void 0) { maxSize = 1; }
-    var cacheStorage = [];
-    var cache = function (deps, cacheAction) {
-        var cacheHit = cache.get(deps);
-        // cache hit is not null
-        if (cacheHit)
-            return cacheHit[1];
-        var result = cacheAction();
-        cacheStorage.unshift([deps.concat(), result]);
-        if (longerThan(cacheStorage, maxSize))
-            cacheStorage.length = maxSize;
-        return result;
-    };
-    // invalidate an item in the cache by its dependencies
-    cache.invalidate = function (deps) {
-        var index = cacheStorage.findIndex(function (_a) {
-            var cachedDeps = _a[0];
-            return lengthEquals(deps, cachedDeps.length) &&
-                deps.every(function (dep, i) { return dep === cachedDeps[i]; });
-        });
-        if (index > -1)
-            cacheStorage.splice(index, 1);
-    };
-    // Retrieves an item from the cache.
-    cache.get = function (deps) {
-        return cacheStorage[cacheStorage.findIndex(function (_a) {
-            var cachedDeps = _a[0];
-            return lengthEquals(deps, cachedDeps.length) &&
-                deps.every(function (dep, i) { return dep === cachedDeps[i]; });
-        })] || null;
-    };
-    return cache;
-}
-
 // STATE REF
 function useStateRef() {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -529,16 +436,115 @@ var VestTest = /** @class */ (function () {
     VestTest.prototype.statusEquals = function (status) {
         return this.status === status;
     };
-    return VestTest;
-}());
-var STATUS_UNTESTED = 'UNTESTED';
-var STATUS_SKIPPED = 'SKIPPED';
-var STATUS_FAILED = 'FAILED';
-var STATUS_WARNING = 'WARNING';
-var STATUS_PASSING = 'PASSING';
-var STATUS_PENDING = 'PENDING';
-var STATUS_CANCELED = 'CANCELED';
-var STATUS_OMITTED = 'OMITTED';
+    return VestTest;
+}());
+var STATUS_UNTESTED = 'UNTESTED';
+var STATUS_SKIPPED = 'SKIPPED';
+var STATUS_FAILED = 'FAILED';
+var STATUS_WARNING = 'WARNING';
+var STATUS_PASSING = 'PASSING';
+var STATUS_PENDING = 'PENDING';
+var STATUS_CANCELED = 'CANCELED';
+var STATUS_OMITTED = 'OMITTED';
+
+/**
+ * Throws a timed out error.
+ */
+function throwError(devMessage, productionMessage) {
+    throw new Error(devMessage );
+}
+function throwErrorDeferred(devMessage, productionMessage) {
+    setTimeout(function () {
+        throwError(devMessage);
+    }, 0);
+}
+
+// eslint-disable-next-line max-lines-per-function
+function createState(onStateChange) {
+    var state = {
+        references: []
+    };
+    var registrations = [];
+    return {
+        registerStateKey: registerStateKey,
+        reset: reset
+    };
+    /**
+     * Registers a new key in the state, takes the initial value (may be a function that returns the initial value), returns a function.
+     *
+     * @example
+     *
+     * const useColor = state.registerStateKey("blue");
+     *
+     * let [color, setColor] = useColor(); // -> ["blue", Function]
+     *
+     * setColor("green");
+     *
+     * useColor()[0]; -> "green"
+     */
+    function registerStateKey(initialState, onUpdate) {
+        var key = registrations.length;
+        registrations.push([initialState, onUpdate]);
+        return initKey(key, initialState);
+    }
+    function reset() {
+        var prev = current();
+        state.references = [];
+        registrations.forEach(function (_a, index) {
+            var initialValue = _a[0];
+            return initKey(index, initialValue, prev[index]);
+        });
+    }
+    function initKey(key, initialState, prevState) {
+        current().push();
+        set(key, optionalFunctionValue(initialState, prevState));
+        return function useStateKey() {
+            return [
+                current()[key],
+                function (nextState) {
+                    return set(key, optionalFunctionValue(nextState, current()[key]));
+                },
+            ];
+        };
+    }
+    function current() {
+        return state.references;
+    }
+    function set(index, value) {
+        var prevValue = state.references[index];
+        state.references[index] = value;
+        var _a = registrations[index], onUpdate = _a[1];
+        if (isFunction(onUpdate)) {
+            onUpdate(value, prevValue);
+        }
+        if (isFunction(onStateChange)) {
+            onStateChange();
+        }
+    }
+}
+
+function createStateRef(state, _a) {
+    var suiteId = _a.suiteId, suiteName = _a.suiteName;
+    return {
+        optionalFields: state.registerStateKey(function () { return ({}); }),
+        suiteId: state.registerStateKey(suiteId),
+        suiteName: state.registerStateKey(suiteName),
+        testCallbacks: state.registerStateKey(function () { return ({
+            fieldCallbacks: {},
+            doneCallbacks: []
+        }); }),
+        testObjects: state.registerStateKey(function (prev) {
+            return {
+                prev: prev ? prev.current : [],
+                current: []
+            };
+        })
+    };
+}
+
+function isNullish(value) {
+    return isNull(value) || isUndefined(value);
+}
 
 function usePath() {
     var context$1 = context.useX();
@@ -613,69 +619,21 @@ function shouldAllowReorder() {
     return context.useX().isolate.type === IsolateTypes.EACH;
 }
 
-/**
- * A safe hasOwnProperty access
- */
-function hasOwnProperty(obj, key) {
-    return Object.prototype.hasOwnProperty.call(obj, key);
-}
-
-function isNumber(value) {
-    return Boolean(typeof value === 'number');
-}
-
-function isEmpty(value) {
-    if (!value) {
-        return true;
-    }
-    else if (isNumber(value)) {
-        return value === 0;
-    }
-    else if (hasOwnProperty(value, 'length')) {
-        return lengthEquals(value, 0);
-    }
-    else if (typeof value === 'object') {
-        return lengthEquals(Object.keys(value), 0);
-    }
-    return true;
-}
-var isNotEmpty = bindNot(isEmpty);
-
-function nonMatchingFieldName(testObject, fieldName) {
-    return !!fieldName && !matchingFieldName(testObject, fieldName);
-}
-function matchingFieldName(testObject, fieldName) {
-    return !!(fieldName && testObject.fieldName === fieldName);
-}
-
-/**
- * Checks if a given field, or the suite as a whole still have remaining tests.
- */
-function hasRemainingTests(fieldName) {
-    var allIncomplete = useAllIncomplete();
-    if (isEmpty(allIncomplete)) {
-        return false;
-    }
-    if (fieldName) {
-        return allIncomplete.some(function (testObject) {
-            return matchingFieldName(testObject, fieldName);
-        });
-    }
-    return isNotEmpty(allIncomplete);
-}
+var Severity;
+(function (Severity) {
+    Severity["WARNINGS"] = "warnings";
+    Severity["ERRORS"] = "errors";
+})(Severity || (Severity = {}));
 
 /**
  * Reads the testObjects list and gets full validation result from it.
  */
 function genTestsSummary() {
     var testObjects = useTestsFlat();
-    var summary = {
-        errorCount: 0,
+    var summary = assign(baseStats(), {
         groups: {},
-        testCount: 0,
-        tests: {},
-        warnCount: 0
-    };
+        tests: {}
+    });
     appendSummary(testObjects);
     return countFailures(summary);
     function appendSummary(testObjects) {
@@ -703,30 +661,34 @@ function countFailures(summary) {
 // eslint-disable-next-line max-statements
 function genTestObject(summaryKey, testObject) {
     var fieldName = testObject.fieldName, message = testObject.message;
-    summaryKey[fieldName] = summaryKey[fieldName] || {
-        errorCount: 0,
-        warnCount: 0,
-        testCount: 0
-    };
+    summaryKey[fieldName] = summaryKey[fieldName] || baseStats();
     var testKey = summaryKey[fieldName];
     if (testObject.isNonActionable())
         return testKey;
     summaryKey[fieldName].testCount++;
     // Adds to severity group
-    function addTo(countKey, group) {
+    function addTo(severity) {
+        var countKey = severity === Severity.ERRORS ? 'errorCount' : 'warnCount';
         testKey[countKey]++;
         if (message) {
-            testKey[group] = (testKey[group] || []).concat(message);
+            testKey[severity] = (testKey[severity] || []).concat(message);
         }
     }
     if (testObject.isFailing()) {
-        addTo('errorCount', 'errors');
+        addTo(Severity.ERRORS);
     }
     else if (testObject.isWarning()) {
-        addTo('warnCount', 'warnings');
+        addTo(Severity.WARNINGS);
     }
     return testKey;
 }
+function baseStats() {
+    return {
+        errorCount: 0,
+        warnCount: 0,
+        testCount: 0
+    };
+}
 
 /*! *****************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -764,6 +726,13 @@ function __spreadArray(to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 }
 
+function nonMatchingFieldName(testObject, fieldName) {
+    return !!fieldName && !matchingFieldName(testObject, fieldName);
+}
+function matchingFieldName(testObject, fieldName) {
+    return !!(fieldName && testObject.fieldName === fieldName);
+}
+
 function either(a, b) {
     return !!a !== !!b;
 }
@@ -772,7 +741,7 @@ function either(a, b) {
  * Checks that a given test object matches the currently specified severity level
  */
 function nonMatchingSeverityProfile(severity, testObject) {
-    return either(severity === 'warnings', testObject.warns());
+    return either(severity === Severity.WARNINGS, testObject.warns());
 }
 
 function collectFailureMessages(severity, testObjects, options) {
@@ -814,10 +783,10 @@ function getFailuresArrayOrObject(group, fieldName) {
 }
 
 function getErrors(fieldName) {
-    return getFailures('errors', fieldName);
+    return getFailures(Severity.ERRORS, fieldName);
 }
 function getWarnings(fieldName) {
-    return getFailures('warnings', fieldName);
+    return getFailures(Severity.WARNINGS, fieldName);
 }
 /**
  * @returns suite or field's errors or warnings.
@@ -831,11 +800,11 @@ function getFailures(severityKey, fieldName) {
 }
 
 function getErrorsByGroup(groupName, fieldName) {
-    var errors = getByGroup('errors', groupName, fieldName);
+    var errors = getByGroup(Severity.ERRORS, groupName, fieldName);
     return getFailuresArrayOrObject(errors, fieldName);
 }
 function getWarningsByGroup(groupName, fieldName) {
-    var warnings = getByGroup('warnings', groupName, fieldName);
+    var warnings = getByGroup(Severity.WARNINGS, groupName, fieldName);
     return getFailuresArrayOrObject(warnings, fieldName);
 }
 /**
@@ -869,10 +838,10 @@ function hasFailuresLogic(testObject, severityKey, fieldName) {
 }
 
 function hasErrors(fieldName) {
-    return has('errors', fieldName);
+    return has(Severity.ERRORS, fieldName);
 }
 function hasWarnings(fieldName) {
-    return has('warnings', fieldName);
+    return has(Severity.WARNINGS, fieldName);
 }
 function has(severityKey, fieldName) {
     var testObjects = useTestsFlat();
@@ -882,10 +851,10 @@ function has(severityKey, fieldName) {
 }
 
 function hasErrorsByGroup(groupName, fieldName) {
-    return hasByGroup('errors', groupName, fieldName);
+    return hasByGroup(Severity.ERRORS, groupName, fieldName);
 }
 function hasWarningsByGroup(groupName, fieldName) {
-    return hasByGroup('warnings', groupName, fieldName);
+    return hasByGroup(Severity.WARNINGS, groupName, fieldName);
 }
 /**
  * Checks whether there are failures in a given group.
@@ -899,6 +868,34 @@ function hasByGroup(severityKey, group, fieldName) {
     });
 }
 
+/**
+ * A safe hasOwnProperty access
+ */
+function hasOwnProperty(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+function isNumber(value) {
+    return Boolean(typeof value === 'number');
+}
+
+function isEmpty(value) {
+    if (!value) {
+        return true;
+    }
+    else if (isNumber(value)) {
+        return value === 0;
+    }
+    else if (hasOwnProperty(value, 'length')) {
+        return lengthEquals(value, 0);
+    }
+    else if (typeof value === 'object') {
+        return lengthEquals(Object.keys(value), 0);
+    }
+    return true;
+}
+var isNotEmpty = bindNot(isEmpty);
+
 // eslint-disable-next-line max-statements, complexity
 function isValid(result, fieldName) {
     if (fieldIsOmitted(fieldName)) {
@@ -952,7 +949,7 @@ function noMissingTests(fieldName) {
 }
 
 var cache$1 = createCache(20);
-function produceDraft() {
+function produceBase() {
     var testObjects = useTestsFlat();
     var ctxRef = { stateRef: useStateRef() };
     return cache$1([testObjects], context.bind(ctxRef, function () {
@@ -967,19 +964,35 @@ function produceDraft() {
             hasWarnings: context.bind(ctxRef, hasWarnings),
             hasWarningsByGroup: context.bind(ctxRef, hasWarningsByGroup),
             isValid: context.bind(ctxRef, function (fieldName) {
-                return isValid(produceDraft(), fieldName);
+                return isValid(produceBase(), fieldName);
             }),
             suiteName: suiteName
         });
     }));
 }
 
+/**
+ * Checks if a given field, or the suite as a whole still have remaining tests.
+ */
+function hasRemainingTests(fieldName) {
+    var allIncomplete = useAllIncomplete();
+    if (isEmpty(allIncomplete)) {
+        return false;
+    }
+    if (fieldName) {
+        return allIncomplete.some(function (testObject) {
+            return matchingFieldName(testObject, fieldName);
+        });
+    }
+    return isNotEmpty(allIncomplete);
+}
+
 var cache = createCache(20);
 function produceFullResult() {
     var testObjects = useTestsFlat();
     var ctxRef = { stateRef: useStateRef() };
     return cache([testObjects], context.bind(ctxRef, function () {
-        return assign({}, produceDraft(), {
+        return assign({}, produceBase(), {
             done: context.bind(ctxRef, done)
         });
     }));
@@ -1012,7 +1025,7 @@ var done = function done() {
     if (shouldSkipDoneRegistration(callback, fieldName, output)) {
         return output;
     }
-    var doneCallback = function () { return callback(produceDraft()); };
+    var doneCallback = function () { return callback(produceBase()); };
     if (shouldRunDoneCallback(fieldName)) {
         doneCallback();
         return output;
@@ -1038,18 +1051,12 @@ function createBus() {
     var listeners = {};
     return {
         emit: function (event, data) {
-            if (!listeners[event]) {
-                return;
-            }
-            listeners[event].forEach(function (listener) {
-                listener(data);
+            (listeners[event] || []).forEach(function (handler) {
+                handler(data);
             });
         },
         on: function (event, handler) {
-            if (!listeners[event]) {
-                listeners[event] = [];
-            }
-            listeners[event].push(handler);
+            listeners[event] = (listeners[event] || []).concat(handler);
             return {
                 off: function () {
                     listeners[event] = listeners[event].filter(function (h) { return h !== handler; });
@@ -1117,9 +1124,7 @@ function runFieldCallbacks(fieldName) {
  */
 function runDoneCallbacks() {
     var doneCallbacks = useTestCallbacks()[0].doneCallbacks;
-    if (!hasRemainingTests()) {
-        callEach(doneCallbacks);
-    }
+    callEach(doneCallbacks);
 }
 
 // eslint-disable-next-line max-lines-per-function
@@ -1133,14 +1138,21 @@ function initBus() {
         }
         testObject.done();
         runFieldCallbacks(testObject.fieldName);
-        runDoneCallbacks();
+        if (!hasRemainingTests()) {
+            // When no more tests are running, emit the done event
+            bus.emit(Events.ALL_RUNNING_TESTS_FINISHED);
+        }
     });
     // Report that the suite completed its synchronous test run.
     // Async operations may still be running.
-    bus.on(Events.SUITE_COMPLETED, function () {
+    bus.on(Events.SUITE_CALLBACK_DONE_RUNNING, function () {
         // Remove tests that are optional and need to be omitted
         omitOptionalTests();
     });
+    // Called when all the tests, including async, are done running
+    bus.on(Events.ALL_RUNNING_TESTS_FINISHED, function () {
+        runDoneCallbacks();
+    });
     // Removes a certain field from the state.
     bus.on(Events.REMOVE_FIELD, function (fieldName) {
         useEachTestObject(function (testObject) {
@@ -1170,9 +1182,10 @@ function useBus() {
 var Events;
 (function (Events) {
     Events["TEST_COMPLETED"] = "test_completed";
+    Events["ALL_RUNNING_TESTS_FINISHED"] = "all_running_tests_finished";
     Events["REMOVE_FIELD"] = "remove_field";
     Events["RESET_FIELD"] = "reset_field";
-    Events["SUITE_COMPLETED"] = "suite_completed";
+    Events["SUITE_CALLBACK_DONE_RUNNING"] = "suite_callback_done_running";
 })(Events || (Events = {}));
 
 // eslint-disable-next-line max-lines-per-function
@@ -1209,11 +1222,11 @@ function create() {
         });
         // Report the suite is done registering tests
         // Async tests may still be running
-        bus.emit(Events.SUITE_COMPLETED);
+        bus.emit(Events.SUITE_CALLBACK_DONE_RUNNING);
         // Return the result
         return produceFullResult();
     }), {
-        get: context.bind(ctxRef, produceDraft),
+        get: context.bind(ctxRef, produceBase),
         remove: context.bind(ctxRef, function (fieldName) {
             bus.emit(Events.REMOVE_FIELD, fieldName);
         }),
@@ -1240,7 +1253,7 @@ function create() {
  */
 function each(list, callback) {
     if (!isFunction(callback)) {
-        throwError('callback must be a function');
+        throwError('each callback must be a function');
     }
     isolate({ type: IsolateTypes.EACH }, function () {
         list.forEach(function (arg, index) {
@@ -1254,6 +1267,31 @@ function each(list, callback) {
  */
 var ERROR_HOOK_CALLED_OUTSIDE = 'hook called outside of a running suite.';
 
+/**
+ * Conditionally skips running tests within the callback.
+ *
+ * @example
+ *
+ * skipWhen(res => res.hasErrors('username'), () => {
+ *  test('username', 'User already taken', async () => await doesUserExist(username)
+ * });
+ */
+function skipWhen(conditional, callback) {
+    isolate({ type: IsolateTypes.SKIP_WHEN }, function () {
+        context.run({
+            skipped: 
+            // Checking for nested conditional. If we're in a nested skipWhen,
+            // we should skip the test if the parent conditional is true.
+            isExcludedIndividually() ||
+                // Otherwise, we should skip the test if the conditional is true.
+                optionalFunctionValue(conditional, optionalFunctionValue(produceBase))
+        }, function () { return callback(); });
+    });
+}
+function isExcludedIndividually() {
+    return !!context.useX().skipped;
+}
+
 /**
  * Adds a field or a list of fields into the inclusion list
  *
@@ -1280,9 +1318,6 @@ function skip(item) {
 skip.group = function (item) {
     return addTo(1 /* SKIP */, 'groups', item);
 };
-function isExcludedIndividually() {
-    return !!context.useX().skipped;
-}
 //Checks whether a certain test profile excluded by any of the exclusion groups.
 // eslint-disable-next-line complexity, max-statements, max-lines-per-function
 function isExcluded(testObject) {
@@ -1449,11 +1484,50 @@ function include(fieldName) {
             if (isStringValue(condition)) {
                 return Boolean(exclusion.tests[condition]);
             }
-            return optionalFunctionValue(condition, optionalFunctionValue(produceDraft));
+            return optionalFunctionValue(condition, optionalFunctionValue(produceBase));
         };
     }
 }
 
+/**
+ * Sets the suite to "eager" (fail fast) mode.
+ * Eager mode will skip running subsequent tests of a failing fields.
+ *
+ * @example
+ *  // in the following example, the second test of username will not run
+ *  // if the first test of username failed.
+ * const suite = create((data) => {
+ *  eager();
+ *
+ *  test('username', 'username is required', () => {
+ *   enforce(data.username).isNotBlank();
+ *  });
+ *
+ *  test('username', 'username is too short', () => {
+ *   enforce(data.username).longerThan(2);
+ *  });
+ * });
+ */
+function eager() {
+    setMode(Modes.EAGER);
+}
+function shouldSkipBasedOnMode(testObject) {
+    if (isEager() && hasErrors(testObject.fieldName))
+        return true;
+    return false;
+}
+function isEager() {
+    return isMode(Modes.EAGER);
+}
+function isMode(mode) {
+    var currentMode = context.useX().mode;
+    return currentMode[0] === mode;
+}
+function setMode(nextMode) {
+    var mode = context.useX().mode;
+    mode[0] = nextMode;
+}
+
 /**
  * Conditionally omits tests from the suite.
  *
@@ -1466,7 +1540,8 @@ function include(fieldName) {
 function omitWhen(conditional, callback) {
     isolate({ type: IsolateTypes.OMIT_WHEN }, function () {
         context.run({
-            omitted: optionalFunctionValue(conditional, optionalFunctionValue(produceDraft))
+            omitted: isOmitted() ||
+                optionalFunctionValue(conditional, optionalFunctionValue(produceBase))
         }, function () { return callback(); });
     });
 }
@@ -1504,28 +1579,6 @@ function optional(optionals) {
     });
 }
 
-/**
- * Conditionally skips running tests within the callback.
- *
- * @example
- *
- * skipWhen(res => res.hasErrors('username'), () => {
- *  test('username', 'User already taken', async () => await doesUserExist(username)
- * });
- */
-function skipWhen(conditional, callback) {
-    isolate({ type: IsolateTypes.SKIP_WHEN }, function () {
-        context.run({
-            skipped: 
-            // Checking for nested conditional. If we're in a nested skipWhen,
-            // we should skip the test if the parent conditional is true.
-            isExcludedIndividually() ||
-                // Otherwise, we should skip the test if the conditional is true.
-                optionalFunctionValue(conditional, optionalFunctionValue(produceDraft))
-        }, function () { return callback(); });
-    });
-}
-
 var isNotString = bindNot(isStringValue);
 
 function isPromise(value) {
@@ -1621,7 +1674,7 @@ function registerTest(testObject) {
         }
     }
     catch (e) {
-        throwError("Unexpected error encountered during test registration.\n      Test Object: ".concat(testObject, ".\n      Error: ").concat(e, "."));
+        throwError("Unexpected error encountered during test registration.\n      Test Object: ".concat(JSON.stringify(testObject), ".\n      Error: ").concat(e, "."));
     }
 }
 
@@ -1707,6 +1760,11 @@ function handleKeyTest(key, newTestObject) {
 // eslint-disable-next-line max-statements
 function registerPrevRunTest(testObject) {
     var prevRunTest = useTestAtCursor(testObject);
+    if (shouldSkipBasedOnMode(testObject)) {
+        moveForward();
+        testObject.skip();
+        return testObject;
+    }
     if (isOmitted()) {
         prevRunTest.omit();
         moveForward();
@@ -1815,6 +1873,6 @@ function warn() {
     ctx.currentTest.warn();
 }
 
-var VERSION = "4.1.1";
+var VERSION = "4.2.1-dev-ee64be";
 
-export { VERSION, context, create, each, group, include, omitWhen, only, optional, skip, skipWhen, test, warn };
+export { VERSION, context, create, each, eager, group, include, omitWhen, only, optional, skip, skipWhen, test, warn };