vest 4.4.0 → 4.4.2-dev-d13b14

package/dist/umd/vest.development.js

@@ -4,12 +4,6 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.vest = {}));
 }(this, (function (exports) { 'use strict';
 
-  var assign = Object.assign;
-
-  function isFunction(value) {
-      return typeof value === 'function';
-  }
-
   function bindNot(fn) {
       return function () {
           var args = [];
@@ -20,6 +14,69 @@
       };
   }
 
+  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 numberEquals(value, eq) {
+      return isNumeric(value) && isNumeric(eq) && Number(value) === Number(eq);
+  }
+  var numberNotEquals = bindNot(numberEquals);
+
+  function lengthEquals(value, arg1) {
+      return numberEquals(value.length, arg1);
+  }
+  var lengthNotEquals = bindNot(lengthEquals);
+
+  function greaterThan(value, gt) {
+      return isNumeric(value) && isNumeric(gt) && Number(value) > Number(gt);
+  }
+
+  function longerThan(value, arg1) {
+      return greaterThan(value.length, arg1);
+  }
+
+  /**
+   * Creates a cache function
+   */
+  function createCache(maxSize) {
+      if (maxSize === void 0) { maxSize = 1; }
+      var cacheStorage = [];
+      var cache = function (deps, cacheAction) {
+          var cacheHit = cache.get(deps);
+          // cache hit is not null
+          if (cacheHit)
+              return cacheHit[1];
+          var result = cacheAction();
+          cacheStorage.unshift([deps.concat(), result]);
+          if (longerThan(cacheStorage, maxSize))
+              cacheStorage.length = maxSize;
+          return result;
+      };
+      // invalidate an item in the cache by its dependencies
+      cache.invalidate = function (deps) {
+          var index = findIndex(deps);
+          if (index > -1)
+              cacheStorage.splice(index, 1);
+      };
+      // Retrieves an item from the cache.
+      cache.get = function (deps) {
+          return cacheStorage[findIndex(deps)] || null;
+      };
+      return cache;
+      function findIndex(deps) {
+          return cacheStorage.findIndex(function (_a) {
+              var cachedDeps = _a[0];
+              return lengthEquals(deps, cachedDeps.length) &&
+                  deps.every(function (dep, i) { return dep === cachedDeps[i]; });
+          });
+      }
+  }
+
   function isNull(value) {
       return value === null;
   }
@@ -35,39 +92,25 @@
   }
   var isNotNullish = bindNot(isNullish);
 
-  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);
+  function asArray(possibleArg) {
+      return [].concat(possibleArg);
   }
-  var isNotNumeric = bindNot(isNumeric);
 
-  function greaterThan(value, gt) {
-      return isNumeric(value) && isNumeric(gt) && Number(value) > Number(gt);
+  function isFunction(value) {
+      return typeof value === 'function';
   }
 
-  function numberEquals(value, eq) {
-      return isNumeric(value) && isNumeric(eq) && Number(value) === Number(eq);
+  function optionalFunctionValue(value) {
+      var args = [];
+      for (var _i = 1; _i < arguments.length; _i++) {
+          args[_i - 1] = arguments[_i];
+      }
+      return isFunction(value) ? value.apply(void 0, args) : value;
   }
-  var numberNotEquals = bindNot(numberEquals);
 
-  function greaterThanOrEquals(value, gte) {
-      return numberEquals(value, gte) || greaterThan(value, gte);
+  function defaultTo(value, defaultValue) {
+      var _a;
+      return (_a = optionalFunctionValue(value)) !== null && _a !== void 0 ? _a : optionalFunctionValue(defaultValue);
   }
 
   // The module is named "isArrayValue" since it
@@ -78,66 +121,159 @@
   }
   var isNotArray = bindNot(isArray);
 
-  function inside(value, arg1) {
-      if (isArray(arg1)) {
-          return arg1.indexOf(value) !== -1;
+  function last(values) {
+      var valuesArray = asArray(values);
+      return valuesArray[valuesArray.length - 1];
+  }
+
+  // This is kind of a map/filter in one function.
+  // Normally, behaves like a nested-array map,
+  // but returning `null` will drop the element from the array
+  function transform(array, cb) {
+      var res = [];
+      for (var _i = 0, array_1 = array; _i < array_1.length; _i++) {
+          var v = array_1[_i];
+          if (isArray(v)) {
+              res.push(transform(v, cb));
+          }
+          else {
+              var output = cb(v);
+              if (isNotNull(output)) {
+                  res.push(output);
+              }
+          }
       }
-      // both value and arg1 are strings
-      if (isStringValue(arg1) && isStringValue(value)) {
-          return arg1.indexOf(value) !== -1;
+      return res;
+  }
+  function valueAtPath(array, path) {
+      return getCurrent(array, path)[last(path)];
+  }
+  function setValueAtPath(array, path, value) {
+      var current = getCurrent(array, path);
+      current[last(path)] = value;
+      return array;
+  }
+  function flatten(values) {
+      return asArray(values).reduce(function (acc, value) {
+          if (isArray(value)) {
+              return acc.concat(flatten(value));
+          }
+          return asArray(acc).concat(value);
+      }, []);
+  }
+  function getCurrent(array, path) {
+      var current = array;
+      for (var _i = 0, _a = path.slice(0, -1); _i < _a.length; _i++) {
+          var p = _a[_i];
+          current[p] = defaultTo(current[p], []);
+          current = current[p];
       }
-      return false;
+      return current;
   }
-  var notInside = bindNot(inside);
 
-  function lessThan(value, lt) {
-      return isNumeric(value) && isNumeric(lt) && Number(value) < Number(lt);
+  function callEach(arr) {
+      return arr.forEach(function (fn) { return fn(); });
   }
 
-  function lessThanOrEquals(value, lte) {
-      return numberEquals(value, lte) || lessThan(value, lte);
+  /**
+   * A safe hasOwnProperty access
+   */
+  function hasOwnProperty(obj, key) {
+      return Object.prototype.hasOwnProperty.call(obj, key);
   }
 
-  function isBetween(value, min, max) {
-      return greaterThanOrEquals(value, min) && lessThanOrEquals(value, max);
+  function isPromise(value) {
+      return value && isFunction(value.then);
   }
-  var isNotBetween = bindNot(isBetween);
 
-  function isBlank(value) {
-      return isNullish(value) || (isStringValue(value) && !value.trim());
+  var assign = Object.assign;
+
+  function invariant(condition, 
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  message) {
+      if (condition) {
+          return;
+      }
+      // If message is a string object (rather than string literal)
+      // Throw the value directly as a string
+      // Alternatively, throw an error with the message
+      throw message instanceof String
+          ? message.valueOf()
+          : new Error(message ? optionalFunctionValue(message) : message);
+  }
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  function StringObject(value) {
+      return new String(optionalFunctionValue(value));
+  }
+
+  function isStringValue(v) {
+      return String(v) === v;
+  }
+
+  function either(a, b) {
+      return !!a !== !!b;
   }
-  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 deferThrow(message) {
+      setTimeout(function () {
+          throw new Error(message);
+      }, 0);
   }
 
-  function isNumber(value) {
-      return Boolean(typeof value === 'number');
+  function createBus() {
+      var listeners = {};
+      return {
+          emit: function (event, data) {
+              listener(event).forEach(function (handler) {
+                  handler(data);
+              });
+          },
+          on: function (event, handler) {
+              listeners[event] = listener(event).concat(handler);
+              return {
+                  off: function () {
+                      listeners[event] = listener(event).filter(function (h) { return h !== handler; });
+                  }
+              };
+          }
+      };
+      function listener(event) {
+          return listeners[event] || [];
+      }
   }
-  var isNotNumber = bindNot(isNumber);
 
-  function lengthEquals(value, arg1) {
-      return numberEquals(value.length, arg1);
+  /**
+   * @returns a unique numeric id.
+   */
+  var genId = (function (n) { return function () {
+      return "".concat(n++);
+  }; })(0);
+
+  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(conditional, value) {
+          if (conditional) {
+              broke = true;
+              breakoutValue = value;
+          }
+      }
   }
-  var lengthNotEquals = bindNot(lengthEquals);
 
   function isEmpty(value) {
       if (!value) {
           return true;
       }
-      else if (isNumber(value)) {
-          return value === 0;
-      }
       else if (hasOwnProperty(value, 'length')) {
           return lengthEquals(value, 0);
       }
@@ -148,6 +284,56 @@
   }
   var isNotEmpty = bindNot(isEmpty);
 
+  function isPositive(value) {
+      return greaterThan(value, 0);
+  }
+
+  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 greaterThanOrEquals(value, gte) {
+      return numberEquals(value, gte) || greaterThan(value, gte);
+  }
+
+  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 lessThan(value, lt) {
+      return isNumeric(value) && isNumeric(lt) && Number(value) < Number(lt);
+  }
+
+  function lessThanOrEquals(value, lte) {
+      return numberEquals(value, lte) || lessThan(value, lte);
+  }
+
+  function isBetween(value, min, max) {
+      return greaterThanOrEquals(value, min) && lessThanOrEquals(value, max);
+  }
+  var isNotBetween = bindNot(isBetween);
+
+  function isBlank(value) {
+      return isNullish(value) || (isStringValue(value) && !value.trim());
+  }
+  var isNotBlank = bindNot(isBlank);
+
+  var isNotBoolean = bindNot(isBoolean);
+
   /**
    * Validates that a given value is an even number
    */
@@ -172,6 +358,11 @@
       return lessThan(value, 0);
   }
 
+  function isNumber(value) {
+      return Boolean(typeof value === 'number');
+  }
+  var isNotNumber = bindNot(isNumber);
+
   /**
    * Validates that a given value is an odd number
    */
@@ -182,10 +373,6 @@
       return false;
   };
 
-  function isPositive(value) {
-      return greaterThan(value, 0);
-  }
-
   var isNotString = bindNot(isStringValue);
 
   function isTruthy(value) {
@@ -206,10 +393,6 @@
   }
   var isNotValueOf = bindNot(isValueOf);
 
-  function longerThan(value, arg1) {
-      return greaterThan(value.length, arg1);
-  }
-
   function longerThanOrEquals(value, arg1) {
       return greaterThanOrEquals(value.length, arg1);
   }
@@ -330,33 +513,6 @@
       }
   }
 
-  function optionalFunctionValue(value) {
-      var args = [];
-      for (var _i = 1; _i < arguments.length; _i++) {
-          args[_i - 1] = arguments[_i];
-      }
-      return isFunction(value) ? value.apply(void 0, args) : value;
-  }
-
-  function defaultTo(callback, defaultValue) {
-      var _a;
-      return (_a = optionalFunctionValue(callback)) !== null && _a !== void 0 ? _a : defaultValue;
-  }
-
-  function invariant(condition, 
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  message) {
-      if (condition) {
-          return;
-      }
-      // If message is a string object (rather than string literal)
-      // Throw the value directly as a string
-      // Alternatively, throw an error with the message
-      throw message instanceof String
-          ? message.valueOf()
-          : new Error(message ? optionalFunctionValue(message) : message);
-  }
-
   // eslint-disable-next-line max-lines-per-function
   function createContext(init) {
       var storage = { ancestry: [] };
@@ -367,8 +523,9 @@
           useX: useX
       };
       function useX(errorMessage) {
-          invariant(storage.ctx, defaultTo(errorMessage, 'Context was used after it was closed'));
-          return storage.ctx;
+          var ctx = use();
+          invariant(ctx, defaultTo(errorMessage, 'Context was used after it was closed'));
+          return ctx;
       }
       function run(ctxRef, fn) {
           var _a;
@@ -531,32 +688,17 @@
               for (var _i = 0; _i < arguments.length; _i++) {
                   args[_i] = arguments[_i];
               }
-              var transformedResult = transformResult.apply(void 0, __spreadArray([ctx.run({ value: value }, function () { return rule.apply(void 0, __spreadArray([value], args, false)); }),
-                  ruleName,
-                  value], args, false));
-              invariant(transformedResult.pass, isEmpty(transformedResult.message)
+              var transformedResult = ctx.run({ value: value }, function () {
+                  return transformResult.apply(void 0, __spreadArray([rule.apply(void 0, __spreadArray([value], args, false)), ruleName, value], args, false));
+              });
+              invariant(transformedResult.pass, isNullish(transformedResult.message)
                   ? "enforce/".concat(ruleName, " failed with ").concat(JSON.stringify(value))
-                  : new String(transformedResult.message));
+                  : StringObject(transformedResult.message));
               return target;
           };
       }
   }
 
-  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;
-      }
-  }
-
   // eslint-disable-next-line max-lines-per-function
   function genEnforceLazy(key) {
       var registeredRules = [];
@@ -579,9 +721,7 @@
                       return defaultToPassing(mapFirst(registeredRules, function (rule, breakout) {
                           var _a;
                           var res = ctx.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));
-                          }
+                          breakout(!res.pass, ruleReturn(!!res.pass, (_a = optionalFunctionValue(lazyMessage, value, res.message)) !== null && _a !== void 0 ? _a : res.message));
                       }));
                   },
                   test: function (value) { return proxy.run(value).pass; },
