vest 4.2.1-dev-ee64be → 4.2.3-dev-87ebfa

package/dist/es/vest.development.js

@@ -1,6 +1,8 @@
 export { enforce } from 'n4s';
 import { createContext } from 'context';
 
+var assign = Object.assign;
+
 /**
  * @returns a unique numeric id.
  */
@@ -8,76 +10,203 @@ var genId = (function (n) { return function () {
     return "".concat(n++);
 }; })(0);
 
-function isStringValue(v) {
-    return String(v) === v;
+function isFunction(value) {
+    return typeof value === 'function';
 }
 
-function bindNot(fn) {
-    return function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        return !fn.apply(void 0, args);
-    };
+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 isUndefined(value) {
-    return value === undefined;
+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);
 }
 
-function shouldUseErrorAsMessage(message, error) {
-    // kind of cheating with this safe guard, but it does the job
-    return isUndefined(message) && isStringValue(error);
+// 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 asArray(possibleArg) {
-    return [].concat(possibleArg);
+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 lengthEquals(value, arg1) {
-    return value.length === Number(arg1);
+function asArray(possibleArg) {
+    return [].concat(possibleArg);
 }
 
-function longerThan(value, arg1) {
-    return value.length > Number(arg1);
+function last(values) {
+    var valuesArray = asArray(values);
+    return valuesArray[valuesArray.length - 1];
 }
 
-/**
- * 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;
+function createCursor() {
+    var storage = {
+        cursor: []
     };
-    // invalidate an item in the cache by its dependencies
-    cache.invalidate = function (deps) {
-        var index = findIndex(deps);
-        if (index > -1)
-            cacheStorage.splice(index, 1);
+    function addLevel() {
+        storage.cursor.push(0);
+    }
+    function removeLevel() {
+        storage.cursor.pop();
+    }
+    function cursorAt() {
+        return last(storage.cursor);
+    }
+    function getCursor() {
+        return asArray(storage.cursor);
+    }
+    function next() {
+        storage.cursor[storage.cursor.length - 1]++;
+        return last(storage.cursor);
+    }
+    function reset() {
+        storage.cursor = [0];
+    }
+    reset();
+    return {
+        addLevel: addLevel,
+        cursorAt: cursorAt,
+        getCursor: getCursor,
+        next: next,
+        removeLevel: removeLevel,
+        reset: reset
     };
-    // Retrieves an item from the cache.
-    cache.get = function (deps) {
-        return cacheStorage[findIndex(deps)] || null;
+}
+
+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
+        : assign({}, {
+            exclusion: {
+                tests: {},
+                groups: {}
+            },
+            inclusion: {},
+            isolate: {
+                type: IsolateTypes.DEFAULT,
+                keys: {
+                    current: {},
+                    prev: {}
+                }
+            },
+            mode: [Modes.ALL],
+            testCursor: createCursor()
+        }, ctxRef);
+});
+
+function bindNot(fn) {
+    return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return !fn.apply(void 0, args);
     };
-    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]; });
-        });
-    }
 }
 
 // The module is named "isArrayValue" since it
@@ -92,28 +221,11 @@ function isNull(value) {
 }
 var isNotNull = bindNot(isNull);
 
-function isFunction(value) {
-    return typeof value === 'function';
-}
-
-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(callback, defaultValue) {
     var _a;
     return (_a = optionalFunctionValue(callback)) !== null && _a !== void 0 ? _a : defaultValue;
 }
 
-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
@@ -159,78 +271,73 @@ function getCurrent(array, path) {
     return current;
 }
 
-var assign = Object.assign;
+function isUndefined(value) {
+    return value === undefined;
+}
 
-function createCursor() {
-    var storage = {
-        cursor: []
-    };
-    function addLevel() {
-        storage.cursor.push(0);
-    }
-    function removeLevel() {
-        storage.cursor.pop();
-    }
-    function cursorAt() {
-        return last(storage.cursor);
-    }
-    function getCursor() {
-        return asArray(storage.cursor);
-    }
-    function next() {
-        storage.cursor[storage.cursor.length - 1]++;
-        return last(storage.cursor);
-    }
-    function reset() {
-        storage.cursor = [0];
-    }
-    reset();
-    return {
-        addLevel: addLevel,
-        cursorAt: cursorAt,
-        getCursor: getCursor,
-        next: next,
-        removeLevel: removeLevel,
-        reset: reset
-    };
+function isNullish(value) {
+    return isNull(value) || isUndefined(value);
 }
 
-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 deferThrow(message) {
+    setTimeout(function () {
+        throw new Error(message);
+    }, 0);
+}
 
-var Modes;
-(function (Modes) {
-    Modes[Modes["ALL"] = 0] = "ALL";
-    Modes[Modes["EAGER"] = 1] = "EAGER";
-})(Modes || (Modes = {}));
+function isStringValue(v) {
+    return String(v) === v;
+}
 
-var context = createContext(function (ctxRef, parentContext) {
-    return parentContext
-        ? null
-        : assign({}, {
-            exclusion: {
-                tests: {},
-                groups: {}
-            },
-            inclusion: {},
-            isolate: {
-                type: IsolateTypes.DEFAULT,
-                keys: {
-                    current: {},
-                    prev: {}
-                }
-            },
-            mode: [Modes.ALL],
-            testCursor: createCursor()
-        }, ctxRef);
-});
+function shouldUseErrorAsMessage(message, error) {
+    // kind of cheating with this safe guard, but it does the job
+    return isUndefined(message) && isStringValue(error);
+}
+
+function lengthEquals(value, arg1) {
+    return value.length === Number(arg1);
+}
+
+function longerThan(value, arg1) {
+    return value.length > Number(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]; });
+        });
+    }
+}
 
 // STATE REF
 function useStateRef() {
@@ -447,105 +554,6 @@ var STATUS_PENDING = 'PENDING';
 var STATUS_CANCELED = 'CANCELED';
 var STATUS_OMITTED = 'OMITTED';
 
-/**
- * Throws a timed out error.
- */
-function throwError(devMessage, productionMessage) {
-    throw new Error(devMessage );
-}
-function throwErrorDeferred(devMessage, productionMessage) {
-    setTimeout(function () {
-        throwError(devMessage);
-    }, 0);
-}
-
-// 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 isNullish(value) {
-    return isNull(value) || isUndefined(value);
-}
-
 function usePath() {
     var context$1 = context.useX();
     return context$1.testCursor.getCursor();
@@ -591,7 +599,7 @@ function useRetainTestKey(key, testObject) {
         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."));
     }
 }
 
@@ -624,6 +632,11 @@ var Severity;
     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.
@@ -634,18 +647,26 @@ function genTestsSummary() {
         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
@@ -658,29 +679,36 @@ function countFailures(summary) {
     }
     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 {
@@ -811,9 +839,7 @@ function getWarningsByGroup(groupName, 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."));
-    }
+    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,
@@ -897,18 +923,18 @@ function isEmpty(value) {
 var isNotEmpty = bindNot(isEmpty);
 
 // 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)) {
@@ -932,8 +958,10 @@ function hasNonOptionalIncomplete(fieldName) {
         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();
@@ -949,7 +977,7 @@ function noMissingTests(fieldName) {
 }
 
 var cache$1 = createCache(20);
-function produceBase() {
+function produceSuiteResult() {
     var testObjects = useTestsFlat();
     var ctxRef = { stateRef: useStateRef() };
     return cache$1([testObjects], context.bind(ctxRef, function () {
@@ -963,9 +991,7 @@ function produceBase() {
             hasErrorsByGroup: context.bind(ctxRef, hasErrorsByGroup),
             hasWarnings: context.bind(ctxRef, hasWarnings),
             hasWarningsByGroup: context.bind(ctxRef, hasWarningsByGroup),
-            isValid: context.bind(ctxRef, function (fieldName) {
-                return isValid(produceBase(), fieldName);
-            }),
+            isValid: context.bind(ctxRef, isValid),
             suiteName: suiteName
         });
     }));
@@ -992,7 +1018,7 @@ function produceFullResult() {
     var testObjects = useTestsFlat();
     var ctxRef = { stateRef: useStateRef() };
     return cache([testObjects], context.bind(ctxRef, function () {
-        return assign({}, produceBase(), {
+        return assign({}, produceSuiteResult(), {
             done: context.bind(ctxRef, done)
         });
     }));
@@ -1025,7 +1051,7 @@ var done = function done() {
     if (shouldSkipDoneRegistration(callback, fieldName, output)) {
         return output;
     }
-    var doneCallback = function () { return callback(produceBase()); };
+    var doneCallback = function () { return callback(produceSuiteResult()); };
     if (shouldRunDoneCallback(fieldName)) {
         doneCallback();
         return output;
@@ -1174,9 +1200,7 @@ function initBus() {
 }
 function useBus() {
     var context$1 = context.useX();
-    if (!context$1.bus) {
-        throwError();
-    }
+    invariant(context$1.bus);
     return context$1.bus;
 }
 var Events;
@@ -1195,9 +1219,7 @@ function create() {
         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
@@ -1226,7 +1248,7 @@ function create() {
         // Return the result
         return produceFullResult();
     }), {
-        get: context.bind(ctxRef, produceBase),
+        get: context.bind(ctxRef, produceSuiteResult),
         remove: context.bind(ctxRef, function (fieldName) {
             bus.emit(Events.REMOVE_FIELD, fieldName);
         }),
@@ -1252,9 +1274,7 @@ function create() {
  * })
  */
 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);
@@ -1284,7 +1304,7 @@ function skipWhen(conditional, callback) {
             // 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(produceBase))
+                optionalFunctionValue(conditional, optionalFunctionValue(produceSuiteResult))
         }, function () { return callback(); });
     });
 }
@@ -1451,19 +1471,15 @@ function hasIncludedTests(keyTests) {
  * });
  */
 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) {
@@ -1484,7 +1500,7 @@ function include(fieldName) {
             if (isStringValue(condition)) {
                 return Boolean(exclusion.tests[condition]);
             }
-            return optionalFunctionValue(condition, optionalFunctionValue(produceBase));
+            return optionalFunctionValue(condition, optionalFunctionValue(produceSuiteResult));
         };
     }
 }
@@ -1541,7 +1557,7 @@ function omitWhen(conditional, callback) {
     isolate({ type: IsolateTypes.OMIT_WHEN }, function () {
         context.run({
             omitted: isOmitted() ||
-                optionalFunctionValue(conditional, optionalFunctionValue(produceBase))
+                optionalFunctionValue(conditional, optionalFunctionValue(produceSuiteResult))
         }, function () { return callback(); });
     });
 }
@@ -1579,8 +1595,6 @@ function optional(optionals) {
     });
 }
 
-var isNotString = bindNot(isStringValue);
-
 function isPromise(value) {
     return value && isFunction(value.then);
 }
@@ -1674,7 +1688,7 @@ function registerTest(testObject) {
         }
     }
     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, "."));
     }
 }
 
