vest 4.4.0-dev-08ec91 → 4.4.2-dev-afe5de

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;
@@ -438,7 +595,7 @@
       return null;
   }
 
-  /*! *****************************************************************************
+  /******************************************************************************
   Copyright (c) Microsoft Corporation.
 
   Permission to use, copy, modify, and/or distribute this software for any
@@ -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; },
@@ -672,143 +812,11 @@
   }
   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));
-          }
-          else {
-              var output = cb(v);
-              if (isNotNull(output)) {
-                  res.push(output);
-              }
-          }
-      }
-      return res;
-  }
-  function valueAtPath(array, path) {
-      return getCurrent(array, path)[last(path)];
-  }
-  function setValueAtPath(array, path, value) {
-      var current = getCurrent(array, path);
-      current[last(path)] = value;
-      return array;
-  }
-  function flatten(values) {
-      return asArray(values).reduce(function (acc, value) {
-          if (isArray(value)) {
-              return acc.concat(flatten(value));
-          }
-          return asArray(acc).concat(value);
-      }, []);
-  }
-  function getCurrent(array, path) {
-      var current = array;
-      for (var _i = 0, _a = path.slice(0, -1); _i < _a.length; _i++) {
-          var p = _a[_i];
-          current[p] = defaultTo(current[p], []);
-          current = current[p];
-      }
-      return current;
-  }
-
-  function createCursor() {
-      var storage = {
-          cursor: []
-      };
-      function addLevel() {
-          storage.cursor.push(0);
-      }
-      function removeLevel() {
-          storage.cursor.pop();
-      }
-      function cursorAt() {
-          return last(storage.cursor);
-      }
-      function getCursor() {
-          return asArray(storage.cursor);
-      }
-      function next() {
-          storage.cursor[storage.cursor.length - 1]++;
-          return last(storage.cursor);
-      }
-      function reset() {
-          storage.cursor = [0];
-      }
-      reset();
-      return {
-          addLevel: addLevel,
-          cursorAt: cursorAt,
-          getCursor: getCursor,
-          next: next,
-          removeLevel: removeLevel,
-          reset: reset
-      };
-  }
-
   var IsolateTypes;
   (function (IsolateTypes) {
       IsolateTypes[IsolateTypes["DEFAULT"] = 0] = "DEFAULT";
@@ -825,6 +833,41 @@
       Modes[Modes["EAGER"] = 1] = "EAGER";
   })(Modes || (Modes = {}));
 
+  function createIsolateCursor() {
+      var cursor = {
+          value: 0
+      };
+      return {
+          current: current,
+          next: next
+      };
+      /**
+       * @returns {number} The current value of the cursor
+       */
+      function current() {
+          return cursor.value;
+      }
+      /**
+       * Moves the isolate cursor forward by 1
+       */
+      function next() {
+          cursor.value++;
+      }
+  }
+
+  function generateIsolate(type, path) {
+      if (path === void 0) { path = []; }
+      return {
+          cursor: createIsolateCursor(),
+          keys: {
+              current: {},
+              prev: {}
+          },
+          path: path,
+          type: type
+      };
+  }
+
   var context = createContext(function (ctxRef, parentContext) {
       return parentContext
           ? null
@@ -834,15 +877,8 @@
                   groups: {}
               },
               inclusion: {},
-              isolate: {
-                  type: IsolateTypes.DEFAULT,
-                  keys: {
-                      current: {},
-                      prev: {}
-                  }
-              },
-              mode: [Modes.ALL],
-              testCursor: createCursor()
+              isolate: generateIsolate(IsolateTypes.DEFAULT),
+              mode: [Modes.ALL]
           }, ctxRef);
   });
 
@@ -1144,36 +1180,9 @@
       };
   }
 
