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

package/dist/umd/vest.development.js

@@ -61,8 +61,13 @@
       return isNumeric(value) && isNumeric(gt) && Number(value) > Number(gt);
   }
 
+  function numberEquals(value, eq) {
+      return isNumeric(value) && isNumeric(eq) && Number(value) === Number(eq);
+  }
+  var numberNotEquals = bindNot(numberEquals);
+
   function greaterThanOrEquals(value, gte) {
-      return isNumeric(value) && isNumeric(gte) && Number(value) >= Number(gte);
+      return numberEquals(value, gte) || greaterThan(value, gte);
   }
 
   // The module is named "isArrayValue" since it
@@ -85,8 +90,12 @@
   }
   var notInside = bindNot(inside);
 
+  function lessThan(value, lt) {
+      return isNumeric(value) && isNumeric(lt) && Number(value) < Number(lt);
+  }
+
   function lessThanOrEquals(value, lte) {
-      return isNumeric(value) && isNumeric(lte) && Number(value) <= Number(lte);
+      return numberEquals(value, lte) || lessThan(value, lte);
   }
 
   function isBetween(value, min, max) {
@@ -118,7 +127,7 @@
   var isNotNumber = bindNot(isNumber);
 
   function lengthEquals(value, arg1) {
-      return value.length === Number(arg1);
+      return numberEquals(value.length, arg1);
   }
   var lengthNotEquals = bindNot(lengthEquals);
 
@@ -135,7 +144,7 @@
       else if (typeof value === 'object') {
           return lengthEquals(Object.keys(value), 0);
       }
-      return true;
+      return false;
   }
   var isNotEmpty = bindNot(isEmpty);
 
@@ -160,12 +169,8 @@
   var isNotNaN = bindNot(isNaN$1);
 
   function isNegative(value) {
-      if (isNumeric(value)) {
-          return Number(value) < 0;
-      }
-      return false;
+      return lessThan(value, 0);
   }
