vest 4.2.2 → 4.3.1

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);
 
@@ -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) {
@@ -343,16 +343,18 @@
       return (_a = optionalFunctionValue(callback)) !== null && _a !== void 0 ? _a : defaultValue;
   }
 
-  /**
-   * Throws a timed out error.
-   */
-  function throwError(devMessage, productionMessage) {
-      throw new Error(devMessage );
-  }
-  function throwErrorDeferred(devMessage, productionMessage) {
-      setTimeout(function () {
-          throwError(devMessage);
-      }, 0);
+  function 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
@@ -365,8 +367,8 @@
           useX: useX
       };
       function useX(errorMessage) {
-          var _a;
-          return ((_a = storage.ctx) !== null && _a !== void 0 ? _a : throwError(defaultTo(errorMessage, 'Context was used after it was closed')));
+          invariant(storage.ctx, defaultTo(errorMessage, 'Context was used after it was closed'));
+          return storage.ctx;
       }
       function run(ctxRef, fn) {
           var _a;
@@ -451,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)) {
@@ -514,10 +505,7 @@
   }
   function validateResult(result) {
       // if result is boolean, or if result.pass is boolean
-      if (isBoolean(result) || (result && isBoolean(result.pass))) {
-          return;
-      }
-      throwError('Incorrect return value for rule: ' + JSON.stringify(result));
+      invariant(isBoolean(result) || (result && isBoolean(result.pass)), 'Incorrect return value for rule: ' + JSON.stringify(result));
   }
 
   function enforceEager(value) {
@@ -546,15 +534,9 @@
               var transformedResult = transformResult.apply(void 0, __spreadArray([ctx.run({ value: value }, function () { return rule.apply(void 0, __spreadArray([value], args, false)); }),
                   ruleName,
                   value], args, false));
-              if (!transformedResult.pass) {
-                  if (isEmpty(transformedResult.message)) {
-                      throwError("enforce/".concat(ruleName, " failed with ").concat(JSON.stringify(value)));
-                  }
-                  else {
-                      // Explicitly throw a string so that vest.test can pick it up as the validation error message
-                      throw transformedResult.message;
-                  }
-              }
+              invariant(transformedResult.pass, isEmpty(transformedResult.message)
+                  ? "enforce/".concat(ruleName, " failed with ").concat(JSON.stringify(value))
+                  : new String(transformedResult.message));
               return target;
           };
       }
@@ -1158,6 +1140,12 @@
       };
   }
 
+  function deferThrow(message) {
+      setTimeout(function () {
+          throw new Error(message);
+      }, 0);
+  }
+
   function usePath() {
       var context$1 = context.useX();
       return context$1.testCursor.getCursor();
@@ -1203,7 +1191,7 @@
           current[key] = testObject;
       }
       else {
-          throwErrorDeferred("Encountered the same test key \"".concat(key, "\" twice. This may lead to tests overriding each other's results, or to tests being unexpectedly omitted."));
+          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."));
       }
   }
 
@@ -1236,71 +1224,11 @@
       Severity["WARNINGS"] = "warnings";
       Severity["ERRORS"] = "errors";
   })(Severity || (Severity = {}));