@@ -619,160 +759,62 @@
    *
    * 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 = {
-          context: function () { return ctx.useX(); },
-          extend: function (customRules) {
-              assign(baseRules, customRules);
-              handleNoProxy(); // TODO: REMOVE when we stop supporting ES5
-          }
-      };
-      handleNoProxy();
-      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);
-          }
-      });
-      function handleNoProxy() {
-          if (!isProxySupported()) {
-              eachEnforceRule(function (ruleName) {
-                  // Only on the first rule access - start the chain of calls
-                  target[ruleName] = genEnforceLazy(ruleName);
-              });
-              return assign(enforceEager, target);
-          }
-      }
-  }
-  var enforce = genEnforce();
-
-  /**
-   * @returns a unique numeric id.
-   */
-  var genId = (function (n) { return function () {
-      return "".concat(n++);
-  }; })(0);
-
-  function shouldUseErrorAsMessage(message, error) {
-      // kind of cheating with this safe guard, but it does the job
-      return isUndefined(message) && isStringValue(error);
-  }
-
-  function asArray(possibleArg) {
-      return [].concat(possibleArg);
-  }
-
-  /**
-   * Creates a cache function
-   */
-  function createCache(maxSize) {
-      if (maxSize === void 0) { maxSize = 1; }
-      var cacheStorage = [];
-      var cache = function (deps, cacheAction) {
-          var cacheHit = cache.get(deps);
-          // cache hit is not null
-          if (cacheHit)
-              return cacheHit[1];
-          var result = cacheAction();
-          cacheStorage.unshift([deps.concat(), result]);
-          if (longerThan(cacheStorage, maxSize))
-              cacheStorage.length = maxSize;
-          return result;
-      };
-      // invalidate an item in the cache by its dependencies
-      cache.invalidate = function (deps) {
-          var index = findIndex(deps);
-          if (index > -1)
-              cacheStorage.splice(index, 1);
-      };
-      // Retrieves an item from the cache.
-      cache.get = function (deps) {
-          return cacheStorage[findIndex(deps)] || null;
-      };
-      return cache;
-      function findIndex(deps) {
-          return cacheStorage.findIndex(function (_a) {
-              var cachedDeps = _a[0];
-              return lengthEquals(deps, cachedDeps.length) &&
-                  deps.every(function (dep, i) { return dep === cachedDeps[i]; });
-          });
-      }
-  }
-
-  function last(values) {
-      var valuesArray = asArray(values);
-      return valuesArray[valuesArray.length - 1];
-  }
-
-  // This is kind of a map/filter in one function.
-  // Normally, behaves like a nested-array map,
-  // but returning `null` will drop the element from the array
-  function transform(array, cb) {
-      var res = [];
-      for (var _i = 0, array_1 = array; _i < array_1.length; _i++) {
-          var v = array_1[_i];
-          if (isArray(v)) {
-              res.push(transform(v, cb));
+   * 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 = {
+          context: function () { return ctx.useX(); },
+          extend: function (customRules) {
+              assign(baseRules, customRules);
+              handleNoProxy(); // TODO: REMOVE when we stop supporting ES5
           }
-          else {
-              var output = cb(v);
-              if (isNotNull(output)) {
-                  res.push(output);
+      };
+      handleNoProxy();
+      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);
           }
-      }
-      return res;
-  }
-  function valueAtPath(array, path) {
-      return getCurrent(array, path)[last(path)];
-  }
-  function setValueAtPath(array, path, value) {
-      var current = getCurrent(array, path);
-      current[last(path)] = value;
-      return array;
-  }
-  function flatten(values) {
-      return asArray(values).reduce(function (acc, value) {
-          if (isArray(value)) {
-              return acc.concat(flatten(value));
+      });
+      function handleNoProxy() {
+          if (!isProxySupported()) {
+              eachEnforceRule(function (ruleName) {
+                  // Only on the first rule access - start the chain of calls
+                  target[ruleName] = genEnforceLazy(ruleName);
+              });
+              return assign(enforceEager, target);
           }
-          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;
+  }
+  var enforce = genEnforce();
+
+  function shouldUseErrorAsMessage(message, error) {
+      // kind of cheating with this safe guard, but it does the job
+      return isUndefined(message) && isStringValue(error);
   }
 
   var IsolateTypes;
@@ -813,80 +855,6 @@
       }
   }
 
-  function deferThrow(message) {
-      setTimeout(function () {
-          throw new Error(message);
-      }, 0);
-  }
-
-  function usePrevKeys() {
-      var prev = useTestObjects()[0].prev;
-      return asArray(getCurrent(prev, useCurrentPath())).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 {
-          deferThrow("Encountered the same test key \"".concat(key, "\" twice. This may lead to tests overriding each other's results, or to tests being unexpectedly omitted."));
-      }
-  }
-
-  function isolate(_a, callback) {
-      var _b = _a.type, type = _b === void 0 ? IsolateTypes.DEFAULT : _b;
-      invariant(isFunction(callback));
-      // Generate a new Isolate layer, with its own cursor
-      var isolate = generateIsolate(type, useCurrentPath());
-      var output = context.run({ isolate: isolate }, function () {
-          isolate.keys.prev = usePrevKeys();
-          useSetTests(function (tests) { return setValueAtPath(tests, isolate.path, []); });
-          var res = callback();
-          return res;
-      });
-      // Move the parent cursor forward once we're done
-      useCursor().next();
-      return output;
-  }
-  /**
-   * @returns {Isolate} The current isolate layer
-   */
-  function useIsolate() {
-      return context.useX().isolate;
-  }
-  /**
-   * @returns {boolean} Whether or not the current isolate allows tests to be reordered
-   */
-  function shouldAllowReorder() {
-      return context.useX().isolate.type === IsolateTypes.EACH;
-  }
-  /**
-   * @returns {number[]} The current cursor path of the isolate tree
-   */
-  function useCurrentPath() {
-      var isolate = useIsolate();
-      return isolate.path.concat(isolate.cursor.current());
-  }
-  /**
-   * @returns {IsolateCursor} The cursor object for the current isolate
-   */
-  function useCursor() {
-      return useIsolate().cursor;
-  }
   function generateIsolate(type, path) {
       if (path === void 0) { path = []; }
       return {
@@ -1212,6 +1180,74 @@
       };
   }
 
+  function usePrevKeys() {
+      var prev = useTestObjects()[0].prev;
+      return asArray(getCurrent(prev, useCurrentPath())).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 = useIsolate().keys.prev;
+      return prev[key];
+  }
+  function useRetainTestKey(key, testObject) {
+      var current = useIsolate().keys.current;
+      if (isNullish(current[key])) {
+          current[key] = testObject;
+      }
+      else {
+          deferThrow("Encountered the same test key \"".concat(key, "\" twice. This may lead to tests overriding each other's results, or to tests being unexpectedly omitted."));
+      }
+  }
+
+  function isolate(_a, callback) {
+      var _b = _a.type, type = _b === void 0 ? IsolateTypes.DEFAULT : _b;
+      invariant(isFunction(callback));
+      // Generate a new Isolate layer, with its own cursor
+      var isolate = generateIsolate(type, useCurrentPath());
+      var output = context.run({ isolate: isolate }, function () {
+          isolate.keys.prev = usePrevKeys();
+          useSetTests(function (tests) { return setValueAtPath(tests, isolate.path, []); });
+          var res = callback();
+          return res;
+      });
+      // Move the parent cursor forward once we're done
+      useCursor().next();
+      return output;
+  }
+  /**
+   * @returns {Isolate} The current isolate layer
+   */
+  function useIsolate() {
+      return context.useX().isolate;
+  }
+  /**
+   * @returns {boolean} Whether or not the current isolate allows tests to be reordered
+   */
+  function shouldAllowReorder() {
+      return useIsolate().type === IsolateTypes.EACH;
+  }
+  /**
+   * @returns {number[]} The current cursor path of the isolate tree
+   */
+  function useCurrentPath() {
+      var isolate = useIsolate();
+      return isolate.path.concat(isolate.cursor.current());
+  }
+  /**
+   * @returns {IsolateCursor} The cursor object for the current isolate
+   */
+  function useCursor() {
+      return useIsolate().cursor;
+  }
+
   var Severity;
   (function (Severity) {
       Severity["WARNINGS"] = "warnings";
@@ -1240,10 +1276,6 @@
       return testObject.groupName === groupName;
   }
 
-  function either(a, b) {
-      return !!a !== !!b;
-  }
-
   /**
    * Checks that a given test object matches the currently specified severity level
    */
@@ -1682,28 +1714,6 @@
       });
   }
 