-  var isPositive = bindNot(isNegative);
 
   /**
    * Validates that a given value is an odd number
@@ -177,6 +182,10 @@
       return false;
   };
 
+  function isPositive(value) {
+      return greaterThan(value, 0);
+  }
+
   var isNotString = bindNot(isStringValue);
 
   function isTruthy(value) {
@@ -197,16 +206,12 @@
   }
   var isNotValueOf = bindNot(isValueOf);
 
-  function lessThan(value, lt) {
-      return isNumeric(value) && isNumeric(lt) && Number(value) < Number(lt);
-  }
-
   function longerThan(value, arg1) {
-      return value.length > Number(arg1);
+      return greaterThan(value.length, arg1);
   }
 
   function longerThanOrEquals(value, arg1) {
-      return value.length >= Number(arg1);
+      return greaterThanOrEquals(value.length, arg1);
   }
 
   function matches(value, regex) {
@@ -222,11 +227,6 @@
   }
   var notMatches = bindNot(matches);
 
-  function numberEquals(value, eq) {
-      return isNumeric(value) && isNumeric(eq) && Number(value) === Number(eq);
-  }
-  var numberNotEquals = bindNot(numberEquals);
-
   function condition(value, callback) {
       try {
           return callback(value);
@@ -237,11 +237,11 @@
   }
 
   function shorterThan(value, arg1) {
-      return value.length < Number(arg1);
+      return lessThan(value.length, arg1);
   }
 
   function shorterThanOrEquals(value, arg1) {
-      return value.length <= Number(arg1);
+      return lessThanOrEquals(value.length, arg1);
   }
 
   function startsWith(value, arg1) {
@@ -453,17 +453,6 @@
   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)) {
@@ -655,15 +644,10 @@
           context: function () { return ctx.useX(); },
           extend: function (customRules) {
               assign(baseRules, customRules);
+              handleNoProxy(); // TODO: REMOVE when we stop supporting ES5
           }
       };
-      if (!isProxySupported()) {
-          eachEnforceRule(function (ruleName) {
-              // Only on the first rule access - start the chain of calls
-              target[ruleName] = genEnforceLazy(ruleName);
-          });
-          return assign(enforceEager, target);
-      }
+      handleNoProxy();
       return new Proxy(assign(enforceEager, target), {
           get: function (target, key) {
               if (key in target) {
@@ -676,6 +660,15 @@
               return genEnforceLazy(key);
           }
       });
+      function handleNoProxy() {
+          if (!isProxySupported()) {
+              eachEnforceRule(function (ruleName) {
+                  // Only on the first rule access - start the chain of calls
+                  target[ruleName] = genEnforceLazy(ruleName);
+              });
+              return assign(enforceEager, target);
+          }
+      }
   }
   var enforce = genEnforce();
 
@@ -686,106 +679,100 @@
       return "".concat(n++);
   }; })(0);
 
-  // eslint-disable-next-line max-lines-per-function
-  function createState(onStateChange) {
-      var state = {
-          references: []
+  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);
+  }
+
+  /**
+   * 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;
       };
-      var registrations = [];
-      return {
-          registerStateKey: registerStateKey,
-          reset: reset
+      // invalidate an item in the cache by its dependencies
+      cache.invalidate = function (deps) {
+          var index = findIndex(deps);
+          if (index > -1)
+              cacheStorage.splice(index, 1);
       };
-      /**
-       * 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]);
+      // 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]; });
           });
       }
-      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);
+  }
+
+  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
+  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;
   }
 
   function createCursor() {
@@ -822,6 +809,16 @@
       };
   }
 
+  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";
@@ -849,99 +846,6 @@
           }, ctxRef);
   });
 
-  // 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));
-          }
-          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 deferThrow(message) {
-      setTimeout(function () {
-          throw new Error(message);
-      }, 0);
-  }
-
-  function shouldUseErrorAsMessage(message, error) {
-      // kind of cheating with this safe guard, but it does the job
-      return isUndefined(message) && isStringValue(error);
-  }
-
-  /**
-   * 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]; });
-          });
-      }
-  }
-
   // STATE REF
   function useStateRef() {
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -991,18 +895,6 @@
           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;
@@ -1157,6 +1049,95 @@
   var STATUS_CANCELED = 'CANCELED';
   var STATUS_OMITTED = 'OMITTED';
 
+  // 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 deferThrow(message) {
+      setTimeout(function () {
+          throw new Error(message);
+      }, 0);
+  }
+
   function usePath() {
       var context$1 = context.useX();
       return context$1.testCursor.getCursor();
@@ -1201,46 +1182,147 @@
       if (isNullish(current[key])) {
           current[key] = testObject;
       }
-      else {
-          deferThrow("Encountered the same test key \"".concat(key, "\" twice. This may lead to tests overriding each other's results, or to tests being unexpectedly omitted."));
+      else {
+          deferThrow("Encountered the same test key \"".concat(key, "\" twice. This may lead to tests overriding each other's results, or to tests being unexpectedly omitted."));
+      }
+  }
+
+  function isolate(_a, callback) {
+      var _b = _a.type, type = _b === void 0 ? IsolateTypes.DEFAULT : _b;
+      invariant(isFunction(callback));
+      var keys = {
+          current: {},
+          prev: {}
+      };
+      var path = usePath();
+      return context.run({ isolate: { type: type, keys: keys } }, function () {
+          addLevel();
+          keys.prev = usePrevKeys();
+          useSetTests(function (tests) { return setValueAtPath(tests, path, []); });
+          var res = callback();
+          removeLevel();
+          moveForward();
+          return res;
+      });
+  }
+  function shouldAllowReorder() {
+      return context.useX().isolate.type === IsolateTypes.EACH;
+  }
+
+  var Severity;
+  (function (Severity) {
+      Severity["WARNINGS"] = "warnings";
+      Severity["ERRORS"] = "errors";
+  })(Severity || (Severity = {}));
+  var SeverityCount;
+  (function (SeverityCount) {
+      SeverityCount["ERROR_COUNT"] = "errorCount";
+      SeverityCount["WARN_COUNT"] = "warnCount";
+  })(SeverityCount || (SeverityCount = {}));
+  function countKeyBySeverity(severity) {
+      return severity === Severity.ERRORS
+          ? SeverityCount.ERROR_COUNT
+          : SeverityCount.WARN_COUNT;
+  }
+
+  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;
   }
 
-  function isolate(_a, callback) {
-      var _b = _a.type, type = _b === void 0 ? IsolateTypes.DEFAULT : _b;
-      if (!isFunction(callback)) {
-          return;
+  // eslint-disable-next-line max-statements, complexity
+  function shouldAddValidProp(fieldName) {
+      if (fieldIsOmitted(fieldName)) {
+          return true;
       }
-      var keys = {
-          current: {},
-          prev: {}
-      };
-      var path = usePath();
-      return context.run({ isolate: { type: type, keys: keys } }, function () {
-          addLevel();
-          keys.prev = usePrevKeys();
-          useSetTests(function (tests) { return setValueAtPath(tests, path, []); });
-          var res = callback();
-          removeLevel();
-          moveForward();
-          return res;
-      });
+      if (hasErrorsByTestObjects(fieldName)) {
+          return false;
+      }
+      var testObjects = useTestsFlat();
+      if (isEmpty(testObjects)) {
+          return false;
+      }
+      if (hasNonOptionalIncomplete(fieldName)) {
+          return false;
+      }
+      return noMissingTests(fieldName);
   }
-  function shouldAllowReorder() {
-      return context.useX().isolate.type === IsolateTypes.EACH;
+  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());
+      });
   }
 
-  var Severity;
-  (function (Severity) {
-      Severity["WARNINGS"] = "warnings";
-      Severity["ERRORS"] = "errors";
-  })(Severity || (Severity = {}));
-  var SeverityCount;
-  (function (SeverityCount) {
-      SeverityCount["ERROR_COUNT"] = "errorCount";
-      SeverityCount["WARN_COUNT"] = "warnCount";
-  })(SeverityCount || (SeverityCount = {}));
-
+  function useSummary() {
+      var summary = context.useX().summary;
+      invariant(summary);
+      return summary;
+  }
   /**
    * Reads the testObjects list and gets full validation result from it.
    */