-
-  /**
-   * Reads the testObjects list and gets full validation result from it.
-   */
-  function genTestsSummary() {
-      var testObjects = useTestsFlat();
-      var summary = assign(baseStats(), {
-          groups: {},
-          tests: {}
-      });
-      appendSummary(testObjects);
-      return countFailures(summary);
-      function appendSummary(testObjects) {
-          testObjects.forEach(function (testObject) {
-              var fieldName = testObject.fieldName, groupName = testObject.groupName;
-              summary.tests[fieldName] = genTestObject(summary.tests, testObject);
-              if (groupName) {
-                  summary.groups[groupName] = summary.groups[groupName] || {};
-                  summary.groups[groupName][fieldName] = genTestObject(summary.groups[groupName], testObject);
-              }
-          });
-      }
-  }
-  /**
-   * Counts the failed tests and adds global counters
-   */
-  function countFailures(summary) {
-      for (var test in summary.tests) {
-          summary.errorCount += summary.tests[test].errorCount;
-          summary.warnCount += summary.tests[test].warnCount;
-          summary.testCount += summary.tests[test].testCount;
-      }
-      return summary;
-  }
-  // eslint-disable-next-line max-statements
-  function genTestObject(summaryKey, testObject) {
-      var fieldName = testObject.fieldName, message = testObject.message;
-      summaryKey[fieldName] = summaryKey[fieldName] || baseStats();
-      var testKey = summaryKey[fieldName];
-      if (testObject.isNonActionable())
-          return testKey;
-      summaryKey[fieldName].testCount++;
-      // Adds to severity group
-      function addTo(severity) {
-          var countKey = severity === Severity.ERRORS ? 'errorCount' : 'warnCount';
-          testKey[countKey]++;
-          if (message) {
-              testKey[severity] = (testKey[severity] || []).concat(message);
-          }
-      }
-      if (testObject.isFailing()) {
-          addTo(Severity.ERRORS);
-      }
-      else if (testObject.isWarning()) {
-          addTo(Severity.WARNINGS);
-      }
-      return testKey;
-  }
-  function baseStats() {
-      return {
-          errorCount: 0,
-          warnCount: 0,
-          testCount: 0
-      };
-  }
+  var SeverityCount;
+  (function (SeverityCount) {
+      SeverityCount["ERROR_COUNT"] = "errorCount";
+      SeverityCount["WARN_COUNT"] = "warnCount";
+  })(SeverityCount || (SeverityCount = {}));
 
   function nonMatchingFieldName(testObject, fieldName) {
       return !!fieldName && !matchingFieldName(testObject, fieldName);
@@ -1320,83 +1248,6 @@
       return either(severity === Severity.WARNINGS, testObject.warns());
   }
 
-  function collectFailureMessages(severity, testObjects, options) {
-      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;
-  }
-
-  function getFailuresArrayOrObject(group, fieldName) {
-      if (fieldName) {
-          return group[fieldName];
-      }
-      return group;
-  }
-
-  function getErrors(fieldName) {
-      return getFailures(Severity.ERRORS, fieldName);
-  }
-  function getWarnings(fieldName) {
-      return getFailures(Severity.WARNINGS, 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);
-  }
-
-  function getErrorsByGroup(groupName, fieldName) {
-      var errors = getByGroup(Severity.ERRORS, groupName, fieldName);
-      return getFailuresArrayOrObject(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) {
-      if (!group) {
-          throwError("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
-      });
-  }
-
   /**
    * Determines whether a certain test profile has failures.
    */
@@ -1426,37 +1277,25 @@
       });
   }
 
-  function hasErrorsByGroup(groupName, fieldName) {
-      return hasByGroup(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;
-      });
+  function isValid(fieldName) {
+      var _a, _b;
+      var summary = context.useX().summary;
+      invariant(summary);
+      return Boolean(fieldName ? (_b = (_a = summary.tests) === null || _a === void 0 ? void 0 : _a[fieldName]) === null || _b === void 0 ? void 0 : _b.valid : summary.valid);
   }
-
   // eslint-disable-next-line max-statements, complexity
-  function isValid(result, fieldName) {
+  function shouldAddValidProp(fieldName) {
       if (fieldIsOmitted(fieldName)) {
           return true;
       }
-      if (result.hasErrors(fieldName)) {
+      if (hasErrors(fieldName)) {
           return false;
       }
       var testObjects = useTestsFlat();
       if (isEmpty(testObjects)) {
           return false;
       }
-      if (fieldDoesNotExist(result, fieldName)) {
+      if (fieldDoesNotExist(fieldName)) {
           return false;
       }
       if (hasNonOptionalIncomplete(fieldName)) {
@@ -1480,8 +1319,10 @@
           return optionalFields[testObject.fieldName] !== true;
       }));
   }
-  function fieldDoesNotExist(result, fieldName) {
-      return !!fieldName && isEmpty(result.tests[fieldName]);
+  function fieldDoesNotExist(fieldName) {
+      var testObjects = useTestsFlat();
+      return (!!fieldName &&
+          !testObjects.find(function (testObject) { return testObject.fieldName === fieldName; }));
   }
   function noMissingTests(fieldName) {
       var testObjects = useTestsFlat();
@@ -1496,24 +1337,175 @@
       });
   }
 
