vest 4.0.0-dev-deabb8 → 4.0.0-dev-8851ff

package/dist/es/vest.development.js

@@ -224,8 +224,16 @@ function greaterThanOrEquals(value, gte) {
     return isNumeric(value) && isNumeric(gte) && Number(value) >= Number(gte);
 }
 
+// The module is named "isArrayValue" since it
+// is conflicting with a nested npm dependency.
+// We may need to revisit this in the future.
+function isArray(value) {
+    return Boolean(Array.isArray(value));
+}
+var isNotArray = bindNot(isArray);
+
 function inside(value, arg1) {
-    if (Array.isArray(arg1)) {
+    if (isArray(arg1)) {
         return arg1.indexOf(value) !== -1;
     }
     // both value and arg1 are strings
@@ -236,14 +244,6 @@ function inside(value, arg1) {
 }
 var notInside = bindNot(inside);
 
-// The module is named "isArrayValue" since it
-// is conflicting with a nested npm dependency.
-// We may need to revisit this in the future.
-function isArray(value) {
-    return Boolean(Array.isArray(value));
-}
-var isNotArray = bindNot(isArray);
-
 function lessThanOrEquals(value, lte) {
     return isNumeric(value) && isNumeric(lte) && Number(value) <= Number(lte);
 }
@@ -253,6 +253,11 @@ function isBetween(value, min, max) {
 }
 var isNotBetween = bindNot(isBetween);
 
+function isBlank(value) {
+    return isStringValue(value) && !value.trim();
+}
+var isNotBlank = bindNot(isBlank);
+
 function isBoolean(value) {
     return !!value === value;
 }
@@ -391,6 +396,7 @@ function rules() {
         inside: inside,
         isArray: isArray,
         isBetween: isBetween,
+        isBlank: isBlank,
         isBoolean: isBoolean,
         isEmpty: isEmpty,
         isEven: isEven,
@@ -399,6 +405,7 @@ function rules() {
         isNegative: isNegative,
         isNotArray: isNotArray,
         isNotBetween: isNotBetween,
+        isNotBlank: isNotBlank,
         isNotBoolean: isNotBoolean,
         isNotEmpty: isNotEmpty,
         isNotNaN: isNotNaN,
@@ -441,6 +448,11 @@ function rules() {
 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 createContext(init) {
@@ -605,7 +617,7 @@ function transformResult(result, ruleName, value) {
         return ruleReturn(result);
     }
     else {
-        return ruleReturn(result.pass, optionalFunctionValue.apply(void 0, __spreadArray([result.message, ruleName, value], args, false)));
+        return ruleReturn(result.pass, optionalFunctionValue.apply(void 0, __spreadArray([result.message, ruleName, value], args)));
     }
 }
 function validateResult(result) {
@@ -639,9 +651,9 @@ function enforceEager(value) {
             for (var _i = 0; _i < arguments.length; _i++) {
                 args[_i] = arguments[_i];
             }
-            var transformedResult = transformResult.apply(void 0, __spreadArray([ctx$1.run({ value: value }, function () { return rule.apply(void 0, __spreadArray([value], args, false)); }),
+            var transformedResult = transformResult.apply(void 0, __spreadArray([ctx$1.run({ value: value }, function () { return rule.apply(void 0, __spreadArray([value], args)); }),
                 ruleName,
-                value], args, false));
+                value], args));
             if (!transformedResult.pass) {
                 if (isEmpty(transformedResult.message)) {
                     throwError("enforce/" + ruleName + " failed with " + JSON.stringify(value));
@@ -671,7 +683,7 @@ function genEnforceLazy(key) {
             }
             var rule = getRule(ruleName);
             registeredRules.push(function (value) {
-                return transformResult.apply(void 0, __spreadArray([rule.apply(void 0, __spreadArray([value], args, false)), ruleName, value], args, false));
+                return transformResult.apply(void 0, __spreadArray([rule.apply(void 0, __spreadArray([value], args)), ruleName, value], args));
             });
             var proxy = {
                 run: function (value) {
@@ -778,10 +790,6 @@ function genEnforce() {
 }
 var enforce = genEnforce();
 
-function asArray(possibleArg) {
-    return [].concat(possibleArg);
-}
-
 /**
  * @returns a unique numeric id.
  */
@@ -818,15 +826,16 @@ function createState(onStateChange) {
         return initKey(key, initialState);
     }
     function reset() {
+        var prev = current();
         state.references = [];
         registrations.forEach(function (_a, index) {
             var initialValue = _a[0];
-            return initKey(index, initialValue);
+            return initKey(index, initialValue, prev[index]);
         });
     }
-    function initKey(key, initialState) {
+    function initKey(key, initialState, prevState) {
         current().push();
-        set(key, optionalFunctionValue(initialState));
+        set(key, optionalFunctionValue(initialState, prevState));
         return function useStateKey() {
             return [
                 current()[key],
@@ -852,18 +861,74 @@ function createState(onStateChange) {
     }
 }
 
+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["GROUP"] = 4] = "GROUP";
+})(IsolateTypes || (IsolateTypes = {}));
+
 function createStateRef(state, _a) {
     var suiteId = _a.suiteId;
     return {
         optionalFields: state.registerStateKey(function () { return ({}); }),
-        prevTestObjects: state.registerStateKey(function () { return []; }),
-        suiteId: state.registerStateKey(function () { return suiteId; }),
+        suiteId: state.registerStateKey(suiteId),
         testCallbacks: state.registerStateKey(function () { return ({
             fieldCallbacks: {},
             doneCallbacks: []
         }); }),
-        testObjects: state.registerStateKey(function () { return []; }),
-        testObjectsCursor: state.registerStateKey(function () { return 0; })
+        testObjects: state.registerStateKey(function (prev) {
+            return {
+                prev: (prev ? prev.current : []),
+                current: []
+            };
+        })
+    };
+}
+
+function asArray(possibleArg) {
+    return [].concat(possibleArg);
+}
+
+function last(values) {
+    var valuesArray = asArray(values);
+    var _a = valuesArray, l = _a.length, _b = l - 1, lastValue = _a[_b];
+    return lastValue;
+}
+
+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
     };
 }
 
@@ -871,6 +936,8 @@ var ctx = createContext(function (ctxRef, parentContext) {
     return parentContext
         ? null
         : assign({}, {
+            isolate: { type: IsolateTypes.DEFAULT },
+            testCursor: createCursor(),
             exclusion: {
                 tests: {},
                 groups: {}
@@ -878,18 +945,56 @@ var ctx = createContext(function (ctxRef, parentContext) {
         }, ctxRef);
 });
 
-function nonMatchingFieldName(testObject, fieldName) {
-    return !!fieldName && !matchingFieldName(testObject, fieldName);
+// 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 matchingFieldName(testObject, fieldName) {
-    return !!(fieldName && testObject.fieldName === fieldName);
+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;
 }
 
 /**
  * Creates a cache function
  */
 function createCache(maxSize) {
-    if (maxSize === void 0) { maxSize = 10; }
+    if (maxSize === void 0) { maxSize = 1; }
     var cacheStorage = [];
     var cache = function (deps, cacheAction) {
         var cacheHit = cache.get(deps);
@@ -898,9 +1003,8 @@ function createCache(maxSize) {
             return cacheHit[1];
         var result = cacheAction();
         cacheStorage.unshift([deps.concat(), result]);
-        if (cacheStorage.length > maxSize) {
+        if (longerThan(cacheStorage, maxSize))
             cacheStorage.length = maxSize;
-        }
         return result;
     };
     // invalidate an item in the cache by its dependencies
@@ -924,6 +1028,12 @@ function createCache(maxSize) {
     return cache;
 }
 
+// STATE REF
+function useStateRef() {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    return ctx.useX().stateRef; // I should revisit this
+}
+// STATE KEYS
 function useSuiteId() {
     return useStateRef().suiteId();
 }
@@ -933,58 +1043,133 @@ function useTestCallbacks() {
 function useOptionalFields() {
     return useStateRef().optionalFields();
 }
-function useStateRef() {
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    return ctx.useX().stateRef; // I should revisit this
-}
 function useTestObjects() {
     return useStateRef().testObjects();
 }
-function usePrevTestObjects() {
-    return useStateRef().prevTestObjects();
+// STATE ACTIONS
+function useRefreshTestObjects() {
+    var _a = useTestObjects(), setTestObjects = _a[1];
+    setTestObjects(function (_a) {
+        var current = _a.current, prev = _a.prev;
+        return ({
+            prev: prev,
+            current: asArray(current)
+        });
+    });
 }
-function useTestAtCursor(initialValue) {
-    var cursorAt = useCursorAt()[0];
-    var prevTestObjects = usePrevTestObjects()[0];
-    var nextTest = defaultTo(prevTestObjects[cursorAt], initialValue);
-    useSetTestAtCursor(nextTest);
-    return nextTest;
+function useSetTests(handler) {
+    var _a = useTestObjects(), testObjects = _a[1];
+    testObjects(function (_a) {
+        var current = _a.current, prev = _a.prev;
+        return ({
+            prev: prev,
+            current: asArray(handler(current))
+        });
+    });
 }
-function useSetTestAtCursor(testObject) {
-    var cursorAt = useCursorAt()[0];
-    var _a = useTestObjects(), testObjects = _a[0], setTestObjects = _a[1];
-    if (testObject === testObjects[cursorAt]) {
+// Derived state
+function useAllIncomplete() {
+    var current = useTestObjects()[0].current;
+    return flatten(transform(current, function (testObject) {
+        return testObject.isPending() ? testObject : null;
+    }));
+}
+function useOmittedFields() {
+    var testObjects = useTestsFlat();
+    return testObjects.reduce(function (omittedFields, testObject) {
+        if (omittedFields[testObject.fieldName]) {
+            return omittedFields;
+        }
+        if (testObject.isOmitted()) {
+            omittedFields[testObject.fieldName] = true;
+        }
+        return omittedFields;
+    }, {});
+}
+var flatCache = createCache();
+function useTestsFlat() {
+    var current = useTestObjects()[0].current;
+    return flatCache([current], function () { return flatten(current); });
+}
+
+function usePath() {
+    var context = ctx.useX();
+    return context.testCursor.getCursor();
+}
+function useCursorAt() {
+    var context = ctx.useX();
+    return context.testCursor.cursorAt();
+}
+function moveForward() {
+    var context = ctx.useX();
+    return context.testCursor.next();
+}
+function addLevel() {
+    var context = ctx.useX();
+    context.testCursor.addLevel();
+}
+function removeLevel() {
+    var context = ctx.useX();
+    context.testCursor.removeLevel();
+}
+
+function isolate(_a, callback) {
+    var _b = _a.type, type = _b === void 0 ? IsolateTypes.DEFAULT : _b;
+    if (!isFunction(callback)) {
         return;
     }
-    setTestObjects(function (testObjects) {
-        var newTestsOrder = testObjects.slice(0);
-        newTestsOrder[cursorAt] = testObject;
-        return newTestsOrder;
+    var path = usePath();
+    return ctx.run({ isolate: { type: type } }, function () {
+        addLevel();
+        useSetTests(function (tests) { return setValueAtPath(tests, path, []); });
+        var res = callback();
+        removeLevel();
+        moveForward();
+        return res;
     });
 }
-function useSetNextCursorAt() {
-    var _a = useCursorAt(), setCursorAt = _a[1];
-    setCursorAt(function (cursorAt) { return cursorAt + 1; });
+function shouldAllowReorder() {
+    return ctx.useX().isolate.type === IsolateTypes.EACH;
 }
-function useRefreshTestObjects() {
-    var _a = useTestObjects(), setTestObjects = _a[1];
-    setTestObjects(function (testObjects) { return testObjects.slice(0); });
+
+function nonMatchingFieldName(testObject, fieldName) {
+    return !!fieldName && !matchingFieldName(testObject, fieldName);
 }
-function useCursorAt() {
-    return useStateRef().testObjectsCursor();
+function matchingFieldName(testObject, fieldName) {
+    return !!(fieldName && testObject.fieldName === fieldName);
 }
-function isOptionalField(fieldName) {
+
+function omitOptionalTests() {
     var optionalFields = useOptionalFields()[0];
-    return !!optionalFields[fieldName];
-}
-function useAllIncomplete() {
-    var testObjects = useTestObjects()[0];
-    // TODO: CACHE?
-    return testObjects.filter(function (testObject) { return testObject.isPending(); });
+    if (isEmpty(optionalFields)) {
+        return;
+    }
+    var shouldOmit = {};
+    useSetTests(function (tests) {
+        return transform(tests, function (testObject) {
+            var fieldName = testObject.fieldName;
+            if (shouldOmit.hasOwnProperty(fieldName)) {
+                omit(testObject);
+            }
+            else {
+                var optionalConfig = optionalFields[fieldName];
+                if (isFunction(optionalConfig)) {
+                    shouldOmit[fieldName] = optionalConfig();
+                    omit(testObject);
+                }
+            }
+            return testObject;
+        });
+    });
+    function omit(testObject) {
+        if (shouldOmit[testObject.fieldName]) {
+            testObject.omit();
+        }
+    }
 }
 
 /**
- * Checks if a given tests, or the suite as a whole still have remaining tests.
+ * Checks if a given field, or the suite as a whole still have remaining tests.
  */
 function hasRemainingTests(fieldName) {
     var allIncomplete = useAllIncomplete();
@@ -1003,7 +1188,7 @@ function hasRemainingTests(fieldName) {
  * Reads the testObjects list and gets full validation result from it.
  */
 function genTestsSummary() {
-    var testObjects = useTestObjects()[0];
+    var testObjects = useTestsFlat();
     var summary = {
         errorCount: 0,
         groups: {},
@@ -1123,7 +1308,7 @@ function getWarnings(fieldName) {
  * @returns suite or field's errors or warnings.
  */
 function getFailures(severityKey, fieldName) {
-    var testObjects = useTestObjects()[0];
+    var testObjects = useTestsFlat();
     var failureMessages = collectFailureMessages(severityKey, testObjects, {
         fieldName: fieldName
     });
@@ -1145,7 +1330,7 @@ function getByGroup(severityKey, group, fieldName) {
     if (!group) {
         throwError("get" + severityKey[0].toUpperCase() + severityKey.slice(1) + "ByGroup requires a group name. Received `" + group + "` instead.");
     }
-    var testObjects = useTestObjects()[0];
+    var testObjects = useTestsFlat();
     var failureMessages = collectFailureMessages(severityKey, testObjects, {
         group: group,
         fieldName: fieldName
@@ -1176,7 +1361,7 @@ function hasWarnings(fieldName) {
     return has('warnings', fieldName);
 }
 function has(severityKey, fieldName) {
-    var testObjects = useTestObjects()[0];
+    var testObjects = useTestsFlat();
     return testObjects.some(function (testObject) {
         return hasFailuresLogic(testObject, severityKey, fieldName);
     });
@@ -1192,7 +1377,7 @@ function hasWarningsByGroup(groupName, fieldName) {
  * Checks whether there are failures in a given group.
  */
 function hasByGroup(severityKey, group, fieldName) {
-    var testObjects = useTestObjects()[0];
+    var testObjects = useTestsFlat();
     return testObjects.some(function (testObject) {
         return group === testObject.groupName
             ? hasFailuresLogic(testObject, severityKey, fieldName)
@@ -1200,46 +1385,61 @@ function hasByGroup(severityKey, group, fieldName) {
     });
 }
 
+// eslint-disable-next-line max-statements, complexity
 function isValid(result, fieldName) {
+    if (fieldIsOmitted(fieldName)) {
+        return true;
+    }
     if (result.hasErrors(fieldName)) {
         return false;
     }
-    var testObjects = useTestObjects()[0];
+    var testObjects = useTestsFlat();
     if (isEmpty(testObjects)) {
         return false;
     }
     if (fieldDoesNotExist(result, fieldName)) {
         return false;
     }
-    if (isNotEmpty(useAllIncomplete().filter(function (testObject) {
-        if (nonMatchingFieldName(testObject, fieldName)) {
-            return false;
-        }
-        return !isOptionalField(testObject.fieldName);
-    }))) {
+    if (hasNonOptionalIncomplete(fieldName)) {
         return false;
     }
     return noMissingTests(fieldName);
 }
+function fieldIsOmitted(fieldName) {
+    var omittedFields = useOmittedFields();
+    if (!fieldName) {
+        return false;
+    }
+    return !!omittedFields[fieldName];
+}
+function hasNonOptionalIncomplete(fieldName) {
+    var optionalFields = useOptionalFields()[0];
+    return isNotEmpty(useAllIncomplete().filter(function (testObject) {
+        if (nonMatchingFieldName(testObject, fieldName)) {
+            return false;
+        }
+        return optionalFields[testObject.fieldName] !== true;
+    }));
+}
 function fieldDoesNotExist(result, fieldName) {
     return !!fieldName && isEmpty(result.tests[fieldName]);
 }
 function noMissingTests(fieldName) {
-    var testObjects = useTestObjects()[0];
+    var testObjects = useTestsFlat();
+    var optionalFields = useOptionalFields()[0];
     return testObjects.every(function (testObject) {
         if (nonMatchingFieldName(testObject, fieldName)) {
             return true;
         }
-        if (isOptionalField(testObject.fieldName)) {
-            return true;
-        }
-        return testObject.isTested();
+        return (optionalFields[testObject.fieldName] === true ||
+            testObject.isTested() ||
+            testObject.isOmitted());
     });
 }
 
 var cache$1 = createCache(20);
 function produceDraft() {
-    var testObjects = useTestObjects()[0];
+    var testObjects = useTestsFlat();
     var ctxRef = { stateRef: useStateRef() };
     return cache$1([testObjects], ctx.bind(ctxRef, function () {
         return assign(genTestsSummary(), {
@@ -1260,7 +1460,7 @@ function produceDraft() {
 
 var cache = createCache(20);
 function produceFullResult() {
-    var testObjects = useTestObjects()[0];
+    var testObjects = useTestsFlat();
     var ctxRef = { stateRef: useStateRef() };
     return cache([testObjects], ctx.bind(ctxRef, function () {
         return assign({}, produceDraft(), {
@@ -1318,6 +1518,15 @@ function deferDoneCallback(doneCallback, fieldName) {
     });
 }
 
+/**
+ * Removes test object from suite state
+ */
+function removeTestFromState (testObject) {
+    useSetTests(function (tests) {
+        return transform(tests, function (test) { return (testObject !== test ? test : null); });
+    });
+}
+
 function createBus() {
     var listeners = {};
     return {
@@ -1353,8 +1562,7 @@ function callEach(arr) {
 function runFieldCallbacks(fieldName) {
     var fieldCallbacks = useTestCallbacks()[0].fieldCallbacks;
     if (fieldName) {
-        if (!hasRemainingTests(fieldName) &&
-            Array.isArray(fieldCallbacks[fieldName])) {
+        if (!hasRemainingTests(fieldName) && isArray(fieldCallbacks[fieldName])) {
             callEach(fieldCallbacks[fieldName]);
         }
     }
@@ -1406,22 +1614,23 @@ function create(suiteCallback) {
         for (var _i = 0; _i < arguments.length; _i++) {
             args[_i] = arguments[_i];
         }
-        var prevTestObjects = useTestObjects()[0];
-        var _a = usePrevTestObjects(), setPrevTestObjects = _a[1];
         state.reset();
-        setPrevTestObjects(function () { return prevTestObjects; });
         // Run the consumer's callback
-        suiteCallback.apply(void 0, args);
+        isolate({ type: IsolateTypes.SUITE }, function () {
+            suiteCallback.apply(void 0, args);
+        });
+        omitOptionalTests();
         var res = produceFullResult();
         return res;
     }), {
         get: ctx.bind({ stateRef: stateRef }, produceDraft),
         remove: ctx.bind({ stateRef: stateRef }, function (name) {
-            var testObjects = useTestObjects()[0];
+            var testObjects = useTestsFlat();
             // We're mutating the array in `cancel`, so we have to first copy it.
-            asArray(testObjects).forEach(function (testObject) {
+            testObjects.forEach(function (testObject) {
                 if (matchingFieldName(testObject, name)) {
                     testObject.cancel();
+                    removeTestFromState(testObject);
                 }
             });
         }),
@@ -1535,6 +1744,12 @@ function hasIncludedTests(keyTests) {
     return false;
 }
 
+function skipWhen(conditional, callback) {
+    isolate({ type: IsolateTypes.SKIP_WHEN }, function () {
+        ctx.run({ skipped: optionalFunctionValue(conditional) }, function () { return callback(); });
+    });
+}
+
 var ERROR_OUTSIDE_OF_TEST = "warn hook called outside of a test callback. It won't have an effect."
     ;
 /**
@@ -1548,10 +1763,6 @@ function warn() {
     ctx$1.currentTest.warn();
 }
 
-function skipWhen(conditional, callback) {
-    ctx.run({ skipped: optionalFunctionValue(conditional) }, function () { return callback(); });
-}
-
 /**
  * Runs a group callback.
  */
@@ -1563,7 +1774,9 @@ function group(groupName, tests) {
         throwGroupError('callback must be a function');
     }
     // Running with the context applied
-    ctx.run({ groupName: groupName }, tests);
+    isolate({ type: IsolateTypes.GROUP }, function () {
+        ctx.run({ groupName: groupName }, tests);
+    });
 }
 function throwGroupError(error) {
     throwError("Wrong arguments passed to group. Group " + error + ".");
@@ -1572,36 +1785,22 @@ function throwGroupError(error) {
 function optional(optionals) {
     var _a = useOptionalFields(), setOptionalFields = _a[1];
     setOptionalFields(function (state) {
-        asArray(optionals).forEach(function (optionalField) {
-            state[optionalField] = true;
-        });
+        if (!isArray(optionals) && !isStringValue(optionals)) {
+            var optionalFunctions = optionals;
+            for (var field in optionalFunctions) {
+                var predicate = optionalFunctions[field];
+                state[field] = predicate;
+            }
+        }
+        else {
+            asArray(optionals).forEach(function (optionalField) {
+                state[optionalField] = true;
+            });
+        }
         return state;
     });
 }
 
-/**
- * Removes first found element from array
- * WARNING: Mutates array
- */
-function removeElementFromArray(array, element) {
-    var index = array.indexOf(element);
-    if (index !== -1) {
-        array.splice(index, 1);
-    }
-    return array;
-}
-
-/**
- * Removes test object from suite state
- */
-function removeTestFromState (testObject) {
-    var _a = useTestObjects(), setTestObjects = _a[1];
-    setTestObjects(function (testObjects) {
-        // using asArray to clear the cache.
-        return asArray(removeElementFromArray(testObjects, testObject));
-    });
-}
-
 function shouldUseErrorAsMessage(message, error) {
     // kind of cheating with this safe guard, but it does the job
     return isUndefined(message) && isStringValue(error);
@@ -1639,7 +1838,7 @@ var VestTest = /** @class */ (function () {
         return result;
     };
     VestTest.prototype.setStatus = function (status) {
-        if (this.isCanceled()) {
+        if (this.isFinalStatus() && status !== STATUS_OMITTED) {
             return;
         }
         this.status = status;
@@ -1651,7 +1850,7 @@ var VestTest = /** @class */ (function () {
         this.setStatus(this.warns ? STATUS_WARNING : STATUS_FAILED);
     };
     VestTest.prototype.done = function () {
-        if (this.isWarning() || this.isCanceled() || this.isFailing()) {
+        if (this.isFinalStatus()) {
             return;
         }
         this.setStatus(STATUS_PASSING);
@@ -1659,12 +1858,18 @@ var VestTest = /** @class */ (function () {
     VestTest.prototype.warn = function () {
         this.warns = true;
     };
+    VestTest.prototype.isFinalStatus = function () {
+        return this.hasFailures() || this.isCanceled() || this.isPassing();
+    };
     VestTest.prototype.skip = function () {
         this.setStatus(STATUS_SKIPPED);
     };
     VestTest.prototype.cancel = function () {
         this.setStatus(STATUS_CANCELED);
-        removeTestFromState(this);
+        useRefreshTestObjects();
+    };
+    VestTest.prototype.omit = function () {
+        this.setStatus(STATUS_OMITTED);
     };
     VestTest.prototype.valueOf = function () {
         return !this.isFailing();
@@ -1678,6 +1883,9 @@ var VestTest = /** @class */ (function () {
     VestTest.prototype.isTested = function () {
         return this.hasFailures() || this.isPassing();
     };
+    VestTest.prototype.isOmitted = function () {
+        return this.status === STATUS_OMITTED;
+    };
     VestTest.prototype.isUntested = function () {
         return this.status === STATUS_UNTESTED;
     };
@@ -1705,6 +1913,7 @@ var STATUS_WARNING = 'WARNING';
 var STATUS_PASSING = 'PASSING';
 var STATUS_PENDING = 'PENDING';
 var STATUS_CANCELED = 'CANCELED';
+var STATUS_OMITTED = 'OMITTED';
 
 function isPromise(value) {
     return value && isFunction(value.then);
@@ -1733,6 +1942,8 @@ function runAsyncTest(testObject) {
     var emit = useBus().emit;
     var stateRef = useStateRef();
     var done = ctx.bind({ stateRef: stateRef }, function () {
+        // invalidating the "produce" cache
+        useRefreshTestObjects();
         emit(Events.TEST_COMPLETED, testObject);
     });
     var fail = ctx.bind({ stateRef: stateRef }, function (rejectionMessage) {
@@ -1743,8 +1954,6 @@ function runAsyncTest(testObject) {
             ? rejectionMessage
             : message;
         testObject.fail();
-        // invalidating the "produce" cache
-        useRefreshTestObjects();
         done();
     });
     try {
@@ -1798,21 +2007,86 @@ function registerTest(testObject) {
             emit(Events.TEST_COMPLETED, testObject);
         }
     }
-    catch (_a) {
+    catch (e) {
         throwError("Your test function " + testObject.fieldName + " returned " + JSON.stringify(result) + ". Only \"false\" or a Promise are supported. Return values may cause unexpected behavior.");
     }
 }
 
+/**
+ * This module serves as the "collision detection" mechanism for Vest.
+ * It is used to ensure that tests are not called in a different order than
+ * they were called in the previous run.
+ * If they are, it will throw a deferred error unless explicitly allowed.
+ *
+ * For now it seems pretty safe, and it covers most common use cases, but it can
+ * be improved in the future both in terms of performance and scenarios it covers.
+ */
+// eslint-disable-next-line max-statements, max-lines-per-function
+function useTestAtCursor(newTestObject) {
+    var _a = useTestObjects(), testObjects = _a[0], setTestObjects = _a[1];
+    var prevTests = testObjects.prev;
+    if (isEmpty(prevTests)) {
+        useSetTestAtCursor(newTestObject);
+        return newTestObject;
+    }
+    var prevTest = useGetTestAtCursor(prevTests);
+    if (shouldPurgePrevTest(prevTest, newTestObject)) {
+        throwTestOrderError(prevTest, newTestObject);
+        // Here we handle just the omission of tests in the middle of the test suite.
+        // We need to also handle a case in which tests are added in between other tests.
+        // At the moment all we can do is just splice the tests out of the array when this happens.
+        // A viable solution would be to use something like React's key prop to identify tests regardless
+        // of their position in the suite. https://reactjs.org/docs/lists-and-keys.html#keys
+        var current = getCurrent(prevTests, usePath());
+        var cursorAt = useCursorAt();
+        current.splice(cursorAt);
+        // We actually don't mind mutating the state directly (as can be seen above). There is no harm in it
+        // since we're only touching the "prev" state. The reason we still use the setter function is
+        // to prevent future headaches if we ever do need to rely on prev-state immutability.
+        setTestObjects(function (_a) {
+            var current = _a.current;
+            return ({
+                prev: prevTests,
+                current: current
+            });
+        });
+        // Need to see if this has any effect at all.
+        prevTest = null;
+    }
+    var nextTest = defaultTo(prevTest, newTestObject);
+    useSetTestAtCursor(nextTest);
+    return nextTest;
+}
+function useSetTestAtCursor(testObject) {
+    var cursorPath = usePath();
+    useSetTests(function (tests) {
+        return setValueAtPath(tests, cursorPath, testObject);
+    });
+}
+function useGetTestAtCursor(tests) {
+    var cursorPath = usePath();
+    return valueAtPath(tests, cursorPath);
+}
+function shouldPurgePrevTest(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: " + prevTest.fieldName + "\n    received: " + newTestObject.fieldName + "\n    This happens when you conditionally call your tests using if/else.\n    This might lead to incorrect validation results.\n    Replacing if/else with skipWhen solves these issues.");
+}
+
 function registerPrevRunTest(testObject) {
     var prevRunTest = useTestAtCursor(testObject);
     if (isExcluded(testObject)) {
         testObject.skip();
-        useSetNextCursorAt();
+        moveForward();
         return prevRunTest;
     }
     cancelOverriddenPendingTest(prevRunTest, testObject);
     useSetTestAtCursor(testObject);
-    useSetNextCursorAt();
+    moveForward();
     registerTestObjectByTier(testObject);
     return testObject;
 }
@@ -1831,7 +2105,7 @@ function bindTestEach(test) {
      * Run multiple tests using a parameter table
      */
     function each(table) {
-        if (!Array.isArray(table)) {
+        if (!isArray(table)) {
             throwError('test.each: Expected table to be an array.');
         }
         function eachReturn(fieldName) {
@@ -1840,9 +2114,12 @@ function bindTestEach(test) {
                 args[_i - 1] = arguments[_i];
             }
             var _a = args.reverse(), testFn = _a[0], message = _a[1];
-            return table.map(function (item) {
-                item = asArray(item);
-                return test(optionalFunctionValue.apply(void 0, __spreadArray([fieldName], item, false)), optionalFunctionValue.apply(void 0, __spreadArray([message], item, false)), function () { return testFn.apply(void 0, item); });
+            return isolate({ type: IsolateTypes.EACH }, function () {
+                return table.map(function (item) {
+                    item = asArray(item);
+                    return test(optionalFunctionValue.apply(void 0, __spreadArray([fieldName], item)), optionalFunctionValue.apply(void 0, __spreadArray([message], item)), function () { return testFn.apply(void 0, item); } // eslint-disable-line max-nested-callbacks
+                    );
+                });
             });
         }
         return eachReturn;
@@ -1860,7 +2137,7 @@ function bindTestMemo(test) {
             args[_i - 1] = arguments[_i];
         }
         var suiteId = useSuiteId()[0];
-        var cursorAt = useCursorAt()[0];
+        var cursorAt = useCursorAt();
         var _a = args.reverse(), deps = _a[0], testFn = _a[1], msg = _a[2];
         // Implicit dependency for more specificity
         var dependencies = [suiteId, fieldName, cursorAt].concat(deps);
@@ -1897,6 +2174,6 @@ var test = assign(testBase, {
     memo: bindTestMemo(testBase)
 });
 
-var VERSION = "4.0.0-dev-deabb8";
+var VERSION = "4.0.0-dev-8851ff";
 
 export { VERSION, create, enforce, group, only, optional, skip, skipWhen, test, warn };