vest 4.0.0-dev-7acb76 → 4.0.0-dev-1aae50

package/dist/cjs/vest.development.js

@@ -2,63 +2,22 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-var __assign = function() {
-    __assign = Object.assign || function __assign(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-
-function __spreadArray(to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || from);
-}
+var n4s = require('n4s');
+var context$1 = require('context');
 
 var assign = Object.assign;
 
+/**
+ * @returns a unique numeric id.
+ */
+var genId = (function (n) { return function () {
+    return "" + n++;
+}; })(0);
+
 function isFunction(value) {
     return typeof value === 'function';
 }
 
-function mapFirst(array, callback) {
-    var broke = false;
-    var breakoutValue = null;
-    for (var i = 0; i < array.length; i++) {
-        callback(array[i], breakout, i);
-        if (broke) {
-            return breakoutValue;
-        }
-    }
-    function breakout(value) {
-        broke = true;
-        breakoutValue = value;
-    }
-}
-
 function optionalFunctionValue(value) {
     var args = [];
     for (var _i = 1; _i < arguments.length; _i++) {
@@ -72,380 +31,6 @@ function defaultTo(callback, defaultValue) {
     return (_a = optionalFunctionValue(callback)) !== null && _a !== void 0 ? _a : defaultValue;
 }
 
-function ruleReturn(pass, message) {
-    var output = { pass: pass };
-    if (message) {
-        output.message = message;
-    }
-    return output;
-}
-function failing() {
-    return ruleReturn(false);
-}
-function passing() {
-    return ruleReturn(true);
-}
-function defaultToFailing(callback) {
-    return defaultTo(callback, failing());
-}
-function defaultToPassing(callback) {
-    return defaultTo(callback, passing());
-}
-
-function runLazyRule(lazyRule, currentValue) {
-    try {
-        return lazyRule.run(currentValue);
-    }
-    catch (_a) {
-        return failing();
-    }
-}
-
-function allOf(value) {
-    var rules = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        rules[_i - 1] = arguments[_i];
-    }
-    return defaultToPassing(mapFirst(rules, function (rule, breakout) {
-        var res = runLazyRule(rule, value);
-        if (!res.pass) {
-            breakout(res);
-        }
-    }));
-}
-
-function anyOf(value) {
-    var rules = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        rules[_i - 1] = arguments[_i];
-    }
-    return defaultToFailing(mapFirst(rules, function (rule, breakout) {
-        var res = runLazyRule(rule, value);
-        if (res.pass) {
-            breakout(res);
-        }
-    }));
-}
-
-function noneOf(value) {
-    var rules = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        rules[_i - 1] = arguments[_i];
-    }
-    return defaultToPassing(mapFirst(rules, function (rule, breakout) {
-        var res = runLazyRule(rule, value);
-        if (res.pass) {
-            breakout(failing());
-        }
-    }));
-}
-
-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 lengthEquals(value, arg1) {
-    return value.length === Number(arg1);
-}
-var lengthNotEquals = bindNot(lengthEquals);
-
-function longerThan(value, arg1) {
-    return value.length > Number(arg1);
-}
-
-function oneOf(value) {
-    var rules = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        rules[_i - 1] = arguments[_i];
-    }
-    var passing = [];
-    rules.some(function (rule) {
-        if (longerThan(passing, 1)) {
-            return false;
-        }
-        var res = runLazyRule(rule, value);
-        if (res.pass) {
-            passing.push(res);
-        }
-    });
-    return ruleReturn(lengthEquals(passing, 1));
-}
-
-function isNull(value) {
-    return value === null;
-}
-var isNotNull = bindNot(isNull);
-
-function isUndefined(value) {
-    return value === undefined;
-}
-var isNotUndefined = bindNot(isUndefined);
-
-function optional$1(value, ruleChain) {
-    if (isUndefined(value) || isNull(value)) {
-        return passing();
-    }
-    return runLazyRule(ruleChain, value);
-}
-
-function compounds() {
-    return { allOf: allOf, anyOf: anyOf, noneOf: noneOf, oneOf: oneOf, optional: optional$1 };
-}
-
-function isStringValue(v) {
-    return String(v) === v;
-}
-
-function endsWith(value, arg1) {
-    return isStringValue(value) && isStringValue(arg1) && value.endsWith(arg1);
-}
-var doesNotEndWith = bindNot(endsWith);
-
-function equals(value, arg1) {
-    return value === arg1;
-}
-var notEquals = bindNot(equals);
-
-function isNumeric(value) {
-    var str = String(value);
-    var num = Number(value);
-    var result = !isNaN(parseFloat(str)) && !isNaN(Number(value)) && isFinite(num);
-    return Boolean(result);
-}
-var isNotNumeric = bindNot(isNumeric);
-
-function greaterThan(value, gt) {
-    return isNumeric(value) && isNumeric(gt) && Number(value) > Number(gt);
-}
-
-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 (isArray(arg1)) {
-        return arg1.indexOf(value) !== -1;
-    }
-    // both value and arg1 are strings
-    if (isStringValue(arg1) && isStringValue(value)) {
-        return arg1.indexOf(value) !== -1;
-    }
-    return false;
-}
-var notInside = bindNot(inside);
-
-function lessThanOrEquals(value, lte) {
-    return isNumeric(value) && isNumeric(lte) && Number(value) <= Number(lte);
-}
-
-function isBetween(value, min, max) {
-    return greaterThanOrEquals(value, min) && lessThanOrEquals(value, max);
-}
-var isNotBetween = bindNot(isBetween);
-
-function isBlank(value) {
-    return isStringValue(value) && !value.trim();
-}
-var isNotBlank = bindNot(isBlank);
-
-function isBoolean(value) {
-    return !!value === value;
-}
-
-var isNotBoolean = bindNot(isBoolean);
-
-/**
- * A safe hasOwnProperty access
- */
-function hasOwnProperty(obj, key) {
-    return Object.prototype.hasOwnProperty.call(obj, key);
-}
-
-function isNumber(value) {
-    return Boolean(typeof value === 'number');
-}
-var isNotNumber = bindNot(isNumber);
-
-function isEmpty(value) {
-    if (!value) {
-        return true;
-    }
-    else if (isNumber(value)) {
-        return value === 0;
-    }
-    else if (hasOwnProperty(value, 'length')) {
-        return lengthEquals(value, 0);
-    }
-    else if (typeof value === 'object') {
-        return lengthEquals(Object.keys(value), 0);
-    }
-    return true;
-}
-var isNotEmpty = bindNot(isEmpty);
-
-/**
- * Validates that a given value is an even number
- */
-var isEven = function (value) {
-    if (isNumeric(value)) {
-        return value % 2 === 0;
-    }
-    return false;
-};
-
-function isNaN$1(value) {
-    return Number.isNaN(value);
-}
-var isNotNaN = bindNot(isNaN$1);
-
-function isNegative(value) {
-    if (isNumeric(value)) {
-        return Number(value) < 0;
-    }
-    return false;
-}
-var isPositive = bindNot(isNegative);
-
-/**
- * Validates that a given value is an odd number
- */
-var isOdd = function (value) {
-    if (isNumeric(value)) {
-        return value % 2 !== 0;
-    }
-    return false;
-};
-
-var isNotString = bindNot(isStringValue);
-
-function isTruthy(value) {
-    return !!value;
-}
-var isFalsy = bindNot(isTruthy);
-
-function lessThan(value, lt) {
-    return isNumeric(value) && isNumeric(lt) && Number(value) < Number(lt);
-}
-
-function longerThanOrEquals(value, arg1) {
-    return value.length >= Number(arg1);
-}
-
-function matches(value, regex) {
-    if (regex instanceof RegExp) {
-        return regex.test(value);
-    }
-    else if (isStringValue(regex)) {
-        return new RegExp(regex).test(value);
-    }
-    else {
-        return false;
-    }
-}
-var notMatches = bindNot(matches);
-
-function numberEquals(value, eq) {
-    return isNumeric(value) && isNumeric(eq) && Number(value) === Number(eq);
-}
-var numberNotEquals = bindNot(numberEquals);
-
-function condition(value, callback) {
-    try {
-        return callback(value);
-    }
-    catch (_a) {
-        return false;
-    }
-}
-
-function shorterThan(value, arg1) {
-    return value.length < Number(arg1);
-}
-
-function shorterThanOrEquals(value, arg1) {
-    return value.length <= Number(arg1);
-}
-
-function startsWith(value, arg1) {
-    return isStringValue(value) && isStringValue(arg1) && value.startsWith(arg1);
-}
-var doesNotStartWith = bindNot(startsWith);
-
-// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, max-lines-per-function
-function rules() {
-    return {
-        condition: condition,
-        doesNotEndWith: doesNotEndWith,
-        doesNotStartWith: doesNotStartWith,
-        endsWith: endsWith,
-        equals: equals,
-        greaterThan: greaterThan,
-        greaterThanOrEquals: greaterThanOrEquals,
-        gt: greaterThan,
-        gte: greaterThanOrEquals,
-        inside: inside,
-        isArray: isArray,
-        isBetween: isBetween,
-        isBlank: isBlank,
-        isBoolean: isBoolean,
-        isEmpty: isEmpty,
-        isEven: isEven,
-        isFalsy: isFalsy,
-        isNaN: isNaN$1,
-        isNegative: isNegative,
-        isNotArray: isNotArray,
-        isNotBetween: isNotBetween,
-        isNotBlank: isNotBlank,
-        isNotBoolean: isNotBoolean,
-        isNotEmpty: isNotEmpty,
-        isNotNaN: isNotNaN,
-        isNotNull: isNotNull,
-        isNotNumber: isNotNumber,
-        isNotNumeric: isNotNumeric,
-        isNotString: isNotString,
-        isNotUndefined: isNotUndefined,
-        isNull: isNull,
-        isNumber: isNumber,
-        isNumeric: isNumeric,
-        isOdd: isOdd,
-        isPositive: isPositive,
-        isString: isStringValue,
-        isTruthy: isTruthy,
-        isUndefined: isUndefined,
-        lengthEquals: lengthEquals,
-        lengthNotEquals: lengthNotEquals,
-        lessThan: lessThan,
-        lessThanOrEquals: lessThanOrEquals,
-        longerThan: longerThan,
-        longerThanOrEquals: longerThanOrEquals,
-        lt: lessThan,
-        lte: lessThanOrEquals,
-        matches: matches,
-        notEquals: notEquals,
-        notInside: notInside,
-        notMatches: notMatches,
-        numberEquals: numberEquals,
-        numberNotEquals: numberNotEquals,
-        shorterThan: shorterThan,
-        shorterThanOrEquals: shorterThanOrEquals,
-        startsWith: startsWith
-    };
-}
-
 /**
  * Throws a timed out error.
  */