-  var cache$1 = createCache(20);
+  /**
+   * Reads the testObjects list and gets full validation result from it.
+   */
+  function genTestsSummary() {
+      var testObjects = useTestsFlat();
+      var summary = assign(baseStats(), {
+          groups: {},
+          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
+   */
+  function appendToGroup(groups, testObject) {
+      var groupName = testObject.groupName;
+      if (!groupName) {
+          return;
+      }
+      groups[groupName] = groups[groupName] || {};
+      groups[groupName][testObject.fieldName] = appendTestObject(groups[groupName], testObject);
+  }
+  /**
+   * Counts the failed tests and adds global counters
+   */
+  function countFailures(summary) {
+      for (var test in summary.tests) {
+          summary.errorCount += summary.tests[test].errorCount;
+          summary.warnCount += summary.tests[test].warnCount;
+          summary.testCount += summary.tests[test].testCount;
+      }
+      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();
+      var testKey = summaryKey[fieldName];
+      if (testObject.isNonActionable())
+          return testKey;
+      summaryKey[fieldName].testCount++;
+      if (testObject.isFailing()) {
+          incrementFailures(Severity.ERRORS);
+      }
+      else if (testObject.isWarning()) {
+          incrementFailures(Severity.WARNINGS);
+      }
+      return testKey;
+      function incrementFailures(severity) {
+          var countKey = getCountKey(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,
+          warnCount: 0,
+          testCount: 0
+      };
+  }
+
+  // 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 getByFieldName(testGroup, severityKey, fieldName) {
+      var _a;
+      return ((_a = testGroup === null || testGroup === void 0 ? void 0 : testGroup[fieldName]) === null || _a === void 0 ? void 0 : _a[severityKey]) || [];
+  }
+  function collectAll(testGroup, severityKey) {
+      var _a;
+      var output = {};
+      for (var field in testGroup) {
+          output[field] = ((_a = testGroup[field]) === null || _a === void 0 ? void 0 : _a[severityKey]) || [];
+      }
+      return output;
+  }
+
+  function getErrors(fieldName) {
+      return getFailures(Severity.ERRORS, fieldName);
+  }
+  function getWarnings(fieldName) {
+      return getFailures(Severity.WARNINGS, fieldName);
+  }
+  /**
+   * @returns suite or field's errors or warnings.
+   */
+  function getFailures(severityKey, fieldName) {
+      var summary = context.useX().summary;
+      invariant(summary);
+      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 = context.useX().summary;
+      invariant(summary);
+      return gatherFailures(summary.groups[groupName], severityKey, fieldName);
+  }
+
+  function hasErrorsByGroup(groupName, fieldName) {
+      return hasByGroup(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;
+      });
+  }
+
+  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, function (fieldName) {
-                  return isValid(produceSuiteResult(), fieldName);
-              }),
+          var ref = assign({ summary: summary }, ctxRef);
+          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
           });
       }));
@@ -1582,14 +1574,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;
       });
