vest 4.2.2 → 4.2.3-dev-87ebfa

package/dist/umd/vest.development.js

@@ -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;
@@ -514,10 +516,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 +545,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;
           };
       }
@@ -693,100 +686,106 @@
       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);
+  // eslint-disable-next-line max-lines-per-function
+  function createState(onStateChange) {
+      var state = {
+          references: []
       };
-      // Retrieves an item from the cache.
-      cache.get = function (deps) {
-          return cacheStorage[findIndex(deps)] || null;
+      var registrations = [];
+      return {
+          registerStateKey: registerStateKey,
+          reset: reset
       };
-      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]; });
+      /**
+       * 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 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));
+      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);
           }
-          else {
-              var output = cb(v);
-              if (isNotNull(output)) {
-                  res.push(output);
-              }
+          if (isFunction(onStateChange)) {
+              onStateChange();
           }
       }
-      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;
+
+  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 flatten(values) {
-      return asArray(values).reduce(function (acc, value) {
-          if (isArray(value)) {
-              return acc.concat(flatten(value));
-          }
-          return asArray(acc).concat(value);
-      }, []);
+
+  function asArray(possibleArg) {
+      return [].concat(possibleArg);
   }
-  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 last(values) {
+      var valuesArray = asArray(values);
+      return valuesArray[valuesArray.length - 1];
   }
 
   function createCursor() {
@@ -823,16 +822,6 @@
       };
   }
 
-  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";
@@ -860,6 +849,99 @@
           }, 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
@@ -1075,89 +1157,6 @@
   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 usePath() {
       var context$1 = context.useX();
       return context$1.testCursor.getCursor();
@@ -1203,7 +1202,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,6 +1235,11 @@
       Severity["WARNINGS"] = "warnings";
       Severity["ERRORS"] = "errors";
   })(Severity || (Severity = {}));
+  var SeverityCount;
+  (function (SeverityCount) {
+      SeverityCount["ERROR_COUNT"] = "errorCount";
+      SeverityCount["WARN_COUNT"] = "warnCount";
+  })(SeverityCount || (SeverityCount = {}));
 
   /**
    * Reads the testObjects list and gets full validation result from it.
@@ -1246,18 +1250,26 @@
           groups: {},
           tests: {}
       });
-      appendSummary(testObjects);
+      testObjects.reduce(function (summary, testObject) {
+          appendToTest(summary.tests, testObject);
+          appendToGroup(summary.groups, testObject);
+          return summary;
+      }, summary);
       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);
-              }
-          });
+  }
+  function appendToTest(tests, testObject) {
+      tests[testObject.fieldName] = appendTestObject(tests, testObject);
+  }
+  /**
+   * 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
@@ -1270,29 +1282,36 @@
       }
       return summary;
   }
+  /**
+   * Appends the test to a results object
+   */
   // eslint-disable-next-line max-statements
-  function genTestObject(summaryKey, testObject) {
+  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++;
-      // 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);
+          incrementFailures(Severity.ERRORS);
       }
       else if (testObject.isWarning()) {
-          addTo(Severity.WARNINGS);
+          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 {
@@ -1387,9 +1406,7 @@
    * 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."));
-      }
+      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,
@@ -1445,18 +1462,18 @@
   }
 
   // eslint-disable-next-line max-statements, complexity
-  function isValid(result, fieldName) {
+  function isValid(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 +1497,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();
@@ -1511,9 +1530,7 @@
               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);
-              }),
+              isValid: context.bind(ctxRef, isValid),
               suiteName: suiteName
           });
       }));
@@ -1722,9 +1739,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 +1758,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 +1813,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 +2010,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 +2227,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 +2254,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 +2291,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);
@@ -2377,12 +2384,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 +2406,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 +2417,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.2.3-dev-87ebfa";
 
   exports.VERSION = VERSION;
   exports.context = context;