@@ -458,349 +43,6 @@ function throwErrorDeferred(devMessage, productionMessage) {
     }, 0);
 }
 
-// eslint-disable-next-line max-lines-per-function
-function createContext(init) {
-    var storage = { ancestry: [] };
-    return {
-        bind: bind,
-        run: run,
-        use: use,
-        useX: useX
-    };
-    function useX(errorMessage) {
-        var _a;
-        return ((_a = storage.ctx) !== null && _a !== void 0 ? _a : throwError(defaultTo(errorMessage, 'Context was used after it was closed')));
-    }
-    function run(ctxRef, fn) {
-        var _a;
-        var parentContext = use();
-        var out = assign({}, parentContext ? parentContext : {}, (_a = init === null || init === void 0 ? void 0 : init(ctxRef, parentContext)) !== null && _a !== void 0 ? _a : ctxRef);
-        var ctx = set(Object.freeze(out));
-        storage.ancestry.unshift(ctx);
-        var res = fn(ctx);
-        clear();
-        return res;
-    }
-    function bind(ctxRef, fn) {
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore - this one's pretty hard to get right
-        var returnedFn = function () {
-            var runTimeArgs = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                runTimeArgs[_i] = arguments[_i];
-            }
-            return run(ctxRef, function () {
-                return fn.apply(void 0, runTimeArgs);
-            });
-        };
-        return returnedFn;
-    }
-    function use() {
-        return storage.ctx;
-    }
-    function set(value) {
-        return (storage.ctx = value);
-    }
-    function clear() {
-        var _a;
-        storage.ancestry.shift();
-        set((_a = storage.ancestry[0]) !== null && _a !== void 0 ? _a : null);
-    }
-}
-
-var ctx$1 = createContext(function (ctxRef, parentContext) {
-    var base = {
-        value: ctxRef.value,
-        meta: ctxRef.meta || {}
-    };
-    if (!parentContext) {
-        return assign(base, {
-            parent: emptyParent
-        });
-    }
-    else if (ctxRef.set) {
-        return assign(base, {
-            parent: function () { return stripContext(parentContext); }
-        });
-    }
-    return parentContext;
-});
-function stripContext(ctx) {
-    if (!ctx) {
-        return ctx;
-    }
-    return {
-        value: ctx.value,
-        meta: ctx.meta,
-        parent: ctx.parent
-    };
-}
-function emptyParent() {
-    return null;
-}
-
-function isArrayOf(inputArray, currentRule) {
-    return defaultToPassing(mapFirst(inputArray, function (currentValue, breakout, index) {
-        var res = ctx$1.run({ value: currentValue, set: true, meta: { index: index } }, function () { return runLazyRule(currentRule, currentValue); });
-        if (!res.pass) {
-            breakout(res);
-        }
-    }));
-}
-
-function loose(inputObject, shapeObject) {
-    var _loop_1 = function (key) {
-        var currentValue = inputObject[key];
-        var currentRule = shapeObject[key];
-        var res = ctx$1.run({ value: currentValue, set: true, meta: { key: key } }, function () {
-            return runLazyRule(currentRule, currentValue);
-        });
-        if (!res.pass) {
-            return { value: res };
-        }
-    };
-    for (var key in shapeObject) {
-        var state_1 = _loop_1(key);
-        if (typeof state_1 === "object")
-            return state_1.value;
-    }
-    return passing();
-}
-
-function shape(inputObject, shapeObject) {
-    var baseRes = loose(inputObject, shapeObject);
-    if (!baseRes.pass) {
-        return baseRes;
-    }
-    for (var key in inputObject) {
-        if (!hasOwnProperty(shapeObject, key)) {
-            return failing();
-        }
-    }
-    return passing();
-}
-
-function schema() {
-    return { shape: shape, loose: loose, isArrayOf: isArrayOf };
-}
-
-var baseRules = assign(rules(), compounds(), schema());
-function getRule(ruleName) {
-    return baseRules[ruleName];
-}
-
-function eachEnforceRule(action) {
-    for (var ruleName in baseRules) {
-        var ruleFn = getRule(ruleName);
-        if (isFunction(ruleFn)) {
-            action(ruleName, ruleFn);
-        }
-    }
-}
-
-function isProxySupported() {
-    try {
-        return typeof Proxy === 'function';
-    }
-    catch (_a) {
-        return false;
-    }
-}
-
-/**
- * Transform the result of a rule into a standard format
- */
-function transformResult(result, ruleName, value) {
-    var args = [];
-    for (var _i = 3; _i < arguments.length; _i++) {
-        args[_i - 3] = arguments[_i];
-    }
-    validateResult(result);
-    // if result is boolean
-    if (isBoolean(result)) {
-        return ruleReturn(result);
-    }
-    else {
-        return ruleReturn(result.pass, optionalFunctionValue.apply(void 0, __spreadArray([result.message, ruleName, value], args)));
-    }
-}
-function validateResult(result) {
-    // if result is boolean, or if result.pass is boolean
-    if (isBoolean(result) || (result && isBoolean(result.pass))) {
-        return;
-    }
-    throwError('Incorrect return value for rule: ' + JSON.stringify(result));
-}
-
-function enforceEager(value) {
-    var target = {};
-    if (!isProxySupported()) {
-        eachEnforceRule(function (ruleName, ruleFn) {
-            target[ruleName] = genRuleCall(target, ruleFn, ruleName);
-        });
-        return target;
-    }
-    var proxy = new Proxy(target, {
-        get: function (_, ruleName) {
-            var rule = getRule(ruleName);
-            if (rule) {
-                return genRuleCall(proxy, rule, ruleName);
-            }
-        }
-    });
-    return proxy;
-    function genRuleCall(target, rule, ruleName) {
-        return function ruleCall() {
-            var args = [];
-            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)); }),
-                ruleName,
-                value], args));
-            if (!transformedResult.pass) {
-                if (isEmpty(transformedResult.message)) {
-                    throwError("enforce/" + ruleName + " failed with " + JSON.stringify(value));
-                }
-                else {
-                    // Explicitly throw a string so that vest.test can pick it up as the validation error message
-                    throw transformedResult.message;
-                }
-            }
-            return target;
-        };
-    }
-}
-
-// eslint-disable-next-line max-lines-per-function
-function genEnforceLazy(key) {
-    var registeredRules = [];
-    var lazyMessage;
-    return addLazyRule(key);
-    // eslint-disable-next-line max-lines-per-function
-    function addLazyRule(ruleName) {
-        // eslint-disable-next-line max-lines-per-function
-        return function () {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            var rule = getRule(ruleName);
-            registeredRules.push(function (value) {
-                return transformResult.apply(void 0, __spreadArray([rule.apply(void 0, __spreadArray([value], args)), ruleName, value], args));
-            });
-            var proxy = {
-                run: function (value) {
-                    return defaultToPassing(mapFirst(registeredRules, function (rule, breakout) {
-                        var _a;
-                        var res = ctx$1.run({ value: value }, function () { return rule(value); });
-                        if (!res.pass) {
-                            breakout(ruleReturn(!!res.pass, (_a = optionalFunctionValue(lazyMessage, value, res.message)) !== null && _a !== void 0 ? _a : res.message));
-                        }
-                    }));
-                },
-                test: function (value) { return proxy.run(value).pass; },
-                message: function (message) {
-                    if (message) {
-                        lazyMessage = message;
-                    }
-                    return proxy;
-                }
-            };
-            if (!isProxySupported()) {
-                eachEnforceRule(function (ruleName) {
-                    proxy[ruleName] = addLazyRule(ruleName);
-                });
-                return proxy;
-            }
-            // reassigning the proxy here is not pretty
-            // but it's a cleaner way of getting `run` and `test` for free
-            proxy = new Proxy(proxy, {
-                get: function (target, key) {
-                    if (getRule(key)) {
-                        return addLazyRule(key);
-                    }
-                    return target[key]; // already has `run` and `test` on it
-                }
-            });
-            return proxy;
-        };
-    }
-}
-
-// Help needed improving the typings of this file.
-// Ideally, we'd be able to extend TShapeObject, but that's not possible.
-function partial(shapeObject) {
-    var output = {};
-    for (var key in shapeObject) {
-        output[key] = enforce.optional(shapeObject[key]);
-    }
-    return output;
-}
-
-function modifiers() {
-    return { partial: partial };
-}
-
-/**
- * Enforce is quite complicated, I want to explain it in detail.
- * It is dynamic in nature, so a lot of proxy objects are involved.
- *
- * Enforce has two main interfaces
- * 1. eager
- * 2. lazy
- *
- * The eager interface is the most commonly used, and the easier to understand.
- * It throws an error when a rule is not satisfied.
- * The eager interface is declared in enforceEager.ts and it is quite simple to understand.
- * enforce is called with a value, and the return value is a proxy object that points back to all the rules.
- * When a rule is called, the value is mapped as its first argument, and if the rule passes, the same
- * proxy object is returned. Otherwise, an error is thrown.
- *
- * The lazy interface works quite differently. It is declared in genEnforceLazy.ts.
- * Rather than calling enforce directly, the lazy interface has all the rules as "methods" (only by proxy).
- * Calling the first function in the chain will initialize an array of calls. It stores the different rule calls
- * and the parameters passed to them. None of the rules are called yet.
- * The rules are only invoked in sequence once either of these chained functions are called:
- * 1. test(value)
- * 2. run(value)
- *
- * Calling run or test will call all the rules in sequence, with the difference that test will only return a boolean value,
- * while run will return an object with the validation result and an optional message created by the rule.
- */
-function genEnforce() {
-    var target = __assign({ context: function () { return ctx$1.useX(); }, extend: function (customRules) {
-            assign(baseRules, customRules);
-        } }, modifiers());
-    if (!isProxySupported()) {
-        eachEnforceRule(function (ruleName) {
-            // Only on the first rule access - start the chain of calls
-            target[ruleName] = genEnforceLazy(ruleName);
-        });
-        return target;
-    }
-    return new Proxy(assign(enforceEager, target), {
-        get: function (target, key) {
-            if (key in target) {
-                return target[key];
-            }
-            if (!getRule(key)) {
-                return;
-            }
-            // Only on the first rule access - start the chain of calls
-            return genEnforceLazy(key);
-        }
-    });
-}
-var enforce = genEnforce();
-
-/**
- * @returns a unique numeric id.
- */
-var genId = (function (n) { return function () {
-    return "" + n++;
-}; })(0);
-
 // eslint-disable-next-line max-lines-per-function
 function createState(onStateChange) {
     var state = {
@@ -875,17 +117,18 @@ var IsolateTypes;
 })(IsolateTypes || (IsolateTypes = {}));
 
 function createStateRef(state, _a) {
-    var suiteId = _a.suiteId;
+    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 : []),
+                prev: prev ? prev.current : [],
                 current: []
             };
         })