@@ -1599,19 +1590,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() {
@@ -1623,24 +1617,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);
+          }
+      }
   }
 
   /**
@@ -1722,9 +1719,7 @@
   }
   function useBus() {
       var context$1 = context.useX();
-      if (!context$1.bus) {
-          throwError();
-      }
+      invariant(context$1.bus);
       return context$1.bus;
   }
   var Events;
@@ -1743,9 +1738,7 @@
           args[_i] = arguments[_i];
       }
       var _a = args.reverse(), suiteCallback = _a[0], suiteName = _a[1];
-      if (!isFunction(suiteCallback)) {
-          throwError('vest.create: Expected callback to be a function.');
-      }
+      invariant(isFunction(suiteCallback), 'vest.create: Expected callback to be a function.');
       // Event bus initialization
       var bus = initBus();
       // State initialization
@@ -1800,9 +1793,7 @@
    * })
    */
   function each(list, callback) {
-      if (!isFunction(callback)) {
-          throwError('each callback must be a function');
-      }
+      invariant(isFunction(callback), 'each callback must be a function');
       isolate({ type: IsolateTypes.EACH }, function () {
           list.forEach(function (arg, index) {
               callback(arg, index);
@@ -1999,19 +1990,15 @@
    * });
    */
   function group(groupName, tests) {
-      if (!isStringValue(groupName)) {
-          throwGroupError('name must be a string');
-      }
-      if (!isFunction(tests)) {
-          throwGroupError('callback must be a function');
-      }
+      invariant(isStringValue(groupName), groupErrorMsg('name must be a string'));
+      invariant(isFunction(tests), groupErrorMsg('callback must be a function'));
       // Running with the context applied
       isolate({ type: IsolateTypes.GROUP }, function () {
           context.run({ groupName: groupName }, tests);
       });
   }
-  function throwGroupError(error) {
-      throwError("Wrong arguments passed to group. Group ".concat(error, "."));
+  function groupErrorMsg(error) {
+      return "Wrong arguments passed to group. Group ".concat(error, ".");
   }
 
   function include(fieldName) {
@@ -2220,7 +2207,7 @@
           }
       }
       catch (e) {
-          throwError("Unexpected error encountered during test registration.\n      Test Object: ".concat(JSON.stringify(testObject), ".\n      Error: ").concat(e, "."));
+          throw new Error("Unexpected error encountered during test registration.\n      Test Object: ".concat(JSON.stringify(testObject), ".\n      Error: ").concat(e, "."));
       }
   }
 
@@ -2247,7 +2234,7 @@
           useSetTestAtCursor(nextTest_1);
           return nextTest_1;
       }
-      if (shouldPurgePrevTest(prevTest, newTestObject)) {
+      if (testReorderDetected(prevTest, newTestObject)) {
           throwTestOrderError(prevTest, newTestObject);
           removeAllNextTestsInIsolate();
           // Need to see if this has any effect at all.
@@ -2284,14 +2271,14 @@
       var cursorPath = usePath();
       return valueAtPath(tests, cursorPath);
   }
-  function shouldPurgePrevTest(prevTest, newTest) {
+  function testReorderDetected(prevTest, newTest) {
       return isNotEmpty(prevTest) && !isSameProfileTest(prevTest, newTest);
   }
   function throwTestOrderError(prevTest, newTestObject) {
       if (shouldAllowReorder()) {
           return;
       }
-      throwErrorDeferred("Vest Critical Error: Tests called in different order than previous run.\n    expected: ".concat(prevTest.fieldName, "\n    received: ").concat(newTestObject.fieldName, "\n    This can happen on one of two reasons:\n    1. You're using if/else statements to conditionally select tests. Instead, use \"skipWhen\".\n    2. You are iterating over a list of tests, and their order changed. Use \"each\" and a custom key prop so that Vest retains their state."));
+      deferThrow("Vest Critical Error: Tests called in different order than previous run.\n    expected: ".concat(prevTest.fieldName, "\n    received: ").concat(newTestObject.fieldName, "\n    This can happen on one of two reasons:\n    1. You're using if/else statements to conditionally select tests. Instead, use \"skipWhen\".\n    2. You are iterating over a list of tests, and their order changed. Use \"each\" and a custom key prop so that Vest retains their state."));
   }
   function handleKeyTest(key, newTestObject) {
       var prevTestByKey = usePrevTestByKey(key);
@@ -2345,7 +2332,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 = [];
@@ -2377,12 +2364,8 @@
           args[_i - 1] = arguments[_i];
       }
       var _a = (isFunction(args[1]) ? args : __spreadArray([undefined], args, true)), message = _a[0], testFn = _a[1], key = _a[2];
-      if (isNotString(fieldName)) {
-          throwIncompatibleParamsError('fieldName', 'string');
-      }
-      if (!isFunction(testFn)) {
-          throwIncompatibleParamsError('Test callback', 'function');
-      }
+      invariant(isStringValue(fieldName), incompatibleParamsError('fieldName', 'string'));
+      invariant(isFunction(testFn), incompatibleParamsError('Test callback', 'function'));
       var context$1 = context.useX();
       var testObject = new VestTest(fieldName, testFn, {
           message: message,
@@ -2403,8 +2386,8 @@
   var test = assign(testBase, {
       memo: bindTestMemo(testBase)
   });
-  function throwIncompatibleParamsError(name, expected) {
-      throwError("Incompatible params passed to test function. ".concat(name, " must be a ").concat(expected));
+  function incompatibleParamsError(name, expected) {
+      return "Incompatible params passed to test function. ".concat(name, " must be a ").concat(expected);
   }
 
   var ERROR_OUTSIDE_OF_TEST = "warn hook called outside of a test callback. It won't have an effect."
@@ -2414,13 +2397,11 @@
    */
   function warn() {
       var ctx = context.useX('warn ' + ERROR_HOOK_CALLED_OUTSIDE);
-      if (!ctx.currentTest) {
-          throwError(ERROR_OUTSIDE_OF_TEST);
-      }
+      invariant(ctx.currentTest, ERROR_OUTSIDE_OF_TEST);
       ctx.currentTest.warn();
   }
 
-  var VERSION = "4.2.2";
+  var VERSION = "4.3.1";
 
   exports.VERSION = VERSION;
   exports.context = context;