vest 4.1.3 → 4.2.1

package/dist/umd/vest.development.js

@@ -693,106 +693,100 @@
       return "".concat(n++);
   }; })(0);
 
-  // eslint-disable-next-line max-lines-per-function
-  function createState(onStateChange) {
-      var state = {
-          references: []
+  function shouldUseErrorAsMessage(message, error) {
+      // kind of cheating with this safe guard, but it does the job
+      return isUndefined(message) && isStringValue(error);
+  }
+
+  function asArray(possibleArg) {
+      return [].concat(possibleArg);
+  }
+
+  /**
+   * Creates a cache function
+   */
+  function createCache(maxSize) {
+      if (maxSize === void 0) { maxSize = 1; }
+      var cacheStorage = [];
+      var cache = function (deps, cacheAction) {
+          var cacheHit = cache.get(deps);
+          // cache hit is not null
+          if (cacheHit)
+              return cacheHit[1];
+          var result = cacheAction();
+          cacheStorage.unshift([deps.concat(), result]);
+          if (longerThan(cacheStorage, maxSize))
+              cacheStorage.length = maxSize;
+          return result;
       };
-      var registrations = [];
-      return {
-          registerStateKey: registerStateKey,
-          reset: reset
+      // invalidate an item in the cache by its dependencies
+      cache.invalidate = function (deps) {
+          var index = findIndex(deps);
+          if (index > -1)
+              cacheStorage.splice(index, 1);
       };
-      /**
-       * Registers a new key in the state, takes the initial value (may be a function that returns the initial value), returns a function.
-       *
-       * @example
-       *
-       * const useColor = state.registerStateKey("blue");
-       *
-       * let [color, setColor] = useColor(); // -> ["blue", Function]
-       *
-       * setColor("green");
-       *
-       * useColor()[0]; -> "green"
-       */
-      function registerStateKey(initialState, onUpdate) {
-          var key = registrations.length;
-          registrations.push([initialState, onUpdate]);
-          return initKey(key, initialState);
-      }
-      function reset() {
-          var prev = current();
-          state.references = [];
-          registrations.forEach(function (_a, index) {
-              var initialValue = _a[0];
-              return initKey(index, initialValue, prev[index]);
+      // Retrieves an item from the cache.
+      cache.get = function (deps) {
+          return cacheStorage[findIndex(deps)] || null;
+      };
+      return cache;
+      function findIndex(deps) {
+          return cacheStorage.findIndex(function (_a) {
+              var cachedDeps = _a[0];
+              return lengthEquals(deps, cachedDeps.length) &&
+                  deps.every(function (dep, i) { return dep === cachedDeps[i]; });
           });
       }
-      function initKey(key, initialState, prevState) {
-          current().push();
-          set(key, optionalFunctionValue(initialState, prevState));
-          return function useStateKey() {
-              return [
-                  current()[key],
-                  function (nextState) {
-                      return set(key, optionalFunctionValue(nextState, current()[key]));
-                  },
-              ];
-          };
-      }
-      function current() {
-          return state.references;
-      }
-      function set(index, value) {
-          var prevValue = state.references[index];
-          state.references[index] = value;
-          var _a = registrations[index], onUpdate = _a[1];
-          if (isFunction(onUpdate)) {
-              onUpdate(value, prevValue);
+  }
+
+  function last(values) {
+      var valuesArray = asArray(values);
+      return valuesArray[valuesArray.length - 1];
+  }
+
+  // This is kind of a map/filter in one function.
+  // Normally, behaves like a nested-array map,
+  // but returning `null` will drop the element from the array
+  function transform(array, cb) {
+      var res = [];
+      for (var _i = 0, array_1 = array; _i < array_1.length; _i++) {
+          var v = array_1[_i];
+          if (isArray(v)) {
+              res.push(transform(v, cb));
           }
-          if (isFunction(onStateChange)) {
-              onStateChange();
+          else {
+              var output = cb(v);
+              if (isNotNull(output)) {
+                  res.push(output);
+              }
           }
       }
+      return res;
   }
-
-  var IsolateTypes;
-  (function (IsolateTypes) {
-      IsolateTypes[IsolateTypes["DEFAULT"] = 0] = "DEFAULT";
-      IsolateTypes[IsolateTypes["SUITE"] = 1] = "SUITE";
-      IsolateTypes[IsolateTypes["EACH"] = 2] = "EACH";
-      IsolateTypes[IsolateTypes["SKIP_WHEN"] = 3] = "SKIP_WHEN";
-      IsolateTypes[IsolateTypes["OMIT_WHEN"] = 4] = "OMIT_WHEN";
-      IsolateTypes[IsolateTypes["GROUP"] = 5] = "GROUP";
-  })(IsolateTypes || (IsolateTypes = {}));
-
-  function createStateRef(state, _a) {
-      var suiteId = _a.suiteId, suiteName = _a.suiteName;
-      return {
-          optionalFields: state.registerStateKey(function () { return ({}); }),
-          suiteId: state.registerStateKey(suiteId),
-          suiteName: state.registerStateKey(suiteName),
-          testCallbacks: state.registerStateKey(function () { return ({
-              fieldCallbacks: {},
-              doneCallbacks: []
-          }); }),
-          testObjects: state.registerStateKey(function (prev) {
-              return {
-                  prev: prev ? prev.current : [],
-                  current: []
-              };
-          })
-      };
+  function valueAtPath(array, path) {
+      return getCurrent(array, path)[last(path)];
   }
-
-  function asArray(possibleArg) {
-      return [].concat(possibleArg);
+  function setValueAtPath(array, path, value) {
+      var current = getCurrent(array, path);
+      current[last(path)] = value;
+      return array;
   }
-
-  function last(values) {
-      var valuesArray = asArray(values);
-      return valuesArray[valuesArray.length - 1];
+  function flatten(values) {
+      return asArray(values).reduce(function (acc, value) {
+          if (isArray(value)) {
+              return acc.concat(flatten(value));
+          }
+          return asArray(acc).concat(value);
+      }, []);
+  }
+  function getCurrent(array, path) {
+      var current = array;
+      for (var _i = 0, _a = path.slice(0, -1); _i < _a.length; _i++) {
+          var p = _a[_i];
+          current[p] = defaultTo(current[p], []);
+          current = current[p];
+      }
+      return current;
   }
 
   function createCursor() {
@@ -829,6 +823,22 @@
       };
   }
 
+  var IsolateTypes;
+  (function (IsolateTypes) {
+      IsolateTypes[IsolateTypes["DEFAULT"] = 0] = "DEFAULT";
+      IsolateTypes[IsolateTypes["SUITE"] = 1] = "SUITE";
+      IsolateTypes[IsolateTypes["EACH"] = 2] = "EACH";
+      IsolateTypes[IsolateTypes["SKIP_WHEN"] = 3] = "SKIP_WHEN";
+      IsolateTypes[IsolateTypes["OMIT_WHEN"] = 4] = "OMIT_WHEN";
+      IsolateTypes[IsolateTypes["GROUP"] = 5] = "GROUP";
+  })(IsolateTypes || (IsolateTypes = {}));
+
+  var Modes;
+  (function (Modes) {
+      Modes[Modes["ALL"] = 0] = "ALL";
+      Modes[Modes["EAGER"] = 1] = "EAGER";
+  })(Modes || (Modes = {}));
+
   var context = createContext(function (ctxRef, parentContext) {
       return parentContext
           ? null
@@ -845,98 +855,11 @@
                       prev: {}
                   }
               },
+              mode: [Modes.ALL],
               testCursor: createCursor()
           }, ctxRef);
   });
 
-  // This is sort of a map/filter in one function.
-  // Normally, behaves like a nested-array map
-  // 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 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 = cacheStorage.findIndex(function (_a) {
-              var cachedDeps = _a[0];
-              return lengthEquals(deps, cachedDeps.length) &&
-                  deps.every(function (dep, i) { return dep === cachedDeps[i]; });
-          });
-          if (index > -1)
-              cacheStorage.splice(index, 1);
-      };
-      // Retrieves an item from the cache.
-      cache.get = function (deps) {
-          return cacheStorage[cacheStorage.findIndex(function (_a) {
-              var cachedDeps = _a[0];
-              return lengthEquals(deps, cachedDeps.length) &&
-                  deps.every(function (dep, i) { return dep === cachedDeps[i]; });
-          })] || null;
-      };
-      return cache;
-  }
-
   // STATE REF
   function useStateRef() {
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -1152,6 +1075,89 @@
   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();
@@ -1225,41 +1231,21 @@
       return context.useX().isolate.type === IsolateTypes.EACH;
   }
 
-  function nonMatchingFieldName(testObject, fieldName) {
-      return !!fieldName && !matchingFieldName(testObject, fieldName);
-  }
-  function matchingFieldName(testObject, fieldName) {
-      return !!(fieldName && testObject.fieldName === fieldName);
-  }
-
-  /**
-   * Checks if a given field, or the suite as a whole still have remaining tests.
-   */
-  function hasRemainingTests(fieldName) {
-      var allIncomplete = useAllIncomplete();
-      if (isEmpty(allIncomplete)) {
-          return false;
-      }
-      if (fieldName) {
-          return allIncomplete.some(function (testObject) {
-              return matchingFieldName(testObject, fieldName);
-          });
-      }
-      return isNotEmpty(allIncomplete);
-  }
+  var Severity;
+  (function (Severity) {
+      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 = {
-          errorCount: 0,
+      var summary = assign(baseStats(), {
           groups: {},
-          testCount: 0,
-          tests: {},
-          warnCount: 0
-      };
+          tests: {}
+      });
       appendSummary(testObjects);
       return countFailures(summary);
       function appendSummary(testObjects) {
@@ -1287,30 +1273,41 @@
   // eslint-disable-next-line max-statements
   function genTestObject(summaryKey, testObject) {
       var fieldName = testObject.fieldName, message = testObject.message;
-      summaryKey[fieldName] = summaryKey[fieldName] || {
-          errorCount: 0,
-          warnCount: 0,
-          testCount: 0
-      };
+      summaryKey[fieldName] = summaryKey[fieldName] || baseStats();
       var testKey = summaryKey[fieldName];
       if (testObject.isNonActionable())
           return testKey;
       summaryKey[fieldName].testCount++;
       // Adds to severity group
-      function addTo(countKey, group) {
+      function addTo(severity) {
+          var countKey = severity === Severity.ERRORS ? 'errorCount' : 'warnCount';
           testKey[countKey]++;
           if (message) {
-              testKey[group] = (testKey[group] || []).concat(message);
+              testKey[severity] = (testKey[severity] || []).concat(message);
           }
       }
       if (testObject.isFailing()) {
-          addTo('errorCount', 'errors');
+          addTo(Severity.ERRORS);
       }
       else if (testObject.isWarning()) {
-          addTo('warnCount', 'warnings');
+          addTo(Severity.WARNINGS);
       }
       return testKey;
   }
+  function baseStats() {
+      return {
+          errorCount: 0,
+          warnCount: 0,
+          testCount: 0
+      };
+  }
+
+  function nonMatchingFieldName(testObject, fieldName) {
+      return !!fieldName && !matchingFieldName(testObject, fieldName);
+  }
+  function matchingFieldName(testObject, fieldName) {
+      return !!(fieldName && testObject.fieldName === fieldName);
+  }
 
   function either(a, b) {
       return !!a !== !!b;
@@ -1320,7 +1317,7 @@
    * Checks that a given test object matches the currently specified severity level
    */
   function nonMatchingSeverityProfile(severity, testObject) {
-      return either(severity === 'warnings', testObject.warns());
+      return either(severity === Severity.WARNINGS, testObject.warns());
   }
 
   function collectFailureMessages(severity, testObjects, options) {
@@ -1362,10 +1359,10 @@
   }
 
   function getErrors(fieldName) {
-      return getFailures('errors', fieldName);
+      return getFailures(Severity.ERRORS, fieldName);
   }
   function getWarnings(fieldName) {
-      return getFailures('warnings', fieldName);
+      return getFailures(Severity.WARNINGS, fieldName);
   }
   /**
    * @returns suite or field's errors or warnings.
@@ -1379,11 +1376,11 @@
   }
 
   function getErrorsByGroup(groupName, fieldName) {
-      var errors = getByGroup('errors', groupName, fieldName);
+      var errors = getByGroup(Severity.ERRORS, groupName, fieldName);
       return getFailuresArrayOrObject(errors, fieldName);
   }
   function getWarningsByGroup(groupName, fieldName) {
-      var warnings = getByGroup('warnings', groupName, fieldName);
+      var warnings = getByGroup(Severity.WARNINGS, groupName, fieldName);
       return getFailuresArrayOrObject(warnings, fieldName);
   }
   /**
@@ -1417,10 +1414,10 @@
   }
 
   function hasErrors(fieldName) {
-      return has('errors', fieldName);
+      return has(Severity.ERRORS, fieldName);
   }
   function hasWarnings(fieldName) {
-      return has('warnings', fieldName);
+      return has(Severity.WARNINGS, fieldName);
   }
   function has(severityKey, fieldName) {
       var testObjects = useTestsFlat();
@@ -1430,10 +1427,10 @@
   }
 
   function hasErrorsByGroup(groupName, fieldName) {
-      return hasByGroup('errors', groupName, fieldName);
+      return hasByGroup(Severity.ERRORS, groupName, fieldName);
   }
   function hasWarningsByGroup(groupName, fieldName) {
-      return hasByGroup('warnings', groupName, fieldName);
+      return hasByGroup(Severity.WARNINGS, groupName, fieldName);
   }
   /**
    * Checks whether there are failures in a given group.
@@ -1500,7 +1497,7 @@
   }
 
   var cache$1 = createCache(20);
-  function produceDraft() {
+  function produceSuiteResult() {
       var testObjects = useTestsFlat();
       var ctxRef = { stateRef: useStateRef() };
       return cache$1([testObjects], context.bind(ctxRef, function () {
@@ -1515,19 +1512,35 @@
               hasWarnings: context.bind(ctxRef, hasWarnings),
               hasWarningsByGroup: context.bind(ctxRef, hasWarningsByGroup),
               isValid: context.bind(ctxRef, function (fieldName) {
-                  return isValid(produceDraft(), fieldName);
+                  return isValid(produceSuiteResult(), fieldName);
               }),
               suiteName: suiteName
           });
       }));
   }
 
+  /**
+   * Checks if a given field, or the suite as a whole still have remaining tests.
+   */
+  function hasRemainingTests(fieldName) {
+      var allIncomplete = useAllIncomplete();
+      if (isEmpty(allIncomplete)) {
+          return false;
+      }
+      if (fieldName) {
+          return allIncomplete.some(function (testObject) {
+              return matchingFieldName(testObject, fieldName);
+          });
+      }
+      return isNotEmpty(allIncomplete);
+  }
+
   var cache = createCache(20);
   function produceFullResult() {
       var testObjects = useTestsFlat();
       var ctxRef = { stateRef: useStateRef() };
       return cache([testObjects], context.bind(ctxRef, function () {
-          return assign({}, produceDraft(), {
+          return assign({}, produceSuiteResult(), {
               done: context.bind(ctxRef, done)
           });
       }));
@@ -1560,7 +1573,7 @@
       if (shouldSkipDoneRegistration(callback, fieldName, output)) {
           return output;
       }
-      var doneCallback = function () { return callback(produceDraft()); };
+      var doneCallback = function () { return callback(produceSuiteResult()); };
       if (shouldRunDoneCallback(fieldName)) {
           doneCallback();
           return output;
@@ -1586,18 +1599,12 @@
       var listeners = {};
       return {
           emit: function (event, data) {
-              if (!listeners[event]) {
-                  return;
-              }
-              listeners[event].forEach(function (listener) {
-                  listener(data);
+              (listeners[event] || []).forEach(function (handler) {
+                  handler(data);
               });
           },
           on: function (event, handler) {
-              if (!listeners[event]) {
-                  listeners[event] = [];
-              }
-              listeners[event].push(handler);
+              listeners[event] = (listeners[event] || []).concat(handler);
               return {
                   off: function () {
                       listeners[event] = listeners[event].filter(function (h) { return h !== handler; });
@@ -1665,9 +1672,7 @@
    */
   function runDoneCallbacks() {
       var doneCallbacks = useTestCallbacks()[0].doneCallbacks;
-      if (!hasRemainingTests()) {
-          callEach(doneCallbacks);
-      }
+      callEach(doneCallbacks);
   }
 
   // eslint-disable-next-line max-lines-per-function
@@ -1681,14 +1686,21 @@
           }
           testObject.done();
           runFieldCallbacks(testObject.fieldName);
-          runDoneCallbacks();
+          if (!hasRemainingTests()) {
+              // When no more tests are running, emit the done event
+              bus.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_COMPLETED, function () {
+      bus.on(Events.SUITE_CALLBACK_DONE_RUNNING, function () {
           // Remove tests that are optional and need to be omitted
           omitOptionalTests();
       });
+      // Called when all the tests, including async, are done running
+      bus.on(Events.ALL_RUNNING_TESTS_FINISHED, function () {
+          runDoneCallbacks();
+      });
       // Removes a certain field from the state.
       bus.on(Events.REMOVE_FIELD, function (fieldName) {
           useEachTestObject(function (testObject) {
@@ -1718,9 +1730,10 @@
   var Events;
   (function (Events) {
       Events["TEST_COMPLETED"] = "test_completed";
+      Events["ALL_RUNNING_TESTS_FINISHED"] = "all_running_tests_finished";
       Events["REMOVE_FIELD"] = "remove_field";
       Events["RESET_FIELD"] = "reset_field";
-      Events["SUITE_COMPLETED"] = "suite_completed";
+      Events["SUITE_CALLBACK_DONE_RUNNING"] = "suite_callback_done_running";
   })(Events || (Events = {}));
 
   // eslint-disable-next-line max-lines-per-function
@@ -1757,11 +1770,11 @@
           });
           // Report the suite is done registering tests
           // Async tests may still be running
-          bus.emit(Events.SUITE_COMPLETED);
+          bus.emit(Events.SUITE_CALLBACK_DONE_RUNNING);
           // Return the result
           return produceFullResult();
       }), {
-          get: context.bind(ctxRef, produceDraft),
+          get: context.bind(ctxRef, produceSuiteResult),
           remove: context.bind(ctxRef, function (fieldName) {
               bus.emit(Events.REMOVE_FIELD, fieldName);
           }),
@@ -1788,7 +1801,7 @@
    */
   function each(list, callback) {
       if (!isFunction(callback)) {
-          throwError('callback must be a function');
+          throwError('each callback must be a function');
       }
       isolate({ type: IsolateTypes.EACH }, function () {
           list.forEach(function (arg, index) {
@@ -1819,7 +1832,7 @@
               // we should skip the test if the parent conditional is true.
               isExcludedIndividually() ||
                   // Otherwise, we should skip the test if the conditional is true.
-                  optionalFunctionValue(conditional, optionalFunctionValue(produceDraft))
+                  optionalFunctionValue(conditional, optionalFunctionValue(produceSuiteResult))
           }, function () { return callback(); });
       });
   }
@@ -2019,11 +2032,50 @@
               if (isStringValue(condition)) {
                   return Boolean(exclusion.tests[condition]);
               }
-              return optionalFunctionValue(condition, optionalFunctionValue(produceDraft));
+              return optionalFunctionValue(condition, optionalFunctionValue(produceSuiteResult));
           };
       }
   }
 
+  /**
+   * Sets the suite to "eager" (fail fast) mode.
+   * Eager mode will skip running subsequent tests of a failing fields.
+   *
+   * @example
+   *  // in the following example, the second test of username will not run
+   *  // if the first test of username failed.
+   * const suite = create((data) => {
+   *  eager();
+   *
+   *  test('username', 'username is required', () => {
+   *   enforce(data.username).isNotBlank();
+   *  });
+   *
+   *  test('username', 'username is too short', () => {
+   *   enforce(data.username).longerThan(2);
+   *  });
+   * });
+   */
+  function eager() {
+      setMode(Modes.EAGER);
+  }
+  function shouldSkipBasedOnMode(testObject) {
+      if (isEager() && hasErrors(testObject.fieldName))
+          return true;
+      return false;
+  }
+  function isEager() {
+      return isMode(Modes.EAGER);
+  }
+  function isMode(mode) {
+      var currentMode = context.useX().mode;
+      return currentMode[0] === mode;
+  }
+  function setMode(nextMode) {
+      var mode = context.useX().mode;
+      mode[0] = nextMode;
+  }
+
   /**
    * Conditionally omits tests from the suite.
    *
@@ -2037,7 +2089,7 @@
       isolate({ type: IsolateTypes.OMIT_WHEN }, function () {
           context.run({
               omitted: isOmitted() ||
-                  optionalFunctionValue(conditional, optionalFunctionValue(produceDraft))
+                  optionalFunctionValue(conditional, optionalFunctionValue(produceSuiteResult))
           }, function () { return callback(); });
       });
   }
@@ -2168,7 +2220,7 @@
           }
       }
       catch (e) {
-          throwError("Unexpected error encountered during test registration.\n      Test Object: ".concat(testObject, ".\n      Error: ").concat(e, "."));
+          throwError("Unexpected error encountered during test registration.\n      Test Object: ".concat(JSON.stringify(testObject), ".\n      Error: ").concat(e, "."));
       }
   }
 
@@ -2254,6 +2306,11 @@
   // eslint-disable-next-line max-statements
   function registerPrevRunTest(testObject) {
       var prevRunTest = useTestAtCursor(testObject);
+      if (shouldSkipBasedOnMode(testObject)) {
+          moveForward();
+          testObject.skip();
+          return testObject;
+      }
       if (isOmitted()) {
           prevRunTest.omit();
           moveForward();
@@ -2362,12 +2419,13 @@
       ctx.currentTest.warn();
   }
 
-  var VERSION = "4.1.3";
+  var VERSION = "4.2.1";
 
   exports.VERSION = VERSION;
   exports.context = context;
   exports.create = create;
   exports.each = each;
+  exports.eager = eager;
   exports.enforce = enforce;
   exports.group = group;
   exports.include = include;