@@ -1248,17 +1330,24 @@
       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
@@ -1282,13 +1371,9 @@
       }
       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;
@@ -1301,18 +1386,13 @@
       }
       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,
@@ -1320,61 +1400,31 @@
           testCount: 0
       };
   }
-
-  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) {
@@ -1387,150 +1437,86 @@
    * @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);
-  }
-  /**
-   * 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
-      });
+      return getFailuresByGroup(groupName, Severity.WARNINGS, 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 getFailuresByGroup(groupName, severityKey, fieldName) {
+      var summary = useSummary();
+      return gatherFailures(summary.groups[groupName], severityKey, fieldName);
   }
 
   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;
-      });
+      return hasFailuresByGroup(Severity.WARNINGS, groupName, fieldName);
   }
-
-  // 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)) {
+  // 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;
       }
-      return noMissingTests(fieldName);
-  }
-  function fieldIsOmitted(fieldName) {
-      var omittedFields = useOmittedFields();
-      if (!fieldName) {
-          return false;
+      if (fieldName) {
+          return isPositive((_a = group[fieldName]) === null || _a === void 0 ? void 0 : _a[severityCount]);
       }
-      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)) {
+      for (var field in group) {
+          if (isPositive((_b = group[field]) === null || _b === void 0 ? void 0 : _b[severityCount])) {
               return true;
           }
-          return (optionalFields[testObject.fieldName] === true ||
-              testObject.isTested() ||
-              testObject.isOmitted());
-      });
+      }
+      return false;
+  }
+
+  function isValid(fieldName) {
+      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
           });
       }));
@@ -1599,14 +1585,13 @@
       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;
       });
@@ -1616,19 +1601,22 @@
       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() {
@@ -1640,24 +1628,27 @@
       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);
+          }
+      }
   }
 
   /**
@@ -1908,7 +1899,7 @@
               return keyTests[fieldName] === false;
           }
       }
-      if (isMissingFromIncludedGroup(groupName)) {
+      if (isTopLevelWhenThereIsAnIncludedGroup(groupName)) {
           return true;
       }
       // if field is only'ed
@@ -1917,39 +1908,13 @@
       // 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.
    */
@@ -1964,13 +1929,8 @@
           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.
@@ -1999,6 +1959,24 @@
       }
       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.
@@ -2024,16 +2002,18 @@
   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)) {
@@ -2067,7 +2047,7 @@
       setMode(Modes.EAGER);
   }
   function shouldSkipBasedOnMode(testObject) {
-      if (isEager() && hasErrors(testObject.fieldName))
+      if (isEager() && hasErrorsByTestObjects(testObject.fieldName))
           return true;
       return false;
   }
@@ -2179,6 +2159,8 @@
           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();
       }
   }
@@ -2187,22 +2169,7 @@
    * 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(); });
   }
 
   /**
@@ -2352,7 +2319,7 @@
   /* 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 = [];
@@ -2421,7 +2388,7 @@
       ctx.currentTest.warn();
   }
 
-  var VERSION = "4.2.3-dev-87ebfa";
+  var VERSION = "4.3.2-dev-2805e3";
 
   exports.VERSION = VERSION;
   exports.context = context;