vest 4.2.3-dev-87ebfa → 4.3.2-dev-2805e3

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,203 +8,91 @@ var genId = (function (n) { return function () {
     return "".concat(n++);
 }; })(0);
 
-function isFunction(value) {
-    return typeof value === 'function';
-}
-
-function optionalFunctionValue(value) {
-    var args = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        args[_i - 1] = arguments[_i];
-    }
-    return isFunction(value) ? value.apply(void 0, args) : value;
-}
-
-function invariant(condition, 
-// eslint-disable-next-line @typescript-eslint/ban-types
-message) {
-    if (condition) {
-        return;
-    }
-    // If message is a string object (rather than string literal)
-    // Throw the value directly as a string
-    // Alternatively, throw an error with the message
-    throw message instanceof String
-        ? message.valueOf()
-        : new Error(message ? optionalFunctionValue(message) : message);
+function isStringValue(v) {
+    return String(v) === v;
 }
 
-// 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 bindNot(fn) {
+    return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
         }
-    }
+        return !fn.apply(void 0, args);
+    };
 }
 
-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 isUndefined(value) {
+    return value === undefined;
+}
 
-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 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 last(values) {
-    var valuesArray = asArray(values);
-    return valuesArray[valuesArray.length - 1];
+function isNumeric(value) {
+    var str = String(value);
+    var num = Number(value);
+    var result = !isNaN(parseFloat(str)) && !isNaN(Number(value)) && isFinite(num);
+    return Boolean(result);
 }
 
-function createCursor() {
-    var storage = {
-        cursor: []
-    };
-    function addLevel() {
-        storage.cursor.push(0);
-    }
-    function removeLevel() {
-        storage.cursor.pop();
-    }
-    function cursorAt() {
-        return last(storage.cursor);
-    }
-    function getCursor() {
-        return asArray(storage.cursor);
-    }
-    function next() {
-        storage.cursor[storage.cursor.length - 1]++;
-        return last(storage.cursor);
-    }
-    function reset() {
-        storage.cursor = [0];
-    }
-    reset();
-    return {
-        addLevel: addLevel,
-        cursorAt: cursorAt,
-        getCursor: getCursor,
-        next: next,
-        removeLevel: removeLevel,
-        reset: reset
-    };
+function numberEquals(value, eq) {
+    return isNumeric(value) && isNumeric(eq) && Number(value) === Number(eq);
 }
 
-var Modes;
-(function (Modes) {
-    Modes[Modes["ALL"] = 0] = "ALL";
-    Modes[Modes["EAGER"] = 1] = "EAGER";
-})(Modes || (Modes = {}));
+function lengthEquals(value, arg1) {
+    return numberEquals(value.length, arg1);
+}
 
-var context = createContext(function (ctxRef, parentContext) {
-    return parentContext
-        ? null
-        : assign({}, {
-            exclusion: {
-                tests: {},
-                groups: {}
-            },
-            inclusion: {},
-            isolate: {
-                type: IsolateTypes.DEFAULT,
-                keys: {
-                    current: {},
-                    prev: {}
-                }
-            },
-            mode: [Modes.ALL],
-            testCursor: createCursor()
-        }, ctxRef);
-});
+function greaterThan(value, gt) {
+    return isNumeric(value) && isNumeric(gt) && Number(value) > Number(gt);
+}
 
-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 longerThan(value, arg1) {
+    return greaterThan(value.length, 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
@@ -221,11 +107,28 @@ function isNull(value) {
 }
 var isNotNull = bindNot(isNull);
 
+function isFunction(value) {
+    return typeof value === 'function';
+}
+
+function optionalFunctionValue(value) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    return isFunction(value) ? value.apply(void 0, args) : value;
+}
+
 function defaultTo(callback, defaultValue) {
     var _a;
     return (_a = optionalFunctionValue(callback)) !== null && _a !== void 0 ? _a : defaultValue;
 }
 
+function last(values) {
+    var valuesArray = asArray(values);
+    return valuesArray[valuesArray.length - 1];
+}
+
 // 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
@@ -271,74 +174,79 @@ function getCurrent(array, path) {
     return current;
 }
 
-function isUndefined(value) {
-    return value === undefined;
-}
-
-function isNullish(value) {
-    return isNull(value) || isUndefined(value);
-}
-
-function deferThrow(message) {
-    setTimeout(function () {
-        throw new Error(message);
-    }, 0);
-}
-
-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);
-}
+var assign = Object.assign;
 
-/**
- * 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;
+function createCursor() {
+    var storage = {
+        cursor: []
     };
-    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]; });
-        });
+    function addLevel() {
+        storage.cursor.push(0);
+    }
+    function removeLevel() {
+        storage.cursor.pop();
+    }
+    function cursorAt() {
+        return last(storage.cursor);
+    }
+    function getCursor() {
+        return asArray(storage.cursor);
+    }
+    function next() {
+        storage.cursor[storage.cursor.length - 1]++;
+        return last(storage.cursor);
+    }
+    function reset() {
+        storage.cursor = [0];
     }
+    reset();
+    return {
+        addLevel: addLevel,
+        cursorAt: cursorAt,
+        getCursor: getCursor,
+        next: next,
+        removeLevel: removeLevel,
+        reset: reset
+    };
 }
 
+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
+        : assign({}, {
+            exclusion: {
+                tests: {},
+                groups: {}
+            },
+            inclusion: {},
+            isolate: {
+                type: IsolateTypes.DEFAULT,
+                keys: {
+                    current: {},
+                    prev: {}
+                }
+            },
+            mode: [Modes.ALL],
+            testCursor: createCursor()
+        }, ctxRef);
+});
+
 // STATE REF
 function useStateRef() {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -388,18 +296,6 @@ function useAllIncomplete() {
         return testObject.isPending() ? testObject : null;
     }));
 }
-function useOmittedFields() {
-    var testObjects = useTestsFlat();
-    return testObjects.reduce(function (omittedFields, testObject) {
-        if (omittedFields[testObject.fieldName]) {
-            return omittedFields;
-        }
-        if (testObject.isOmitted()) {
-            omittedFields[testObject.fieldName] = true;
-        }
-        return omittedFields;
-    }, {});
-}
 var flatCache = createCache();
 function useTestsFlat() {
     var current = useTestObjects()[0].current;
@@ -554,6 +450,113 @@ var STATUS_PENDING = 'PENDING';
 var STATUS_CANCELED = 'CANCELED';
 var STATUS_OMITTED = 'OMITTED';
 
+function invariant(condition, 
+// eslint-disable-next-line @typescript-eslint/ban-types
+message) {
+    if (condition) {
+        return;
+    }
+    // If message is a string object (rather than string literal)
+    // Throw the value directly as a string
+    // Alternatively, throw an error with the message
+    throw message instanceof String
+        ? message.valueOf()
+        : new Error(message ? optionalFunctionValue(message) : message);
+}
+
+// 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 deferThrow(message) {
+    setTimeout(function () {
+        throw new Error(message);
+    }, 0);
+}
+
 function usePath() {
     var context$1 = context.useX();
     return context$1.testCursor.getCursor();
@@ -605,9 +608,7 @@ function useRetainTestKey(key, testObject) {
 
 function isolate(_a, callback) {
     var _b = _a.type, type = _b === void 0 ? IsolateTypes.DEFAULT : _b;
-    if (!isFunction(callback)) {
-        return;
-    }
+    invariant(isFunction(callback));
     var keys = {
         current: {},
         prev: {}
@@ -637,7 +638,138 @@ var SeverityCount;
     SeverityCount["ERROR_COUNT"] = "errorCount";
     SeverityCount["WARN_COUNT"] = "warnCount";
 })(SeverityCount || (SeverityCount = {}));
+function countKeyBySeverity(severity) {
+    return severity === Severity.ERRORS
+        ? SeverityCount.ERROR_COUNT
+        : SeverityCount.WARN_COUNT;
+}
+
+/**
+ * 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 false;
+}
+var isNotEmpty = bindNot(isEmpty);
+
+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;
+}
+
+/**
+ * Checks that a given test object matches the currently specified severity level
+ */
+function nonMatchingSeverityProfile(severity, testObject) {
+    return either(severity === Severity.WARNINGS, testObject.warns());
+}
+
+/**
+ * The difference between this file and hasFailures is that hasFailures uses the static
+ * summary object, while this one uses the actual validation state
+ */
+function hasErrorsByTestObjects(fieldName) {
+    return hasFailuresByTestObjects(Severity.ERRORS, fieldName);
+}
+function hasFailuresByTestObjects(severityKey, fieldName) {
+    var testObjects = useTestsFlat();
+    return testObjects.some(function (testObject) {
+        return hasFailuresByTestObject(testObject, severityKey, fieldName);
+    });
+}
+/**
+ * Determines whether a certain test profile has failures.
+ */
+function hasFailuresByTestObject(testObject, severityKey, fieldName) {
+    if (!testObject.hasFailures()) {
+        return false;
+    }
+    if (nonMatchingFieldName(testObject, fieldName)) {
+        return false;
+    }
+    if (nonMatchingSeverityProfile(severityKey, testObject)) {
+        return false;
+    }
+    return true;
+}
+
+// eslint-disable-next-line max-statements, complexity
+function shouldAddValidProp(fieldName) {
+    if (fieldIsOmitted(fieldName)) {
+        return true;
+    }
+    if (hasErrorsByTestObjects(fieldName)) {
+        return false;
+    }
+    var testObjects = useTestsFlat();
+    if (isEmpty(testObjects)) {
+        return false;
+    }
+    if (hasNonOptionalIncomplete(fieldName)) {
+        return false;
+    }
+    return noMissingTests(fieldName);
+}
+function fieldIsOmitted(fieldName) {
+    if (!fieldName) {
+        return false;
+    }
+    var flatTests = useTestsFlat();
+    return flatTests.some(function (testObject) { return testObject.fieldName === fieldName && testObject.isOmitted(); });
+}
+function hasNonOptionalIncomplete(fieldName) {
+    var optionalFields = useOptionalFields()[0];
+    return isNotEmpty(useAllIncomplete().filter(function (testObject) {
+        if (nonMatchingFieldName(testObject, fieldName)) {
+            return false;
+        }
+        return optionalFields[testObject.fieldName] !== true;
+    }));
+}
+function noMissingTests(fieldName) {
+    var testObjects = useTestsFlat();
+    var optionalFields = useOptionalFields()[0];
+    return testObjects.every(function (testObject) {
+        if (nonMatchingFieldName(testObject, fieldName)) {
+            return true;
+        }
+        return (optionalFields[testObject.fieldName] === true ||
+            testObject.isTested() ||
+            testObject.isOmitted());
+    });
+}
 
+function useSummary() {
+    var summary = context.useX().summary;
+    invariant(summary);
+    return summary;
+}
 /**
  * Reads the testObjects list and gets full validation result from it.
  */
@@ -645,17 +777,24 @@ function genTestsSummary() {
     var testObjects = useTestsFlat();
     var summary = assign(baseStats(), {
         groups: {},
-        tests: {}
+        tests: {},
+        valid: false
     });
     testObjects.reduce(function (summary, testObject) {
         appendToTest(summary.tests, testObject);
         appendToGroup(summary.groups, testObject);
         return summary;
     }, summary);
+    summary.valid = shouldAddValidProp();
     return countFailures(summary);
 }
 function appendToTest(tests, testObject) {
     tests[testObject.fieldName] = appendTestObject(tests, testObject);
+    // If `valid` is false to begin with, keep it that way. Otherwise, assess.
+    tests[testObject.fieldName].valid =
+        tests[testObject.fieldName].valid === false
+            ? false
+            : shouldAddValidProp(testObject.fieldName);
 }
 /**
  * Appends to a group object if within a group
@@ -679,13 +818,9 @@ function countFailures(summary) {
     }
     return summary;
 }
-/**
- * Appends the test to a results object
- */
-// eslint-disable-next-line max-statements
 function appendTestObject(summaryKey, testObject) {
     var fieldName = testObject.fieldName, message = testObject.message;
-    summaryKey[fieldName] = summaryKey[fieldName] || baseStats();
+    summaryKey[fieldName] = summaryKey[fieldName] || baseTestStats();
     var testKey = summaryKey[fieldName];
     if (testObject.isNonActionable())
         return testKey;
@@ -698,18 +833,13 @@ function appendTestObject(summaryKey, testObject) {
     }
     return testKey;
     function incrementFailures(severity) {
-        var countKey = getCountKey(severity);
+        var countKey = countKeyBySeverity(severity);
         testKey[countKey]++;
         if (message) {
             testKey[severity] = (testKey[severity] || []).concat(message);
         }
     }
 }
-function getCountKey(severity) {
-    return severity === Severity.ERRORS
-        ? SeverityCount.ERROR_COUNT
-        : SeverityCount.WARN_COUNT;
-}
 function baseStats() {
     return {
         errorCount: 0,
@@ -717,97 +847,31 @@ function baseStats() {
         testCount: 0
     };
 }
-
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-var __assign = function() {
-    __assign = Object.assign || function __assign(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-
-function __spreadArray(to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    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;
+function baseTestStats() {
+    return assign(baseStats(), {
+        errors: [],
+        warnings: []
+    });
 }
 
-/**
- * Checks that a given test object matches the currently specified severity level
- */
-function nonMatchingSeverityProfile(severity, testObject) {
-    return either(severity === Severity.WARNINGS, testObject.warns());
+// calls collectAll or getByFieldName depending on whether fieldName is provided
+function gatherFailures(testGroup, severityKey, fieldName) {
+    return fieldName
+        ? getByFieldName(testGroup, severityKey, fieldName)
+        : collectAll(testGroup, severityKey);
 }
-
-function collectFailureMessages(severity, testObjects, options) {
+function getByFieldName(testGroup, severityKey, fieldName) {
     var _a;
-    if (options === void 0) { options = {}; }
-    var _b = options || {}, group = _b.group, fieldName = _b.fieldName;
-    return testObjects.reduce(function (collector, testObject) {
-        if (noMatch(testObject, severity, group, fieldName)) {
-            return collector;
-        }
-        if (!testObject.hasFailures()) {
-            return collector;
-        }
-        collector[testObject.fieldName] = (collector[testObject.fieldName] || []).concat(testObject.message || []);
-        return collector;
-    }, __assign({}, (fieldName && (_a = {}, _a[fieldName] = [], _a))));
-}
-function noGroupMatch(testObject, groupName) {
-    return !!(groupName && testObject.groupName !== groupName);
-}
-function noMatch(testObject, severity, group, fieldName) {
-    if (noGroupMatch(testObject, group)) {
-        return true;
-    }
-    if (nonMatchingFieldName(testObject, fieldName)) {
-        return true;
-    }
-    if (nonMatchingSeverityProfile(severity, testObject)) {
-        return true;
-    }
-    return false;
+    return ((_a = testGroup === null || testGroup === void 0 ? void 0 : testGroup[fieldName]) === null || _a === void 0 ? void 0 : _a[severityKey]) || [];
 }
-
-function getFailuresArrayOrObject(group, fieldName) {
-    if (fieldName) {
-        return group[fieldName];
+function collectAll(testGroup, severityKey) {
+    var output = {};
+    for (var field in testGroup) {
+        // We will probably never get to the fallback array
+        // leaving it just in case the implementation changes
+        output[field] = testGroup[field][severityKey] || [];
     }
-    return group;
+    return output;
 }
 
 function getErrors(fieldName) {
@@ -820,178 +884,90 @@ function getWarnings(fieldName) {
  * @returns suite or field's errors or warnings.
  */
 function getFailures(severityKey, fieldName) {
-    var testObjects = useTestsFlat();
-    var failureMessages = collectFailureMessages(severityKey, testObjects, {
-        fieldName: fieldName
-    });
-    return getFailuresArrayOrObject(failureMessages, fieldName);
+    var summary = useSummary();
+    return gatherFailures(summary.tests, severityKey, fieldName);
 }
 
 function getErrorsByGroup(groupName, fieldName) {
-    var errors = getByGroup(Severity.ERRORS, groupName, fieldName);
-    return getFailuresArrayOrObject(errors, fieldName);
+    return getFailuresByGroup(groupName, Severity.ERRORS, fieldName);
 }
 function getWarningsByGroup(groupName, fieldName) {
-    var warnings = getByGroup(Severity.WARNINGS, groupName, fieldName);
-    return getFailuresArrayOrObject(warnings, fieldName);
+    return getFailuresByGroup(groupName, Severity.WARNINGS, fieldName);
 }
-/**
- * Gets failure messages by group.
- */
-function getByGroup(severityKey, group, fieldName) {
-    invariant(group, "get".concat(severityKey[0].toUpperCase()).concat(severityKey.slice(1), "ByGroup requires a group name. Received `").concat(group, "` instead."));
-    var testObjects = useTestsFlat();
-    return collectFailureMessages(severityKey, testObjects, {
-        group: group,
-        fieldName: fieldName
-    });
+function getFailuresByGroup(groupName, severityKey, fieldName) {
+    var summary = useSummary();
+    return gatherFailures(summary.groups[groupName], severityKey, fieldName);
 }
 
-/**
- * Determines whether a certain test profile has failures.
- */
-function hasFailuresLogic(testObject, severityKey, fieldName) {
-    if (!testObject.hasFailures()) {
-        return false;
-    }
-    if (nonMatchingFieldName(testObject, fieldName)) {
-        return false;
-    }
-    if (nonMatchingSeverityProfile(severityKey, testObject)) {
-        return false;
-    }
-    return true;
+function isPositive(value) {
+    return greaterThan(value, 0);
 }
 
 function hasErrors(fieldName) {
-    return has(Severity.ERRORS, fieldName);
+    return hasFailures(SeverityCount.ERROR_COUNT, fieldName);
 }
 function hasWarnings(fieldName) {
-    return has(Severity.WARNINGS, fieldName);
+    return hasFailures(SeverityCount.WARN_COUNT, fieldName);
 }
-function has(severityKey, fieldName) {
-    var testObjects = useTestsFlat();
-    return testObjects.some(function (testObject) {
-        return hasFailuresLogic(testObject, severityKey, fieldName);
-    });
+function hasFailures(severityCount, fieldName) {
+    var _a;
+    var summary = useSummary();
+    if (fieldName) {
+        return isPositive((_a = summary.tests[fieldName]) === null || _a === void 0 ? void 0 : _a[severityCount]);
+    }
+    return isPositive(summary[severityCount]);
 }
 
 function hasErrorsByGroup(groupName, fieldName) {
-    return hasByGroup(Severity.ERRORS, groupName, fieldName);
+    return hasFailuresByGroup(Severity.ERRORS, groupName, fieldName);
 }
 function hasWarningsByGroup(groupName, fieldName) {
-    return hasByGroup(Severity.WARNINGS, groupName, fieldName);
-}
-/**
- * Checks whether there are failures in a given group.
- */
-function hasByGroup(severityKey, group, fieldName) {
-    var testObjects = useTestsFlat();
-    return testObjects.some(function (testObject) {
-        return group === testObject.groupName
-            ? hasFailuresLogic(testObject, severityKey, fieldName)
-            : false;
-    });
-}
-
-/**
- * A safe hasOwnProperty access
- */
-function hasOwnProperty(obj, key) {
-    return Object.prototype.hasOwnProperty.call(obj, key);
+    return hasFailuresByGroup(Severity.WARNINGS, groupName, fieldName);
 }
-
-function isNumber(value) {
-    return Boolean(typeof value === 'number');
-}
-
-function isEmpty(value) {
-    if (!value) {
-        return true;
-    }
-    else if (isNumber(value)) {
-        return value === 0;
+// eslint-disable-next-line max-statements
+function hasFailuresByGroup(severityKey, groupName, fieldName) {
+    var _a, _b;
+    var summary = useSummary();
+    var severityCount = countKeyBySeverity(severityKey);
+    var group = summary.groups[groupName];
+    if (!group) {
+        return false;
     }
-    else if (hasOwnProperty(value, 'length')) {
-        return lengthEquals(value, 0);
+    if (fieldName) {
+        return isPositive((_a = group[fieldName]) === null || _a === void 0 ? void 0 : _a[severityCount]);
     }
-    else if (typeof value === 'object') {
-        return lengthEquals(Object.keys(value), 0);
+    for (var field in group) {
+        if (isPositive((_b = group[field]) === null || _b === void 0 ? void 0 : _b[severityCount])) {
+            return true;
+        }
     }
-    return true;
+    return false;
 }
-var isNotEmpty = bindNot(isEmpty);
 
-// eslint-disable-next-line max-statements, complexity
 function isValid(fieldName) {
-    if (fieldIsOmitted(fieldName)) {
-        return true;
-    }
-    if (hasErrors(fieldName)) {
-        return false;
-    }
-    var testObjects = useTestsFlat();
-    if (isEmpty(testObjects)) {
-        return false;
-    }
-    if (fieldDoesNotExist(fieldName)) {
-        return false;
-    }
-    if (hasNonOptionalIncomplete(fieldName)) {
-        return false;
-    }
-    return noMissingTests(fieldName);
-}
-function fieldIsOmitted(fieldName) {
-    var omittedFields = useOmittedFields();
-    if (!fieldName) {
-        return false;
-    }
-    return !!omittedFields[fieldName];
-}
-function hasNonOptionalIncomplete(fieldName) {
-    var optionalFields = useOptionalFields()[0];
-    return isNotEmpty(useAllIncomplete().filter(function (testObject) {
-        if (nonMatchingFieldName(testObject, fieldName)) {
-            return false;
-        }
-        return optionalFields[testObject.fieldName] !== true;
-    }));
-}
-function fieldDoesNotExist(fieldName) {
-    var testObjects = useTestsFlat();
-    return (!!fieldName &&
-        !testObjects.find(function (testObject) { return testObject.fieldName === fieldName; }));
-}
-function noMissingTests(fieldName) {
-    var testObjects = useTestsFlat();
-    var optionalFields = useOptionalFields()[0];
-    return testObjects.every(function (testObject) {
-        if (nonMatchingFieldName(testObject, fieldName)) {
-            return true;
-        }
-        return (optionalFields[testObject.fieldName] === true ||
-            testObject.isTested() ||
-            testObject.isOmitted());
-    });
+    var _a;
+    var summary = useSummary();
+    return fieldName ? Boolean((_a = summary.tests[fieldName]) === null || _a === void 0 ? void 0 : _a.valid) : summary.valid;
 }
 
-var cache$1 = createCache(20);
+var cache$1 = createCache(1);
 function produceSuiteResult() {
     var testObjects = useTestsFlat();
     var ctxRef = { stateRef: useStateRef() };
     return cache$1([testObjects], context.bind(ctxRef, function () {
+        var summary = genTestsSummary();
         var suiteName = useSuiteName();
-        return assign(genTestsSummary(), {
-            getErrors: context.bind(ctxRef, getErrors),
-            getErrorsByGroup: context.bind(ctxRef, getErrorsByGroup),
-            getWarnings: context.bind(ctxRef, getWarnings),
-            getWarningsByGroup: context.bind(ctxRef, getWarningsByGroup),
-            hasErrors: context.bind(ctxRef, hasErrors),
-            hasErrorsByGroup: context.bind(ctxRef, hasErrorsByGroup),
-            hasWarnings: context.bind(ctxRef, hasWarnings),
-            hasWarningsByGroup: context.bind(ctxRef, hasWarningsByGroup),
-            isValid: context.bind(ctxRef, isValid),
+        var ref = { summary: summary };
+        return assign(summary, {
+            getErrors: context.bind(ref, getErrors),
+            getErrorsByGroup: context.bind(ref, getErrorsByGroup),
+            getWarnings: context.bind(ref, getWarnings),
+            getWarningsByGroup: context.bind(ref, getWarningsByGroup),
+            hasErrors: context.bind(ref, hasErrors),
+            hasErrorsByGroup: context.bind(ref, hasErrorsByGroup),
+            hasWarnings: context.bind(ref, hasWarnings),
+            hasWarningsByGroup: context.bind(ref, hasWarningsByGroup),
+            isValid: context.bind(ref, isValid),
             suiteName: suiteName
         });
     }));
@@ -1060,14 +1036,13 @@ var done = function done() {
     return output;
 };
 function deferDoneCallback(doneCallback, fieldName) {
-    var deferredCallback = context.bind({}, doneCallback);
     var _a = useTestCallbacks(), setTestCallbacks = _a[1];
     setTestCallbacks(function (current) {
         if (fieldName) {
-            current.fieldCallbacks[fieldName] = (current.fieldCallbacks[fieldName] || []).concat(deferredCallback);
+            current.fieldCallbacks[fieldName] = (current.fieldCallbacks[fieldName] || []).concat(doneCallback);
         }
         else {
-            current.doneCallbacks.push(deferredCallback);
+            current.doneCallbacks.push(doneCallback);
         }
         return current;
     });
@@ -1077,19 +1052,22 @@ function createBus() {
     var listeners = {};
     return {
         emit: function (event, data) {
-            (listeners[event] || []).forEach(function (handler) {
+            listener(event).forEach(function (handler) {
                 handler(data);
             });
         },
         on: function (event, handler) {
-            listeners[event] = (listeners[event] || []).concat(handler);
+            listeners[event] = listener(event).concat(handler);
             return {
                 off: function () {
-                    listeners[event] = listeners[event].filter(function (h) { return h !== handler; });
+                    listeners[event] = listener(event).filter(function (h) { return h !== handler; });
                 }
             };
         }
     };
+    function listener(event) {
+        return listeners[event] || [];
+    }
 }
 
 function omitOptionalTests() {
@@ -1101,24 +1079,27 @@ function omitOptionalTests() {
     useSetTests(function (tests) {
         return transform(tests, function (testObject) {
             var fieldName = testObject.fieldName;
-            if (shouldOmit.hasOwnProperty(fieldName)) {
-                omit(testObject);
+            if (hasOwnProperty(shouldOmit, fieldName)) {
+                verifyAndOmit(testObject);
             }
             else {
-                var optionalConfig = optionalFields[fieldName];
-                if (isFunction(optionalConfig)) {
-                    shouldOmit[fieldName] = optionalConfig();
-                    omit(testObject);
-                }
+                runOptionalConfig(testObject);
             }
             return testObject;
         });
     });
-    function omit(testObject) {
+    function verifyAndOmit(testObject) {
         if (shouldOmit[testObject.fieldName]) {
             testObject.omit();
         }
     }
+    function runOptionalConfig(testObject) {
+        var optionalConfig = optionalFields[testObject.fieldName];
+        if (isFunction(optionalConfig)) {
+            shouldOmit[testObject.fieldName] = optionalConfig();
+            verifyAndOmit(testObject);
+        }
+    }
 }
 
 /**
@@ -1369,7 +1350,7 @@ function isExcluded(testObject) {
             return keyTests[fieldName] === false;
         }
     }
-    if (isMissingFromIncludedGroup(groupName)) {
+    if (isTopLevelWhenThereIsAnIncludedGroup(groupName)) {
         return true;
     }
     // if field is only'ed
@@ -1378,39 +1359,13 @@ function isExcluded(testObject) {
     // If there is _ANY_ `only`ed test (and we already know this one isn't) return true
     if (hasIncludedTests(keyTests)) {
         // Check if inclusion rules for this field (`include` hook)
+        // TODO: Check if this may need to be moved outside of the condition.
+        // What if there are no included tests? This shouldn't run then?
         return !optionalFunctionValue(inclusion[fieldName]);
     }
     // We're done here. This field is not excluded
     return false;
 }
-// eslint-disable-next-line max-statements
-function isMissingFromIncludedGroup(groupName) {
-    var context$1 = context.useX();
-    var exclusion = context$1.exclusion;
-    if (!hasIncludedGroups()) {
-        return false;
-    }
-    if (!groupName) {
-        return true;
-    }
-    if (groupName in exclusion.groups) {
-        if (exclusion.groups[groupName]) {
-            return false;
-        }
-        return true;
-    }
-    return true;
-}
-function hasIncludedGroups() {
-    var context$1 = context.useX();
-    var exclusion = context$1.exclusion;
-    for (var group in exclusion.groups) {
-        if (exclusion.groups[group]) {
-            return true;
-        }
-    }
-    return false;
-}
 /**
  * Checks whether a given group is excluded from running.
  */
@@ -1425,13 +1380,8 @@ function isGroupExcluded(groupName) {
         return keyGroups[groupName] === false;
     }
     // Group is not present
-    for (var group in keyGroups) {
-        // If any other group is only'ed
-        if (keyGroups[group] === true) {
-            return true;
-        }
-    }
-    return false;
+    // Return whether other groups are included
+    return hasIncludedGroups();
 }
 /**
  * Adds fields to a specified exclusion group.
@@ -1460,6 +1410,24 @@ function hasIncludedTests(keyTests) {
     }
     return false;
 }
+// are we not in a group and there is an included group?
+function isTopLevelWhenThereIsAnIncludedGroup(groupName) {
+    if (!hasIncludedGroups()) {
+        return false;
+    }
+    // Return whether there's an included group, and we're not inside a group
+    return !groupName;
+}
+function hasIncludedGroups() {
+    var context$1 = context.useX();
+    var exclusion = context$1.exclusion;
+    for (var group in exclusion.groups) {
+        if (exclusion.groups[group]) {
+            return true;
+        }
+    }
+    return false;
+}
 
 /**
  * Runs tests within a group so that they can be controlled or queried separately.
@@ -1485,16 +1453,18 @@ function groupErrorMsg(error) {
 function include(fieldName) {
     var context$1 = context.useX();
     var inclusion = context$1.inclusion, exclusion = context$1.exclusion;
-    if (!fieldName) {
-        return { when: when };
-    }
+    invariant(isStringValue(fieldName));
     inclusion[fieldName] = defaultTo(exclusion.tests[fieldName], true);
     return { when: when };
     function when(condition) {
         var context$1 = context.useX();
         var inclusion = context$1.inclusion, exclusion = context$1.exclusion;
+        // This callback will run as part of the "isExcluded" series of checks
         inclusion[fieldName] = function () {
             if (hasOwnProperty(exclusion.tests, fieldName)) {
+                // I suspect this code is technically unreachable because
+                // if there are any skip/only rules applied to the current
+                // field, the "isExcluded" function will have already bailed
                 return defaultTo(exclusion.tests[fieldName], true);
             }
             if (isStringValue(condition)) {
@@ -1528,7 +1498,7 @@ function eager() {
     setMode(Modes.EAGER);
 }
 function shouldSkipBasedOnMode(testObject) {
-    if (isEager() && hasErrors(testObject.fieldName))
+    if (isEager() && hasErrorsByTestObjects(testObject.fieldName))
         return true;
     return false;
 }
@@ -1595,6 +1565,31 @@ function optional(optionals) {
     });
 }
 
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+}
+
 function isPromise(value) {
     return value && isFunction(value.then);
 }
@@ -1640,6 +1635,8 @@ function runAsyncTest(testObject) {
         asyncTest.then(done, fail);
     }
     catch (e) {
+        // We will probably never get here, unless the consumer uses a buggy custom Promise
+        // implementation that behaves differently than the native one, or if they for some
         fail();
     }
 }
@@ -1648,22 +1645,7 @@ function runAsyncTest(testObject) {
  * Runs sync tests - or extracts promise.
  */
 function runSyncTest(testObject) {
-    return context.run({ currentTest: testObject }, function () {
-        var result;
-        try {
-            result = testObject.testFn();
-        }
-        catch (e) {
-            if (shouldUseErrorAsMessage(testObject.message, e)) {
-                testObject.message = e;
-            }
-            result = false;
-        }
-        if (result === false) {
-            testObject.fail();
-        }
-        return result;
-    });
+    return context.run({ currentTest: testObject }, function () { return testObject.run(); });
 }
 
 /**
@@ -1813,7 +1795,7 @@ function registerTestObjectByTier(testObject) {
 /* eslint-disable jest/valid-title */
 // eslint-disable-next-line max-lines-per-function
 function bindTestMemo(test) {
-    var cache = createCache(100); // arbitrary cache size
+    var cache = createCache(10); // arbitrary cache size
     // eslint-disable-next-line max-statements
     function memo(fieldName) {
         var args = [];
@@ -1882,6 +1864,6 @@ function warn() {
     ctx.currentTest.warn();
 }
 
-var VERSION = "4.2.3-dev-87ebfa";
+var VERSION = "4.3.2-dev-2805e3";
 
 export { VERSION, context, create, each, eager, group, include, omitWhen, only, optional, skip, skipWhen, test, warn };