vest 4.4.2 → 4.5.0

package/dist/umd/vest.development.js

@@ -4,12 +4,6 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.vest = {}));
 }(this, (function (exports) { 'use strict';
 
-  var assign = Object.assign;
-
-  function isFunction(value) {
-      return typeof value === 'function';
-  }
-
   function bindNot(fn) {
       return function () {
           var args = [];
@@ -20,6 +14,69 @@
       };
   }
 
+  function isNumeric(value) {
+      var str = String(value);
+      var num = Number(value);
+      var result = !isNaN(parseFloat(str)) && !isNaN(Number(value)) && isFinite(num);
+      return Boolean(result);
+  }
+  var isNotNumeric = bindNot(isNumeric);
+
+  function numberEquals(value, eq) {
+      return isNumeric(value) && isNumeric(eq) && Number(value) === Number(eq);
+  }
+  var numberNotEquals = bindNot(numberEquals);
+
+  function lengthEquals(value, arg1) {
+      return numberEquals(value.length, arg1);
+  }
+  var lengthNotEquals = bindNot(lengthEquals);
+
+  function greaterThan(value, gt) {
+      return isNumeric(value) && isNumeric(gt) && Number(value) > Number(gt);
+  }
+
+  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]; });
+          });
+      }
+  }
+
   function isNull(value) {
       return value === null;
   }
@@ -35,39 +92,25 @@
   }
   var isNotNullish = bindNot(isNullish);
 
-  function isStringValue(v) {
-      return String(v) === v;
-  }
-
-  function endsWith(value, arg1) {
-      return isStringValue(value) && isStringValue(arg1) && value.endsWith(arg1);
-  }
-  var doesNotEndWith = bindNot(endsWith);
-
-  function equals(value, arg1) {
-      return value === arg1;
-  }
-  var notEquals = bindNot(equals);
-
-  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 asArray(possibleArg) {
+      return [].concat(possibleArg);
   }
-  var isNotNumeric = bindNot(isNumeric);
 
-  function greaterThan(value, gt) {
-      return isNumeric(value) && isNumeric(gt) && Number(value) > Number(gt);
+  function isFunction(value) {
+      return typeof value === 'function';
   }
 
-  function numberEquals(value, eq) {
-      return isNumeric(value) && isNumeric(eq) && Number(value) === Number(eq);
+  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;
   }
-  var numberNotEquals = bindNot(numberEquals);
 
-  function greaterThanOrEquals(value, gte) {
-      return numberEquals(value, gte) || greaterThan(value, gte);
+  function defaultTo(value, defaultValue) {
+      var _a;
+      return (_a = optionalFunctionValue(value)) !== null && _a !== void 0 ? _a : optionalFunctionValue(defaultValue);
   }
 
   // The module is named "isArrayValue" since it
@@ -78,53 +121,154 @@
   }
   var isNotArray = bindNot(isArray);
 
-  function inside(value, arg1) {
-      if (isArray(arg1)) {
-          return arg1.indexOf(value) !== -1;
+  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));
+          }
+          else {
+              var output = cb(v);
+              if (isNotNull(output)) {
+                  res.push(output);
+              }
+          }
       }
-      // both value and arg1 are strings
-      if (isStringValue(arg1) && isStringValue(value)) {
-          return arg1.indexOf(value) !== -1;
+      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 false;
+      return current;
   }
-  var notInside = bindNot(inside);
 