@@ -1701,7 +1715,7 @@ function useTestAtCursor(newTestObject) {
         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.
@@ -1738,14 +1752,14 @@ function useGetTestAtCursor(tests) {
     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);
@@ -1759,12 +1773,13 @@ function handleKeyTest(key, newTestObject) {
 
 // eslint-disable-next-line max-statements
 function registerPrevRunTest(testObject) {
-    var prevRunTest = useTestAtCursor(testObject);
     if (shouldSkipBasedOnMode(testObject)) {
-        moveForward();
         testObject.skip();
+        useTestAtCursor(testObject);
+        moveForward();
         return testObject;
     }
+    var prevRunTest = useTestAtCursor(testObject);
     if (isOmitted()) {
         prevRunTest.omit();
         moveForward();
@@ -1830,12 +1845,8 @@ function testBase(fieldName) {
         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,
@@ -1856,8 +1867,8 @@ function testBase(fieldName) {
 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."
@@ -1867,12 +1878,10 @@ var ERROR_OUTSIDE_OF_TEST = "warn hook called outside of a test callback. It won
  */
 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.1-dev-ee64be";
+var VERSION = "4.2.3-dev-87ebfa";
 
 export { VERSION, context, create, each, eager, group, include, omitWhen, only, optional, skip, skipWhen, test, warn };