-  function deferThrow(message) {
-      setTimeout(function () {
-          throw new Error(message);
-      }, 0);
-  }
-
-  function usePath() {
-      var context$1 = context.useX();
-      return context$1.testCursor.getCursor();
-  }
-  function useCursorAt() {
-      var context$1 = context.useX();
-      return context$1.testCursor.cursorAt();
-  }
-  function moveForward() {
-      var context$1 = context.useX();
-      return context$1.testCursor.next();
-  }
-  function addLevel() {
-      var context$1 = context.useX();
-      context$1.testCursor.addLevel();
-  }
-  function 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) {
+      return asArray(getCurrent(prev, useCurrentPath())).reduce(function (prevKeys, testObject) {
           if (!(testObject instanceof VestTest)) {
               return prevKeys;
           }
@@ -1185,12 +1194,11 @@
       }, {});
   }
   function usePrevTestByKey(key) {
-      var prev = context.useX().isolate.keys.prev;
+      var prev = useIsolate().keys.prev;
       return prev[key];
   }
   function useRetainTestKey(key, testObject) {
-      var context$1 = context.useX();
-      var current = context$1.isolate.keys.current;
+      var current = useIsolate().keys.current;
       if (isNullish(current[key])) {
           current[key] = testObject;
       }
@@ -1202,23 +1210,42 @@
   function isolate(_a, callback) {
       var _b = _a.type, type = _b === void 0 ? IsolateTypes.DEFAULT : _b;
       invariant(isFunction(callback));
-      var keys = {
-          current: {},
-          prev: {}
-      };
-      var path = usePath();
-      return context.run({ isolate: { type: type, keys: keys } }, function () {
-          addLevel();
-          keys.prev = usePrevKeys();
-          useSetTests(function (tests) { return setValueAtPath(tests, path, []); });
+      // 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();
-          removeLevel();
-          moveForward();
           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;
+      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;
@@ -1249,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
    */
@@ -1691,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)) {
@@ -1755,10 +1756,6 @@
       });
   }
 
-  function callEach(arr) {
-      return arr.forEach(function (fn) { return fn(); });
-  }
-
   /**
    * Runs done callback per field when async tests are finished running.
    */
@@ -1780,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;
           }
@@ -1791,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();
@@ -1814,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();
@@ -2142,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);
@@ -2208,10 +2203,6 @@
       }
   }
 
-  function isPromise(value) {
-      return value && isFunction(value.then);
-  }
-
   function isSameProfileTest(testObject1, testObject2) {
       return (testObject1.fieldName === testObject2.fieldName &&
           testObject1.groupName === testObject2.groupName);
@@ -2326,30 +2317,23 @@
       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);
+      var cursorAt = useCursor().current();
       // 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) {
-      var cursorPath = usePath();
+      var cursorPath = useCurrentPath();
       useSetTests(function (tests) {
           return setValueAtPath(tests, cursorPath, testObject);
       });
   }
   function useGetTestAtCursor(tests) {
-      var cursorPath = usePath();
+      var cursorPath = useCurrentPath();
       return valueAtPath(tests, cursorPath);
   }
   function testReorderDetected(prevTest, newTest) {
@@ -2373,16 +2357,17 @@
 
   // eslint-disable-next-line max-statements
   function registerPrevRunTest(testObject) {
+      var cursor = useCursor();
       if (shouldSkipBasedOnMode(testObject)) {
           testObject.skip();
           useTestAtCursor(testObject);
-          moveForward();
+          cursor.next();
           return testObject;
       }
       var prevRunTest = useTestAtCursor(testObject);
       if (isOmitted()) {
           prevRunTest.omit();
-          moveForward();
+          cursor.next();
           return prevRunTest;
       }
       if (isExcluded(testObject)) {
@@ -2391,13 +2376,13 @@
           // This mostly means that we're probably giving
           // up on this async test intentionally.
           prevRunTest.skip(isExcludedIndividually());
-          moveForward();
+          cursor.next();
           return prevRunTest;
       }
       cancelOverriddenPendingTest(prevRunTest, testObject);
       useSetTestAtCursor(testObject);
-      moveForward();
       registerTestObjectByTier(testObject);
+      cursor.next();
       return testObject;
   }
   function registerTestObjectByTier(testObject) {
@@ -2420,7 +2405,7 @@
           for (var _i = 1; _i < arguments.length; _i++) {
               args[_i - 1] = arguments[_i];
           }
-          var cursorAt = useCursorAt();
+          var cursorAt = useCursor().current();
           var _a = args.reverse(), deps = _a[0], testFn = _a[1], msg = _a[2];
           // Implicit dependency for more specificity
           var dependencies = [useSuiteId(), fieldName, cursorAt].concat(deps);
@@ -2482,7 +2467,7 @@
       ctx.currentTest.warn();
   }
 
-  var VERSION = "4.4.0-dev-08ec91";
+  var VERSION = "4.4.2-dev-afe5de";
 
   exports.VERSION = VERSION;
   exports.context = context;