-  function lessThan(value, lt) {
-      return isNumeric(value) && isNumeric(lt) && Number(value) < Number(lt);
+  function callEach(arr) {
+      return arr.forEach(function (fn) { return fn(); });
   }
 
-  function lessThanOrEquals(value, lte) {
-      return numberEquals(value, lte) || lessThan(value, lte);
+  /**
+   * A safe hasOwnProperty access
+   */
+  function hasOwnProperty(obj, key) {
+      return Object.prototype.hasOwnProperty.call(obj, key);
   }
 
-  function isBetween(value, min, max) {
-      return greaterThanOrEquals(value, min) && lessThanOrEquals(value, max);
+  function isPromise(value) {
+      return value && isFunction(value.then);
   }
-  var isNotBetween = bindNot(isBetween);
 
-  function isBlank(value) {
-      return isNullish(value) || (isStringValue(value) && !value.trim());
+  var assign = Object.assign;
+
+  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 @typescript-eslint/ban-types
+  function StringObject(value) {
+      return new String(optionalFunctionValue(value));
+  }
+
+  function isStringValue(v) {
+      return String(v) === v;
+  }
+
+  function either(a, b) {
+      return !!a !== !!b;
   }
-  var isNotBlank = bindNot(isBlank);
 
   function isBoolean(value) {
       return !!value === value;
   }
 
-  var isNotBoolean = bindNot(isBoolean);
+  function deferThrow(message) {
+      setTimeout(function () {
+          throw new Error(message);
+      }, 0);
+  }
+
+  function createBus() {
+      var listeners = {};
+      return {
+          emit: function (event, data) {
+              listener(event).forEach(function (handler) {
+                  handler(data);
+              });
+          },
+          on: function (event, handler) {
+              listeners[event] = listener(event).concat(handler);
+              return {
+                  off: function () {
+                      listeners[event] = listener(event).filter(function (h) { return h !== handler; });
+                  }
+              };
+          }
+      };
+      function listener(event) {
+          return listeners[event] || [];
+      }
+  }
 
   /**
-   * A safe hasOwnProperty access
+   * @returns a unique numeric id.
    */
-  function hasOwnProperty(obj, key) {
-      return Object.prototype.hasOwnProperty.call(obj, key);
-  }
+  var seq = (function (n) { return function () {
+      return "".concat(n++);
+  }; })(0);
 
-  function lengthEquals(value, arg1) {
-      return numberEquals(value.length, arg1);
+  function mapFirst(array, callback) {
+      var broke = false;
+      var breakoutValue = null;
+      for (var i = 0; i < array.length; i++) {
+          callback(array[i], breakout, i);
+          if (broke) {
+              return breakoutValue;
+          }
+      }
+      function breakout(conditional, value) {
+          if (conditional) {
+              broke = true;
+              breakoutValue = value;
+          }
+      }
   }
-  var lengthNotEquals = bindNot(lengthEquals);
 
   function isEmpty(value) {
       if (!value) {
@@ -140,6 +284,56 @@
   }
   var isNotEmpty = bindNot(isEmpty);
 
+  function isPositive(value) {
+      return greaterThan(value, 0);
+  }
+
+  function endsWith(value, arg1) {
+      return isStringValue(value) && isStringValue(arg1) && value.endsWith(arg1);
+  }
+  var doesNotEndWith = bindNot(endsWith);
+
+  function equals(value, arg1) {
+      return value === arg1;
+  }
+  var notEquals = bindNot(equals);
+
+  function greaterThanOrEquals(value, gte) {
+      return numberEquals(value, gte) || greaterThan(value, gte);
+  }
+
+  function inside(value, arg1) {
+      if (isArray(arg1)) {
+          return arg1.indexOf(value) !== -1;
+      }
+      // both value and arg1 are strings
+      if (isStringValue(arg1) && isStringValue(value)) {
+          return arg1.indexOf(value) !== -1;
+      }
+      return false;
+  }
+  var notInside = bindNot(inside);
+
+  function lessThan(value, lt) {
+      return isNumeric(value) && isNumeric(lt) && Number(value) < Number(lt);
+  }
+
+  function lessThanOrEquals(value, lte) {
+      return numberEquals(value, lte) || lessThan(value, lte);
+  }
+
+  function isBetween(value, min, max) {
+      return greaterThanOrEquals(value, min) && lessThanOrEquals(value, max);
+  }
+  var isNotBetween = bindNot(isBetween);
+
+  function isBlank(value) {
+      return isNullish(value) || (isStringValue(value) && !value.trim());
+  }
+  var isNotBlank = bindNot(isBlank);
+
+  var isNotBoolean = bindNot(isBoolean);
+
   /**
    * Validates that a given value is an even number
    */
@@ -179,10 +373,6 @@
       return false;
   };
 
-  function isPositive(value) {
-      return greaterThan(value, 0);
-  }
-
   var isNotString = bindNot(isStringValue);
 
   function isTruthy(value) {
@@ -203,10 +393,6 @@
   }
   var isNotValueOf = bindNot(isValueOf);
 
-  function longerThan(value, arg1) {
-      return greaterThan(value.length, arg1);
-  }
-
   function longerThanOrEquals(value, arg1) {
       return greaterThanOrEquals(value.length, arg1);
   }
@@ -318,46 +504,15 @@
       return baseRules[ruleName];
   }
 
-  function eachEnforceRule(action) {
-      for (var ruleName in baseRules) {
-          var ruleFn = getRule(ruleName);
-          if (isFunction(ruleFn)) {
-              action(ruleName, ruleFn);
-          }
-      }
-  }
-
-  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(value, defaultValue) {
-      var _a;
-      return (_a = optionalFunctionValue(value)) !== null && _a !== void 0 ? _a : optionalFunctionValue(defaultValue);
-  }
-
-  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 @typescript-eslint/ban-types
-  function StringObject(value) {
-      return new String(optionalFunctionValue(value));
-  }
-
+  function eachEnforceRule(action) {
+      for (var ruleName in baseRules) {
+          var ruleFn = getRule(ruleName);
+          if (isFunction(ruleFn)) {
+              action(ruleName, ruleFn);
+          }
+      }
+  }
+
   // eslint-disable-next-line max-lines-per-function
   function createContext(init) {
       var storage = { ancestry: [] };
@@ -512,30 +667,47 @@
 
   function enforceEager(value) {
       var target = {};
+      // This condition is for when we don't have proxy support (ES5).
+      // In this case, we need to manually assign the rules to the target object on runtime.
+      // The follow up proxy block is used in case we do have proxy support, and we can assign each rule upon invocation.
       if (!isProxySupported()) {
+          // We iterate over each of the rules, and add them to the target object being return by enforce
           eachEnforceRule(function (ruleName, ruleFn) {
+              // We then wrap the rule with `genRuleCall` that adds the base enforce behavior
               target[ruleName] = genRuleCall(target, ruleFn, ruleName);
           });
           return target;
       }
+      // We create a proxy intercepting access to the target object (which is empty).
       var proxy = new Proxy(target, {
           get: function (_, ruleName) {
+              // On property access, we identify if it is a rule or not.
               var rule = getRule(ruleName);
+              // If it is a rule, we wrap it with `genRuleCall` that adds the base enforce behavior
               if (rule) {
                   return genRuleCall(proxy, rule, ruleName);
               }
           }
       });
       return proxy;
+      // This function is used to wrap a rule with the base enforce behavior
+      // It takes the target object, the rule function, and the rule name
+      // It then returns the rule, in a manner that can be used by enforce
       function genRuleCall(target, rule, ruleName) {
           return function ruleCall() {
               var args = [];
               for (var _i = 0; _i < arguments.length; _i++) {
                   args[_i] = arguments[_i];
               }
+              // Order of operation:
+              // 1. Create a context with the value being enforced
+              // 2. Call the rule within the context, and pass over the arguments passed to it
+              // 3. Transform the result to the correct output format
               var transformedResult = ctx.run({ value: value }, function () {
                   return transformResult.apply(void 0, __spreadArray([rule.apply(void 0, __spreadArray([value], args, false)), ruleName, value], args, false));
               });
+              // On rule failure (the result is false), we either throw an error
+              // or throw a string value if the rule has a message defined in it.
               invariant(transformedResult.pass, isNullish(transformedResult.message)
                   ? "enforce/".concat(ruleName, " failed with ").concat(JSON.stringify(value))
                   : StringObject(transformedResult.message));
@@ -544,23 +716,6 @@
       }
   }
 
-  function mapFirst(array, callback) {
-      var broke = false;
-      var breakoutValue = null;
-      for (var i = 0; i < array.length; i++) {
-          callback(array[i], breakout, i);
-          if (broke) {
-              return breakoutValue;
-          }
-      }
-      function breakout(conditional, value) {
-          if (conditional) {
-              broke = true;
-              breakoutValue = value;
-          }
-      }
-  }
-
   // eslint-disable-next-line max-lines-per-function
   function genEnforceLazy(key) {
       var registeredRules = [];
@@ -674,109 +829,11 @@
   }
   var enforce = genEnforce();
 
-  /**
-   * @returns a unique numeric id.
-   */
-  var genId = (function (n) { return function () {
-      return "".concat(n++);
-  }; })(0);
-
   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;
-      };
-      // 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]; });
-          });
-      }
-  }
-
-  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));
-          }
-          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;
-  }
-
   var IsolateTypes;
   (function (IsolateTypes) {
       IsolateTypes[IsolateTypes["DEFAULT"] = 0] = "DEFAULT";
@@ -831,7 +888,7 @@
   var context = createContext(function (ctxRef, parentContext) {
       return parentContext
           ? null
-          : assign({}, {
+          : assign({
               exclusion: {
                   tests: {},
                   groups: {}
@@ -922,7 +979,7 @@
       function VestTest(fieldName, testFn, _a) {
           var _b = _a === void 0 ? {} : _a, message = _b.message, groupName = _b.groupName, key = _b.key;
           this.key = null;
-          this.id = genId();
+          this.id = seq();
           this.severity = TestSeverity.Error;
           this.status = STATUS_UNTESTED;
           this.fieldName = fieldName;
@@ -1140,10 +1197,24 @@
       };
   }
 
-  function deferThrow(message) {
-      setTimeout(function () {
-          throw new Error(message);
-      }, 0);
+  /**
+   * @returns {Isolate} The current isolate layer
+   */
+  function useIsolate() {
+      return context.useX().isolate;
+  }
+  /**
+   * @returns {number[]} The current cursor path of the isolate tree
+   */
+  function useCurrentPath() {
+      var isolate = useIsolate();
+      return isolate.path.concat(isolate.cursor.current());
+  }
+  /**
+   * @returns {IsolateCursor} The cursor object for the current isolate
+   */
+  function useCursor() {
+      return useIsolate().cursor;
   }
 
   function usePrevKeys() {
@@ -1188,31 +1259,12 @@
       useCursor().next();
       return output;
   }
-  /**
-   * @returns {Isolate} The current isolate layer
-   */
-  function useIsolate() {
-      return context.useX().isolate;
-  }
   /**
    * @returns {boolean} Whether or not the current isolate allows tests to be reordered
    */
   function shouldAllowReorder() {
       return useIsolate().type === IsolateTypes.EACH;
   }
-  /**
-   * @returns {number[]} The current cursor path of the isolate tree
-   */
-  function useCurrentPath() {
-      var isolate = useIsolate();
-      return isolate.path.concat(isolate.cursor.current());
-  }
-  /**
-   * @returns {IsolateCursor} The cursor object for the current isolate
-   */
-  function useCursor() {
-      return useIsolate().cursor;
-  }
 
   var Severity;
   (function (Severity) {
@@ -1242,10 +1294,6 @@
       return testObject.groupName === groupName;
   }
 
-  function either(a, b) {
-      return !!a !== !!b;
-  }
-
   /**
    * Checks that a given test object matches the currently specified severity level
    */
@@ -1376,11 +1424,6 @@
           testObject.isOmitted());
   }
 
-  function useSummary() {
-      var summary = context.useX().summary;
-      invariant(summary);
-      return summary;
-  }
   /**
    * Reads the testObjects list and gets full validation result from it.
    */
@@ -1492,57 +1535,85 @@
       return output;
   }
 
-  function getErrors(fieldName) {
-      return getFailures(Severity.ERRORS, fieldName);
-  }
-  function getWarnings(fieldName) {
-      return getFailures(Severity.WARNINGS, fieldName);
+  // eslint-disable-next-line max-lines-per-function, max-statements
+  function suiteSelectors(summary) {
+      var selectors = {
+          getErrors: getErrors,
+          getErrorsByGroup: getErrorsByGroup,
+          getWarnings: getWarnings,
+          getWarningsByGroup: getWarningsByGroup,
+          hasErrors: hasErrors,
+          hasErrorsByGroup: hasErrorsByGroup,
+          hasWarnings: hasWarnings,
+          hasWarningsByGroup: hasWarningsByGroup,
+          isValid: isValid,
+          isValidByGroup: isValidByGroup
+      };
+      return selectors;
+      // Booleans
+      function isValid(fieldName) {
+          var _a;
+          return fieldName ? Boolean((_a = summary.tests[fieldName]) === null || _a === void 0 ? void 0 : _a.valid) : summary.valid;
+      }
+      function isValidByGroup(groupName, fieldName) {
+          var group = summary.groups[groupName];
+          if (!group) {
+              return false;
+          }
+          if (fieldName) {
+              return isFieldValid(group, fieldName);
+          }
+          for (var fieldName_1 in group) {
+              if (!isFieldValid(group, fieldName_1)) {
+                  return false;
+              }
+          }
+          return true;
+      }
+      function hasWarnings(fieldName) {
+          return hasFailures(summary, SeverityCount.WARN_COUNT, fieldName);
+      }
+      function hasErrors(fieldName) {
+          return hasFailures(summary, SeverityCount.ERROR_COUNT, fieldName);
+      }
+      function hasWarningsByGroup(groupName, fieldName) {
+          return hasFailuresByGroup(summary, SeverityCount.WARN_COUNT, groupName, fieldName);
+      }
+      function hasErrorsByGroup(groupName, fieldName) {
+          return hasFailuresByGroup(summary, SeverityCount.ERROR_COUNT, groupName, fieldName);
+      }
+      function getWarnings(fieldName) {
+          return getFailures(summary, Severity.WARNINGS, fieldName);
+      }
+      function getErrors(fieldName) {
+          return getFailures(summary, Severity.ERRORS, fieldName);
+      }
+      function getErrorsByGroup(groupName, fieldName) {
+          return getFailuresByGroup(summary, Severity.ERRORS, groupName, fieldName);
+      }
+      function getWarningsByGroup(groupName, fieldName) {
+          return getFailuresByGroup(summary, Severity.WARNINGS, groupName, fieldName);
+      }
   }
-  /**
-   * @returns suite or field's errors or warnings.
-   */
-  function getFailures(severityKey, fieldName) {
-      var summary = useSummary();
+  // Gathers all failures of a given severity
+  // With a fieldName, it will only gather failures for that field
+  function getFailures(summary, severityKey, fieldName) {
       return gatherFailures(summary.tests, severityKey, fieldName);
   }
-
-  function getErrorsByGroup(groupName, fieldName) {
-      return getFailuresByGroup(groupName, Severity.ERRORS, fieldName);
-  }
-  function getWarningsByGroup(groupName, fieldName) {
-      return getFailuresByGroup(groupName, Severity.WARNINGS, fieldName);
-  }
-  function getFailuresByGroup(groupName, severityKey, fieldName) {
-      var summary = useSummary();
+  // Gathers all failures of a given severity within a group
+  // With a fieldName, it will only gather failures for that field
+  function getFailuresByGroup(summary, severityKey, groupName, fieldName) {
       return gatherFailures(summary.groups[groupName], severityKey, fieldName);
   }
-
-  function hasErrors(fieldName) {
-      return hasFailures(SeverityCount.ERROR_COUNT, fieldName);
-  }
-  function hasWarnings(fieldName) {
-      return hasFailures(SeverityCount.WARN_COUNT, fieldName);
-  }
-  function hasFailures(severityCount, fieldName) {
+  // Checks if a field is valid within a container object - can be within a group or top level
+  function isFieldValid(testContainer, 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 hasFailuresByGroup(Severity.ERRORS, groupName, fieldName);
-  }
-  function hasWarningsByGroup(groupName, fieldName) {
-      return hasFailuresByGroup(Severity.WARNINGS, groupName, fieldName);
+      return !!((_a = testContainer[fieldName]) === null || _a === void 0 ? void 0 : _a.valid);
   }
-  // eslint-disable-next-line max-statements
-  function hasFailuresByGroup(severityKey, groupName, fieldName) {
+  // Checks if a there are any failures of a given severity within a group
+  // If a fieldName is provided, it will only check for failures within that field
+  function hasFailuresByGroup(summary, severityCount, groupName, fieldName) {
       var _a, _b;
-      var summary = useSummary();
-      var severityCount = countKeyBySeverity(severityKey);
       var group = summary.groups[groupName];
       if (!group) {
           return false;
@@ -1557,32 +1628,14 @@
       }
       return false;
   }
-
-  function isValid(fieldName) {
-      var summary = useSummary();
-      return fieldName
-          ? Boolean(isFieldValid(summary.tests, fieldName))
-          : summary.valid;
-  }
-  function isValidByGroup(groupName, fieldName) {
-      var summary = useSummary();
-      var group = summary.groups[groupName];
-      if (!group) {
-          return false;
-      }
-      if (fieldName) {
-          return isFieldValid(group, fieldName);
-      }
-      for (var fieldName_1 in group) {
-          if (!isFieldValid(group, fieldName_1)) {
-              return false;
-          }
-      }
-      return true;
-  }
-  function isFieldValid(testContainer, fieldName) {
+  // Checks if there are any failures of a given severity
+  // If a fieldName is provided, it will only check for failures within that field
+  function hasFailures(summary, countKey, fieldName) {
       var _a;
-      return !!((_a = testContainer[fieldName]) === null || _a === void 0 ? void 0 : _a.valid);
+      var failureCount = fieldName
+          ? (_a = summary.tests[fieldName]) === null || _a === void 0 ? void 0 : _a[countKey]
+          : summary[countKey] || 0;
+      return isPositive(failureCount);
   }
 
   var cache$1 = createCache(1);
@@ -1592,18 +1645,7 @@
       return cache$1([testObjects], context.bind(ctxRef, function () {
           var summary = genTestsSummary();
           var suiteName = useSuiteName();
-          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),
-              isValidByGroup: context.bind(ref, isValidByGroup),
+          return assign(summary, suiteSelectors(summary), {
               suiteName: suiteName
           });
       }));
@@ -1622,7 +1664,7 @@
               return matchingFieldName(testObject, fieldName);
           });
       }
-      return isNotEmpty(allIncomplete);
+      return true;
   }
 
   var cache = createCache(20);
@@ -1639,10 +1681,10 @@
    * DONE is here and not in its own module to prevent circular dependency issues.
    */
   function shouldSkipDoneRegistration(callback, fieldName, output) {
+      var _a;
       // If we do not have any test runs for the current field
       return !!(!isFunction(callback) ||
-          (fieldName &&
-              (!output.tests[fieldName] || isEmpty(output.tests[fieldName].testCount))));
+          (fieldName && numberEquals((_a = output.tests[fieldName]) === null || _a === void 0 ? void 0 : _a.testCount, 0)));
   }
   function shouldRunDoneCallback(fieldName) {
       // is suite finished || field name exists, and test is finished;
@@ -1684,28 +1726,6 @@
       });
   }
 
-  function createBus() {
-      var listeners = {};
-      return {
-          emit: function (event, data) {
-              listener(event).forEach(function (handler) {
-                  handler(data);
-              });
-          },
-          on: function (event, handler) {
-              listeners[event] = listener(event).concat(handler);
-              return {
-                  off: function () {
-                      listeners[event] = listener(event).filter(function (h) { return h !== handler; });
-                  }
-              };
-          }
-      };
-      function listener(event) {
-          return listeners[event] || [];
-      }
-  }
-
   function omitOptionalFields() {
       var optionalFields = useOptionalFields()[0];
       if (isEmpty(optionalFields)) {
@@ -1748,10 +1768,6 @@
       });
   }
 
-  function callEach(arr) {
-      return arr.forEach(function (fn) { return fn(); });
-  }
-
   /**
    * Runs done callback per field when async tests are finished running.
    */
@@ -1773,10 +1789,10 @@
 
   // eslint-disable-next-line max-lines-per-function
   function initBus() {
-      var bus = createBus();
+      var vestBus = createBus();
       // Report a the completion of a test. There may be other tests with the same
       // name that are still running, or not yet started.
-      bus.on(Events.TEST_COMPLETED, function (testObject) {
+      vestBus.on(Events.TEST_COMPLETED, function (testObject) {
           if (testObject.isCanceled()) {
               return;
           }
@@ -1784,21 +1800,21 @@
           runFieldCallbacks(testObject.fieldName);
           if (!hasRemainingTests()) {
               // When no more tests are running, emit the done event
-              bus.emit(Events.ALL_RUNNING_TESTS_FINISHED);
+              vestBus.emit(Events.ALL_RUNNING_TESTS_FINISHED);
           }
       });
       // Report that the suite completed its synchronous test run.
       // Async operations may still be running.
-      bus.on(Events.SUITE_CALLBACK_DONE_RUNNING, function () {
+      vestBus.on(Events.SUITE_CALLBACK_DONE_RUNNING, function () {
           // Remove tests that are optional and need to be omitted
           omitOptionalFields();
       });
       // Called when all the tests, including async, are done running
-      bus.on(Events.ALL_RUNNING_TESTS_FINISHED, function () {
+      vestBus.on(Events.ALL_RUNNING_TESTS_FINISHED, function () {
           runDoneCallbacks();
       });
       // Removes a certain field from the state.
-      bus.on(Events.REMOVE_FIELD, function (fieldName) {
+      vestBus.on(Events.REMOVE_FIELD, function (fieldName) {
           useEachTestObject(function (testObject) {
               if (matchingFieldName(testObject, fieldName)) {
                   testObject.cancel();
@@ -1807,14 +1823,14 @@
           });
       });
       // Resets a certain field in the state.
-      bus.on(Events.RESET_FIELD, function (fieldName) {
+      vestBus.on(Events.RESET_FIELD, function (fieldName) {
           useEachTestObject(function (testObject) {
               if (matchingFieldName(testObject, fieldName)) {
                   testObject.reset();
               }
           });
       });
-      return bus;
+      return vestBus;
   }
   function useBus() {
       var context$1 = context.useX();
@@ -1843,7 +1859,7 @@
       // State initialization
       var state = createState();
       // State reference - this holds the actual state values
-      var stateRef = createStateRef(state, { suiteId: genId(), suiteName: suiteName });
+      var stateRef = createStateRef(state, { suiteId: seq(), suiteName: suiteName });
       // Create base context reference. All hooks will derive their data from this
       var ctxRef = { stateRef: stateRef, bus: bus };
       var suite = assign(
@@ -1938,10 +1954,10 @@
    * only('username');
    */
   function only(item) {
-      return addTo(0 /* ONLY */, 'tests', item);
+      return addTo(0 /* ExclusionGroup.ONLY */, 'tests', item);
   }
   only.group = function (item) {
-      return addTo(0 /* ONLY */, 'groups', item);
+      return addTo(0 /* ExclusionGroup.ONLY */, 'groups', item);
   };
   /**
    * Adds a field or a list of fields into the exclusion list
@@ -1951,13 +1967,13 @@
    * skip('username');
    */
   function skip(item) {
-      return addTo(1 /* SKIP */, 'tests', item);
+      return addTo(1 /* ExclusionGroup.SKIP */, 'tests', item);
   }
   skip.group = function (item) {
-      return addTo(1 /* SKIP */, 'groups', item);
+      return addTo(1 /* ExclusionGroup.SKIP */, 'groups', item);
   };
   //Checks whether a certain test profile excluded by any of the exclusion groups.
-  // eslint-disable-next-line complexity, max-statements, max-lines-per-function
+  // eslint-disable-next-line complexity, max-statements
   function isExcluded(testObject) {
       var fieldName = testObject.fieldName, groupName = testObject.groupName;
       if (isExcludedIndividually())
@@ -2033,7 +2049,7 @@
               return;
           }
           context$1.exclusion[itemType][itemName] =
-              exclusionGroup === 0 /* ONLY */;
+              exclusionGroup === 0 /* ExclusionGroup.ONLY */;
       });
   }
   /**
@@ -2199,10 +2215,6 @@
       }
   }
 
-  function isPromise(value) {
-      return value && isFunction(value.then);
-  }
-
   function isSameProfileTest(testObject1, testObject2) {
       return (testObject1.fieldName === testObject2.fieldName &&
           testObject1.groupName === testObject2.groupName);
@@ -2396,7 +2408,6 @@
   }
 
   /* eslint-disable jest/valid-title */
-  // eslint-disable-next-line max-lines-per-function
   function bindTestMemo(test) {
       var cache = createCache(10); // arbitrary cache size
       // eslint-disable-next-line max-statements
@@ -2467,7 +2478,7 @@
       ctx.currentTest.warn();
   }
 
-  var VERSION = "4.4.2";
+  var VERSION = "4.5.0";
 
   exports.VERSION = VERSION;
   exports.context = context;
@@ -2482,6 +2493,7 @@
   exports.optional = optional;
   exports.skip = skip;
   exports.skipWhen = skipWhen;
+  exports.suiteSelectors = suiteSelectors;
   exports.test = test;
   exports.warn = warn;