-  function createBus() {
-      var listeners = {};
-      return {
-          emit: function (event, data) {
-              listener(event).forEach(function (handler) {
-                  handler(data);
-              });
-          },
-          on: function (event, handler) {
-              listeners[event] = listener(event).concat(handler);
-              return {
-                  off: function () {
-                      listeners[event] = listener(event).filter(function (h) { return h !== handler; });
-                  }
-              };
-          }
-      };
-      function listener(event) {
-          return listeners[event] || [];
-      }
-  }
-
   function omitOptionalFields() {
       var optionalFields = useOptionalFields()[0];
       if (isEmpty(optionalFields)) {
@@ -1746,10 +1756,6 @@
       });
   }
 
-  function callEach(arr) {
-      return arr.forEach(function (fn) { return fn(); });
-  }
-
   /**
    * Runs done callback per field when async tests are finished running.
    */
@@ -1771,10 +1777,10 @@
 
   // eslint-disable-next-line max-lines-per-function
   function initBus() {
-      var bus = createBus();
+      var vestBus = 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) {
+      vestBus.on(Events.TEST_COMPLETED, function (testObject) {
           if (testObject.isCanceled()) {
               return;
           }
@@ -1782,21 +1788,21 @@
           runFieldCallbacks(testObject.fieldName);
           if (!hasRemainingTests()) {
               // When no more tests are running, emit the done event
-              bus.emit(Events.ALL_RUNNING_TESTS_FINISHED);
+              vestBus.emit(Events.ALL_RUNNING_TESTS_FINISHED);
           }
       });
       // Report that the suite completed its synchronous test run.
       // Async operations may still be running.
-      bus.on(Events.SUITE_CALLBACK_DONE_RUNNING, function () {
+      vestBus.on(Events.SUITE_CALLBACK_DONE_RUNNING, function () {
           // Remove tests that are optional and need to be omitted
           omitOptionalFields();
       });
       // Called when all the tests, including async, are done running
-      bus.on(Events.ALL_RUNNING_TESTS_FINISHED, function () {
+      vestBus.on(Events.ALL_RUNNING_TESTS_FINISHED, function () {
           runDoneCallbacks();
       });
       // Removes a certain field from the state.
-      bus.on(Events.REMOVE_FIELD, function (fieldName) {
+      vestBus.on(Events.REMOVE_FIELD, function (fieldName) {
           useEachTestObject(function (testObject) {
               if (matchingFieldName(testObject, fieldName)) {
                   testObject.cancel();
@@ -1805,14 +1811,14 @@
           });
       });
       // Resets a certain field in the state.
-      bus.on(Events.RESET_FIELD, function (fieldName) {
+      vestBus.on(Events.RESET_FIELD, function (fieldName) {
           useEachTestObject(function (testObject) {
               if (matchingFieldName(testObject, fieldName)) {
                   testObject.reset();
               }
           });
       });
-      return bus;
+      return vestBus;
   }
   function useBus() {
       var context$1 = context.useX();
@@ -2133,9 +2139,7 @@
       setMode(Modes.EAGER);
   }
   function shouldSkipBasedOnMode(testObject) {
-      if (isEager() && hasErrorsByTestObjects(testObject.fieldName))
-          return true;
-      return false;
+      return isEager() && hasErrorsByTestObjects(testObject.fieldName);
   }
   function isEager() {
       return isMode(Modes.EAGER);
@@ -2199,10 +2203,6 @@
       }
   }
 
-  function isPromise(value) {
-      return value && isFunction(value.then);
-  }
-
   function isSameProfileTest(testObject1, testObject2) {
       return (testObject1.fieldName === testObject2.fieldName &&
           testObject1.groupName === testObject2.groupName);
@@ -2317,20 +2317,13 @@
       return nextTest;
   }
   function removeAllNextTestsInIsolate() {
-      var _a = useTestObjects(), testObjects = _a[0], setTestObjects = _a[1];
-      var prevTests = testObjects.prev;
-      var current = getCurrent(prevTests, useCurrentPath());
       var cursorAt = useCursor().current();
-      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
-          });
+      useSetTests(function (current) {
+          current.splice(cursorAt);
+          return current;
       });
   }
   function useSetTestAtCursor(testObject) {
@@ -2474,7 +2467,7 @@
       ctx.currentTest.warn();
   }
 
-  var VERSION = "4.4.0";
+  var VERSION = "4.4.2-dev-d13b14";
 
   exports.VERSION = VERSION;
   exports.context = context;