@@ -898,8 +141,7 @@ function asArray(possibleArg) {
 
 function last(values) {
     var valuesArray = asArray(values);
-    var _a = valuesArray, l = _a.length, _b = l - 1, lastValue = _a[_b];
-    return lastValue;
+    return valuesArray[valuesArray.length - 1];
 }
 
 function createCursor() {
@@ -936,19 +178,47 @@ function createCursor() {
     };
 }
 
-var ctx = createContext(function (ctxRef, parentContext) {
+var context = context$1.createContext(function (ctxRef, parentContext) {
     return parentContext
         ? null
         : assign({}, {
-            isolate: { type: IsolateTypes.DEFAULT },
-            testCursor: createCursor(),
             exclusion: {
                 tests: {},
                 groups: {}
-            }
+            },
+            isolate: {
+                type: IsolateTypes.DEFAULT,
+                keys: {
+                    current: {},
+                    prev: {}
+                }
+            },
+            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);
+    };
+}
+
+// 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));
+}
+
+function isNull(value) {
+    return value === null;
+}
+var isNotNull = bindNot(isNull);
+
 // 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
@@ -994,6 +264,31 @@ function getCurrent(array, path) {
     return current;
 }
 
+function isUndefined(value) {
+    return value === undefined;
+}
+
+function isNullish(value) {
+    return isNull(value) || isUndefined(value);
+}
+
+function isStringValue(v) {
+    return String(v) === v;
+}
+
+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
  */
@@ -1035,11 +330,14 @@ function createCache(maxSize) {
 // STATE REF
 function useStateRef() {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    return ctx.useX().stateRef; // I should revisit this
+    return context.useX().stateRef; // I should revisit this
 }
 // STATE KEYS
 function useSuiteId() {
-    return useStateRef().suiteId();
+    return useStateRef().suiteId()[0];
+}
+function useSuiteName() {
+    return useStateRef().suiteName()[0];
 }
 function useTestCallbacks() {
     return useStateRef().testCallbacks();
@@ -1096,25 +394,187 @@ function useTestsFlat() {
     return flatCache([current], function () { return flatten(current); });
 }
 
+var TestSeverity;
+(function (TestSeverity) {
+    TestSeverity["Error"] = "error";
+    TestSeverity["Warning"] = "warning";
+})(TestSeverity || (TestSeverity = {}));
+var VestTest = /** @class */ (function () {
+    function VestTest(fieldName, testFn, _a) {
+        var _b = _a === void 0 ? {} : _a, message = _b.message, groupName = _b.groupName, key = _b.key;
+        this.key = null;
+        this.id = genId();
+        this.severity = TestSeverity.Error;
+        this.status = STATUS_UNTESTED;
+        this.fieldName = fieldName;
+        this.testFn = testFn;
+        if (groupName) {
+            this.groupName = groupName;
+        }
+        if (message) {
+            this.message = message;
+        }
+        if (key) {
+            this.key = key;
+        }
+    }
+    VestTest.prototype.run = function () {
+        var result;
+        try {
+            result = this.testFn();
+        }
+        catch (error) {
+            if (shouldUseErrorAsMessage(this.message, error)) {
+                this.message = error;
+            }
+            result = false;
+        }
+        if (result === false) {
+            this.fail();
+        }
+        return result;
+    };
+    VestTest.prototype.setStatus = function (status) {
+        if (this.isFinalStatus() && status !== STATUS_OMITTED) {
+            return;
+        }
+        this.status = status;
+    };
+    VestTest.prototype.warns = function () {
+        return this.severity === TestSeverity.Warning;
+    };
+    VestTest.prototype.setPending = function () {
+        this.setStatus(STATUS_PENDING);
+    };
+    VestTest.prototype.fail = function () {
+        this.setStatus(this.warns() ? STATUS_WARNING : STATUS_FAILED);
+    };
+    VestTest.prototype.done = function () {
+        if (this.isFinalStatus()) {
+            return;
+        }
+        this.setStatus(STATUS_PASSING);
+    };
+    VestTest.prototype.warn = function () {
+        this.severity = TestSeverity.Warning;
+    };
+    VestTest.prototype.isFinalStatus = function () {
+        return this.hasFailures() || this.isCanceled() || this.isPassing();
+    };
+    VestTest.prototype.skip = function (force) {
+        if (this.isPending() && !force) {
+            // Without this condition, the test will be marked as skipped even if it is pending.
+            // This means that it will not be counted in "allIncomplete" and its done callbacks
+            // will not be called, or will be called prematurely.
+            // What this mostly say is that when we have a pending test for one field, and we then
+            // start typing in a different field - the pending test will be canceled, which
+            // is usually an unwanted behavior.
+            // The only scenario in which we DO want to cancel the async test regardless
+            // is when we specifically skip a test with `skipWhen`, which is handled by the
+            // "force" boolean flag.
+            // I am not a fan of this flag, but it gets the job done.
+            return;
+        }
+        this.setStatus(STATUS_SKIPPED);
+    };
+    VestTest.prototype.cancel = function () {
+        this.setStatus(STATUS_CANCELED);
+        useRefreshTestObjects();
+    };
+    VestTest.prototype.omit = function () {
+        this.setStatus(STATUS_OMITTED);
+    };
+    VestTest.prototype.valueOf = function () {
+        return !this.isFailing();
+    };
+    VestTest.prototype.hasFailures = function () {
+        return this.isFailing() || this.isWarning();
+    };
+    VestTest.prototype.isPending = function () {
+        return this.status === STATUS_PENDING;
+    };
+    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;
+    };
+    VestTest.prototype.isFailing = function () {
+        return this.status === STATUS_FAILED;
+    };
+    VestTest.prototype.isCanceled = function () {
+        return this.status === STATUS_CANCELED;
+    };
+    VestTest.prototype.isSkipped = function () {
+        return this.status === STATUS_SKIPPED;
+    };
+    VestTest.prototype.isPassing = function () {
+        return this.status === STATUS_PASSING;
+    };
+    VestTest.prototype.isWarning = function () {
+        return this.status === STATUS_WARNING;
+    };
+    return VestTest;
+}());
+var STATUS_UNTESTED = 'UNTESTED';
+var STATUS_SKIPPED = 'SKIPPED';
+var STATUS_FAILED = 'FAILED';
+var STATUS_WARNING = 'WARNING';
+var STATUS_PASSING = 'PASSING';
+var STATUS_PENDING = 'PENDING';
+var STATUS_CANCELED = 'CANCELED';
+var STATUS_OMITTED = 'OMITTED';
+
 function usePath() {
-    var context = ctx.useX();
-    return context.testCursor.getCursor();
+    var context$1 = context.useX();
+    return context$1.testCursor.getCursor();
 }
 function useCursorAt() {
-    var context = ctx.useX();
-    return context.testCursor.cursorAt();
+    var context$1 = context.useX();
+    return context$1.testCursor.cursorAt();
 }
 function moveForward() {
-    var context = ctx.useX();
-    return context.testCursor.next();
+    var context$1 = context.useX();
+    return context$1.testCursor.next();
 }
 function addLevel() {
-    var context = ctx.useX();
-    context.testCursor.addLevel();
+    var context$1 = context.useX();
+    context$1.testCursor.addLevel();
 }
 function removeLevel() {
-    var context = ctx.useX();
-    context.testCursor.removeLevel();
+    var context$1 = context.useX();
+    context$1.testCursor.removeLevel();
+}
+
+function usePrevKeys() {
+    var prev = useTestObjects()[0].prev;
+    return asArray(getCurrent(prev, usePath())).reduce(function (prevKeys, testObject) {
+        if (!(testObject instanceof VestTest)) {
+            return prevKeys;
+        }
+        if (isNullish(testObject.key)) {
+            return prevKeys;
+        }
+        prevKeys[testObject.key] = testObject;
+        return prevKeys;
+    }, {});
+}
+function usePrevTestByKey(key) {
+    var prev = context.useX().isolate.keys.prev;
+    return prev[key];
+}
+function useRetainTestKey(key, testObject) {
+    var context$1 = context.useX();
+    var current = context$1.isolate.keys.current;
+    if (isNullish(current[key])) {
+        current[key] = testObject;
+    }
+    else {
+        throwErrorDeferred("Encountered the same test key \"" + key + "\" twice. This may lead to tests overriding each other's results, or to tests being unexpectedly omitted.");
+    }
 }
 
 function isolate(_a, callback) {
@@ -1122,9 +582,14 @@ function isolate(_a, callback) {
     if (!isFunction(callback)) {
         return;
     }
+    var keys = {
+        current: {},
+        prev: {}
+    };
     var path = usePath();
-    return ctx.run({ isolate: { type: type } }, function () {
+    return context.run({ isolate: { type: type, keys: keys } }, function () {
         addLevel();
+        keys.prev = usePrevKeys();
         useSetTests(function (tests) { return setValueAtPath(tests, path, []); });
         var res = callback();
         removeLevel();
@@ -1133,43 +598,42 @@ function isolate(_a, callback) {
     });
 }
 function shouldAllowReorder() {
-    return ctx.useX().isolate.type === IsolateTypes.EACH;
+    return context.useX().isolate.type === IsolateTypes.EACH;
 }
 
-function nonMatchingFieldName(testObject, fieldName) {
-    return !!fieldName && !matchingFieldName(testObject, fieldName);
+/**
+ * A safe hasOwnProperty access
+ */
+function hasOwnProperty(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
 }
-function matchingFieldName(testObject, fieldName) {
-    return !!(fieldName && testObject.fieldName === fieldName);
+
+function isNumber(value) {
+    return Boolean(typeof value === 'number');
 }
 
-function omitOptionalTests() {
-    var optionalFields = useOptionalFields()[0];
-    if (isEmpty(optionalFields)) {
-        return;
+function isEmpty(value) {
+    if (!value) {
+        return true;
     }
-    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();
-        }
+    else if (isNumber(value)) {
+        return value === 0;
+    }
+    else if (hasOwnProperty(value, 'length')) {
+        return lengthEquals(value, 0);
     }
+    else if (typeof value === 'object') {
+        return lengthEquals(Object.keys(value), 0);
+    }
+    return true;
+}
+var isNotEmpty = bindNot(isEmpty);
+
+function nonMatchingFieldName(testObject, fieldName) {
+    return !!fieldName && !matchingFieldName(testObject, fieldName);
+}
+function matchingFieldName(testObject, fieldName) {
+    return !!(fieldName && testObject.fieldName === fieldName);
 }
 
 /**
@@ -1252,6 +716,42 @@ function genTestObject(summaryKey, testObject) {
     return testKey;
 }
 
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || from);
+}
+
 function either(a, b) {
     return !!a !== !!b;
 }
@@ -1260,7 +760,7 @@ function either(a, b) {
  * 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 === 'warnings', testObject.warns());
 }
 
 function collectFailureMessages(severity, testObjects, options) {
@@ -1445,19 +945,21 @@ var cache$1 = createCache(20);
 function produceDraft() {
     var testObjects = useTestsFlat();
     var ctxRef = { stateRef: useStateRef() };
-    return cache$1([testObjects], ctx.bind(ctxRef, function () {
+    return cache$1([testObjects], context.bind(ctxRef, function () {
+        var suiteName = useSuiteName();
         return assign(genTestsSummary(), {
-            getErrors: ctx.bind(ctxRef, getErrors),
-            getErrorsByGroup: ctx.bind(ctxRef, getErrorsByGroup),
-            getWarnings: ctx.bind(ctxRef, getWarnings),
-            getWarningsByGroup: ctx.bind(ctxRef, getWarningsByGroup),
-            hasErrors: ctx.bind(ctxRef, hasErrors),
-            hasErrorsByGroup: ctx.bind(ctxRef, hasErrorsByGroup),
-            hasWarnings: ctx.bind(ctxRef, hasWarnings),
-            hasWarningsByGroup: ctx.bind(ctxRef, hasWarningsByGroup),
-            isValid: ctx.bind(ctxRef, function (fieldName) {
+            getErrors: context.bind(ctxRef, getErrors),
+            getErrorsByGroup: context.bind(ctxRef, getErrorsByGroup),
+            getWarnings: context.bind(ctxRef, getWarnings),
+            getWarningsByGroup: context.bind(ctxRef, getWarningsByGroup),
+            hasErrors: context.bind(ctxRef, hasErrors),
+            hasErrorsByGroup: context.bind(ctxRef, hasErrorsByGroup),
+            hasWarnings: context.bind(ctxRef, hasWarnings),
+            hasWarningsByGroup: context.bind(ctxRef, hasWarningsByGroup),
+            isValid: context.bind(ctxRef, function (fieldName) {
                 return isValid(produceDraft(), fieldName);
-            })
+            }),
+            suiteName: suiteName
         });
     }));
 }
@@ -1466,9 +968,9 @@ var cache = createCache(20);
 function produceFullResult() {
     var testObjects = useTestsFlat();
     var ctxRef = { stateRef: useStateRef() };
-    return cache([testObjects], ctx.bind(ctxRef, function () {
+    return cache([testObjects], context.bind(ctxRef, function () {
         return assign({}, produceDraft(), {
-            done: ctx.bind(ctxRef, done)
+            done: context.bind(ctxRef, done)
         });
     }));
 }
@@ -1479,7 +981,7 @@ function shouldSkipDoneRegistration(callback, fieldName, output) {
     // If we do not have any test runs for the current field
     return !!(!isFunction(callback) ||
         (fieldName &&
-            (!output.tests[fieldName] || output.tests[fieldName].testCount === 0)));
+            (!output.tests[fieldName] || isEmpty(output.tests[fieldName].testCount))));
 }
 function shouldRunDoneCallback(fieldName) {
     // is suite finished || field name exists, and test is finished;
@@ -1509,25 +1011,16 @@ var done = function done() {
     return output;
 };
 function deferDoneCallback(doneCallback, fieldName) {
-    var deferredCallback = ctx.bind({}, doneCallback);
+    var deferredCallback = context.bind({}, doneCallback);
     var _a = useTestCallbacks(), setTestCallbacks = _a[1];
     setTestCallbacks(function (current) {
-        if (fieldName) {
-            current.fieldCallbacks[fieldName] = (current.fieldCallbacks[fieldName] || []).concat(deferredCallback);
-        }
-        else {
-            current.doneCallbacks.push(deferredCallback);
-        }
-        return current;
-    });
-}
-
-/**
- * Removes test object from suite state
- */
-function removeTestFromState (testObject) {
-    useSetTests(function (tests) {
-        return transform(tests, function (test) { return (testObject !== test ? test : null); });
+        if (fieldName) {
+            current.fieldCallbacks[fieldName] = (current.fieldCallbacks[fieldName] || []).concat(deferredCallback);
+        }
+        else {
+            current.doneCallbacks.push(deferredCallback);
+        }
+        return current;
     });
 }
 
@@ -1556,6 +1049,44 @@ function createBus() {
     };
 }
 
+function omitOptionalTests() {
+    var optionalFields = useOptionalFields()[0];
+    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();
+        }
+    }
+}
+
+/**
+ * Removes test object from suite state
+ */
+function removeTestFromState (testObject) {
+    useSetTests(function (tests) {
+        return transform(tests, function (test) { return (testObject !== test ? test : null); });
+    });
+}
+
 function callEach(arr) {
     return arr.forEach(function (fn) { return fn(); });
 }
@@ -1583,6 +1114,8 @@ function runDoneCallbacks() {
 
 function initBus() {
     var bus = createBus();
+    // Report a the completion of a test. There may be other tests with the same
+    // name that are still running, or not yet started.
     bus.on(Events.TEST_COMPLETED, function (testObject) {
         if (testObject.isCanceled()) {
             return;
@@ -1591,58 +1124,96 @@ function initBus() {
         runFieldCallbacks(testObject.fieldName);
         runDoneCallbacks();
     });
+    // Report that the suite completed its synchronous test run.
+    // Async operations may still be running.
+    bus.on(Events.SUITE_COMPLETED, function () {
+        // Remove tests that are optional and need to be omitted
+        omitOptionalTests();
+    });
+    // Removes a certain field from the state.
+    bus.on(Events.REMOVE_FIELD, function (fieldName) {
+        var testObjects = useTestsFlat();
+        testObjects.forEach(function (testObject) {
+            if (matchingFieldName(testObject, fieldName)) {
+                testObject.cancel();
+                removeTestFromState(testObject);
+            }
+        });
+    });
     return bus;
 }
 function useBus() {
-    var context = ctx.useX();
-    if (!context.bus) {
+    var context$1 = context.useX();
+    if (!context$1.bus) {
         throwError();
     }
-    return context.bus;
+    return context$1.bus;
 }
 var Events;
 (function (Events) {
     Events["TEST_COMPLETED"] = "test_completed";
+    Events["REMOVE_FIELD"] = "remove_field";
+    Events["SUITE_COMPLETED"] = "suite_completed";
 })(Events || (Events = {}));
 
 // eslint-disable-next-line max-lines-per-function
-function create(suiteCallback) {
+function create() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    var _a = args.reverse(), suiteCallback = _a[0], suiteName = _a[1];
     if (!isFunction(suiteCallback)) {
-        throwError('Suite initialization error. Expected `tests` to be a function.');
+        throwError('vest.create: Expected callback to be a function.');
     }
+    // Event bus initialization
     var bus = initBus();
+    // State initialization
     var state = createState();
-    var stateRef = createStateRef(state, { suiteId: genId() });
-    var suite = assign(ctx.bind({ stateRef: stateRef, bus: bus }, function () {
+    // State reference - this holds the actual state values
+    var stateRef = createStateRef(state, { suiteId: genId(), suiteName: suiteName });
+    // Create base context reference. All hooks will derive their data from this
+    var ctxRef = { stateRef: stateRef, bus: bus };
+    var suite = assign(
+    // Bind the suite body to the context
+    context.bind(ctxRef, function () {
         var args = [];
         for (var _i = 0; _i < arguments.length; _i++) {
             args[_i] = arguments[_i];
         }
+        // Reset the state. Migrates current test objects to `prev` array.
         state.reset();
-        // Run the consumer's callback
+        // Create a top level isolate
         isolate({ type: IsolateTypes.SUITE }, function () {
+            // Run the consumer's callback
             suiteCallback.apply(void 0, args);
         });
-        omitOptionalTests();
-        var res = produceFullResult();
-        return res;
+        // Report the suite is done registering tests
+        // Async tests may still be running
+        bus.emit(Events.SUITE_COMPLETED);
+        // Return the result
+        return produceFullResult();
     }), {
-        get: ctx.bind({ stateRef: stateRef }, produceDraft),
-        remove: ctx.bind({ stateRef: stateRef }, function (name) {
-            var testObjects = useTestsFlat();
-            // We're mutating the array in `cancel`, so we have to first copy it.
-            testObjects.forEach(function (testObject) {
-                if (matchingFieldName(testObject, name)) {
-                    testObject.cancel();
-                    removeTestFromState(testObject);
-                }
-            });
-        }),
-        reset: state.reset
+        get: context.bind(ctxRef, produceDraft),
+        reset: state.reset,
+        remove: context.bind(ctxRef, function (fieldName) {
+            bus.emit(Events.REMOVE_FIELD, fieldName);
+        })
     });
     return suite;
 }
 
+function each(list, callback) {
+    if (!isFunction(callback)) {
+        throwError('callback must be a function');
+    }
+    isolate({ type: IsolateTypes.EACH }, function () {
+        list.forEach(function (arg, index) {
+            callback(arg, index);
+        });
+    });
+}
+
 /**
  * Error message to display when a hook was called outside of context.
  */
@@ -1652,24 +1223,31 @@ var ERROR_HOOK_CALLED_OUTSIDE = 'hook called outside of a running suite.';
  * Adds a field or multiple fields to inclusion group.
  */
 function only(item) {
-    return addTo('only', 'tests', item);
+    return addTo(0 /* ONLY */, 'tests', item);
 }
-only.group = function (item) { return addTo('only', 'groups', item); };
+only.group = function (item) {
+    return addTo(0 /* ONLY */, 'groups', item);
+};
 /**
  * Adds a field or multiple fields to exclusion group.
  */
 function skip(item) {
-    return addTo('skip', 'tests', item);
+    return addTo(1 /* SKIP */, 'tests', item);
+}
+skip.group = function (item) {
+    return addTo(1 /* SKIP */, 'groups', item);
+};
+function isExcludedIndividually() {
+    return !!context.useX().skipped;
 }
-skip.group = function (item) { return addTo('skip', 'groups', item); };
 //Checks whether a certain test profile excluded by any of the exclusion groups.
 // eslint-disable-next-line complexity, max-statements
 function isExcluded(testObject) {
     var fieldName = testObject.fieldName, groupName = testObject.groupName;
-    var context = ctx.useX();
-    if (context.skipped)
+    if (isExcludedIndividually())
         return true;
-    var exclusion = context.exclusion;
+    var context$1 = context.useX();
+    var exclusion = context$1.exclusion;
     var keyTests = exclusion.tests;
     var testValue = keyTests[fieldName];
     // if test is skipped
@@ -1692,6 +1270,9 @@ function isExcluded(testObject) {
             return keyTests[fieldName] === false;
         }
     }
+    if (isMissingFromIncludedGroup(groupName)) {
+        return true;
+    }
     // if field is only'ed
     if (isTestIncluded)
         return false;
@@ -1699,12 +1280,40 @@ function isExcluded(testObject) {
     // Otherwise return false
     return hasIncludedTests(keyTests);
 }
+// eslint-disable-next-line max-statements
+function isMissingFromIncludedGroup(groupName) {
+    var context$1 = context.useX();
+    var exclusion = context$1.exclusion;
+    if (!hasIncludedGroups()) {
+        return false;
+    }
+    if (!groupName) {
+        return true;
+    }
+    if (groupName in exclusion.groups) {
+        if (exclusion.groups[groupName]) {
+            return false;
+        }
+        return true;
+    }
+    return true;
+}
+function hasIncludedGroups() {
+    var context$1 = context.useX();
+    var exclusion = context$1.exclusion;
+    for (var group in exclusion.groups) {
+        if (exclusion.groups[group]) {
+            return true;
+        }
+    }
+    return false;
+}
 /**
  * Checks whether a given group is excluded from running.
  */
 function isGroupExcluded(groupName) {
-    var context = ctx.useX();
-    var exclusion = context.exclusion;
+    var context$1 = context.useX();
+    var exclusion = context$1.exclusion;
     var keyGroups = exclusion.groups;
     var groupPresent = hasOwnProperty(keyGroups, groupName);
     // When group is either only'ed or skipped
@@ -1725,7 +1334,7 @@ function isGroupExcluded(groupName) {
  * Adds fields to a specified exclusion group.
  */
 function addTo(exclusionGroup, itemType, item) {
-    var context = ctx.useX(ERROR_HOOK_CALLED_OUTSIDE);
+    var context$1 = context.useX(ERROR_HOOK_CALLED_OUTSIDE);
     if (!item) {
         return;
     }
@@ -1733,7 +1342,8 @@ function addTo(exclusionGroup, itemType, item) {
         if (!isStringValue(itemName)) {
             return;
         }
-        context.exclusion[itemType][itemName] = exclusionGroup === 'only';
+        context$1.exclusion[itemType][itemName] =
+            exclusionGroup === 0 /* ONLY */;
     });
 }
 /**
@@ -1748,25 +1358,6 @@ 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."
-    ;
-/**
- * Sets a running test to warn only mode.
- */
-function warn() {
-    var ctx$1 = ctx.useX('warn ' + ERROR_HOOK_CALLED_OUTSIDE);
-    if (!ctx$1.currentTest) {
-        throwError(ERROR_OUTSIDE_OF_TEST);
-    }
-    ctx$1.currentTest.warn();
-}
-
 /**
  * Runs a group callback.
  */
@@ -1779,7 +1370,7 @@ function group(groupName, tests) {
     }
     // Running with the context applied
     isolate({ type: IsolateTypes.GROUP }, function () {
-        ctx.run({ groupName: groupName }, tests);
+        context.run({ groupName: groupName }, tests);
     });
 }
 function throwGroupError(error) {
@@ -1805,125 +1396,15 @@ function optional(optionals) {
     });
 }
 
-function shouldUseErrorAsMessage(message, error) {
-    // kind of cheating with this safe guard, but it does the job
-    return isUndefined(message) && isStringValue(error);
+function skipWhen(conditional, callback) {
+    isolate({ type: IsolateTypes.SKIP_WHEN }, function () {
+        context.run({
+            skipped: optionalFunctionValue(conditional, optionalFunctionValue(produceDraft))
+        }, function () { return callback(); });
+    });
 }
 
-var VestTest = /** @class */ (function () {
-    function VestTest(fieldName, testFn, _a) {
-        var _b = _a === void 0 ? {} : _a, message = _b.message, groupName = _b.groupName;
-        this.id = genId();
-        this.warns = false;
-        this.status = STATUS_UNTESTED;
-        this.fieldName = fieldName;
-        this.testFn = testFn;
-        if (groupName) {
-            this.groupName = groupName;
-        }
-        if (message) {
-            this.message = message;
-        }
-    }
-    VestTest.prototype.run = function () {
-        var result;
-        try {
-            result = this.testFn();
-        }
-        catch (error) {
-            if (shouldUseErrorAsMessage(this.message, error)) {
-                this.message = error;
-            }
-            result = false;
-        }
-        if (result === false) {
-            this.fail();
-        }
-        return result;
-    };
-    VestTest.prototype.setStatus = function (status) {
-        if (this.isFinalStatus() && status !== STATUS_OMITTED) {
-            return;
-        }
-        this.status = status;
-    };
-    VestTest.prototype.setPending = function () {
-        this.setStatus(STATUS_PENDING);
-    };
-    VestTest.prototype.fail = function () {
-        this.setStatus(this.warns ? STATUS_WARNING : STATUS_FAILED);
-    };
-    VestTest.prototype.done = function () {
-        if (this.isFinalStatus()) {
-            return;
-        }
-        this.setStatus(STATUS_PASSING);
-    };
-    VestTest.prototype.warn = function () {
-        this.warns = true;
-    };
-    VestTest.prototype.isFinalStatus = function () {
-        return this.hasFailures() || this.isCanceled() || this.isPassing();
-    };
-    VestTest.prototype.skip = function () {
-        if (this.isPending()) {
-            // Without this condition, the test will be marked as skipped even if it is pending.
-            // This means that it will not be counted in "allIncomplete" and its done callbacks
-            // will not be called, or will be called prematurely.
-            return;
-        }
-        this.setStatus(STATUS_SKIPPED);
-    };
-    VestTest.prototype.cancel = function () {
-        this.setStatus(STATUS_CANCELED);
-        useRefreshTestObjects();
-    };
-    VestTest.prototype.omit = function () {
-        this.setStatus(STATUS_OMITTED);
-    };
-    VestTest.prototype.valueOf = function () {
-        return !this.isFailing();
-    };
-    VestTest.prototype.hasFailures = function () {
-        return this.isFailing() || this.isWarning();
-    };
-    VestTest.prototype.isPending = function () {
-        return this.status === STATUS_PENDING;
-    };
-    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;
-    };
-    VestTest.prototype.isFailing = function () {
-        return this.status === STATUS_FAILED;
-    };
-    VestTest.prototype.isCanceled = function () {
-        return this.status === STATUS_CANCELED;
-    };
-    VestTest.prototype.isSkipped = function () {
-        return this.status === STATUS_SKIPPED;
-    };
-    VestTest.prototype.isPassing = function () {
-        return this.status === STATUS_PASSING;
-    };
-    VestTest.prototype.isWarning = function () {
-        return this.status === STATUS_WARNING;
-    };
-    return VestTest;
-}());
-var STATUS_UNTESTED = 'UNTESTED';
-var STATUS_SKIPPED = 'SKIPPED';
-var STATUS_FAILED = 'FAILED';
-var STATUS_WARNING = 'WARNING';
-var STATUS_PASSING = 'PASSING';
-var STATUS_PENDING = 'PENDING';
-var STATUS_CANCELED = 'CANCELED';
-var STATUS_OMITTED = 'OMITTED';
+var isNotString = bindNot(isStringValue);
 
 function isPromise(value) {
     return value && isFunction(value.then);
@@ -1951,12 +1432,12 @@ function runAsyncTest(testObject) {
         return;
     var emit = useBus().emit;
     var stateRef = useStateRef();
-    var done = ctx.bind({ stateRef: stateRef }, function () {
+    var done = context.bind({ stateRef: stateRef }, function () {
         // invalidating the "produce" cache
         useRefreshTestObjects();
         emit(Events.TEST_COMPLETED, testObject);
     });
-    var fail = ctx.bind({ stateRef: stateRef }, function (rejectionMessage) {
+    var fail = context.bind({ stateRef: stateRef }, function (rejectionMessage) {
         if (testObject.isCanceled()) {
             return;
         }
@@ -1978,7 +1459,7 @@ function runAsyncTest(testObject) {
  * Runs sync tests - or extracts promise.
  */
 function runSyncTest(testObject) {
-    return ctx.run({ currentTest: testObject }, function () {
+    return context.run({ currentTest: testObject }, function () {
         var result;
         try {
             result = testObject.testFn();
@@ -2000,7 +1481,7 @@ function runSyncTest(testObject) {
  * Registers test, if async - adds to pending array
  */
 function registerTest(testObject) {
-    var emit = useBus().emit;
+    var bus = useBus();
     // Run test callback.
     // If a promise is returned, set as async and
     // Move to pending list.
@@ -2014,11 +1495,11 @@ function registerTest(testObject) {
             runAsyncTest(testObject);
         }
         else {
-            emit(Events.TEST_COMPLETED, testObject);
+            bus.emit(Events.TEST_COMPLETED, testObject);
         }
     }
     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.");
+        throwError("Your test function " + testObject.fieldName + " returned a value. Only \"false\" or Promise returns are supported.");
     }
 }
 
@@ -2033,33 +1514,21 @@ function registerTest(testObject) {
  */
 // eslint-disable-next-line max-statements, max-lines-per-function
 function useTestAtCursor(newTestObject) {
-    var _a = useTestObjects(), testObjects = _a[0], setTestObjects = _a[1];
+    var testObjects = useTestObjects()[0];
     var prevTests = testObjects.prev;
     if (isEmpty(prevTests)) {
         useSetTestAtCursor(newTestObject);
         return newTestObject;
     }
     var prevTest = useGetTestAtCursor(prevTests);
+    if (!isNullish(newTestObject.key)) {
+        var nextTest_1 = handleKeyTest(newTestObject.key, newTestObject);
+        useSetTestAtCursor(nextTest_1);
+        return nextTest_1;
+    }
     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
-            });
-        });
+        removeAllNextTestsInIsolate();
         // Need to see if this has any effect at all.
         prevTest = null;
     }
@@ -2067,6 +1536,23 @@ function useTestAtCursor(newTestObject) {
     useSetTestAtCursor(nextTest);
     return nextTest;
 }
+function removeAllNextTestsInIsolate() {
+    var _a = useTestObjects(), testObjects = _a[0], setTestObjects = _a[1];
+    var prevTests = testObjects.prev;
+    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
+        });
+    });
+}
 function useSetTestAtCursor(testObject) {
     var cursorPath = usePath();
     useSetTests(function (tests) {
@@ -2084,13 +1570,26 @@ 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.");
+    throwErrorDeferred("Vest Critical Error: Tests called in different order than previous run.\n    expected: " + prevTest.fieldName + "\n    received: " + 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);
+    var nextTest = newTestObject;
+    if (prevTestByKey) {
+        nextTest = prevTestByKey;
+    }
+    useRetainTestKey(key, nextTest);
+    return nextTest;
 }
 
 function registerPrevRunTest(testObject) {
     var prevRunTest = useTestAtCursor(testObject);
     if (isExcluded(testObject)) {
-        testObject.skip();
+        // We're forcing skipping the pending test
+        // if we're directly within a skipWhen block
+        // This mostly means that we're probably giving
+        // up on this async test intentionally.
+        prevRunTest.skip(isExcludedIndividually());
         moveForward();
         return prevRunTest;
     }
@@ -2110,33 +1609,6 @@ function registerTestObjectByTier(testObject) {
     }
 }
 
-function bindTestEach(test) {
-    /**
-     * Run multiple tests using a parameter table
-     */
-    function each(table) {
-        if (!isArray(table)) {
-            throwError('test.each: Expected table to be an array.');
-        }
-        function eachReturn(fieldName) {
-            var args = [];
-            for (var _i = 1; _i < arguments.length; _i++) {
-                args[_i - 1] = arguments[_i];
-            }
-            var _a = args.reverse(), testFn = _a[0], message = _a[1];
-            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;
-    }
-    return each;
-}
-
 // eslint-disable-next-line max-lines-per-function
 function bindTestMemo(test) {
     var cache = createCache(100); // arbitrary cache size
@@ -2146,11 +1618,10 @@ function bindTestMemo(test) {
         for (var _i = 1; _i < arguments.length; _i++) {
             args[_i - 1] = arguments[_i];
         }
-        var suiteId = useSuiteId()[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);
+        var dependencies = [useSuiteId(), fieldName, cursorAt].concat(deps);
         var cached = cache.get(dependencies);
         if (isNull(cached)) {
             // cache miss
@@ -2171,24 +1642,52 @@ function testBase(fieldName) {
     for (var _i = 1; _i < arguments.length; _i++) {
         args[_i - 1] = arguments[_i];
     }
-    var _a = args.reverse(), testFn = _a[0], message = _a[1];
-    var context = ctx.useX();
+    var _a = (isFunction(args[1]) ? args : __spreadArray([undefined], args)), message = _a[0], testFn = _a[1], key = _a[2];
+    if (isNotString(fieldName)) {
+        throwIncompatibleParamsError('fieldName', 'string');
+    }
+    if (!isFunction(testFn)) {
+        throwIncompatibleParamsError('Test callback', 'function');
+    }
+    var context$1 = context.useX();
     var testObject = new VestTest(fieldName, testFn, {
         message: message,
-        groupName: context === null || context === void 0 ? void 0 : context.groupName
+        groupName: context$1.groupName,
+        key: key
     });
     return registerPrevRunTest(testObject);
 }
 var test = assign(testBase, {
-    each: bindTestEach(testBase),
     memo: bindTestMemo(testBase)
 });
+function throwIncompatibleParamsError(name, expected) {
+    throwError("Incompatible params passed to test function. " + name + " must be a " + expected);
+}
+
+var ERROR_OUTSIDE_OF_TEST = "warn hook called outside of a test callback. It won't have an effect."
+    ;
+/**
+ * Sets a running test to warn only mode.
+ */
+function warn() {
+    var ctx = context.useX('warn ' + ERROR_HOOK_CALLED_OUTSIDE);
+    if (!ctx.currentTest) {
+        throwError(ERROR_OUTSIDE_OF_TEST);
+    }
+    ctx.currentTest.warn();
+}
 
-var VERSION = "4.0.0-dev-7acb76";
+var VERSION = "4.0.0-dev-1aae50";
 
+Object.defineProperty(exports, 'enforce', {
+  enumerable: true,
+  get: function () {
+    return n4s.enforce;
+  }
+});
 exports.VERSION = VERSION;
 exports.create = create;
-exports.enforce = enforce;
+exports.each = each;
 exports.group = group;
 exports.only = only;
 exports.optional = optional;