vest 4.4.2 → 4.4.3-dev-c786f7

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,67 +121,218 @@
   }
   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);
+  function deferThrow(message) {
+      setTimeout(function () {
+          throw new Error(message);
+      }, 0);
+  }
+
+  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] || [];
+      }
+  }
 
   /**
-   * A safe hasOwnProperty access
+   * @returns a unique numeric id.
    */
-  function hasOwnProperty(obj, key) {
-      return Object.prototype.hasOwnProperty.call(obj, key);
+  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;
+          }
+      }
+  }
+
+  function isEmpty(value) {
+      if (!value) {
+          return true;
+      }
+      else if (hasOwnProperty(value, 'length')) {
+          return lengthEquals(value, 0);
+      }
+      else if (typeof value === 'object') {
+          return lengthEquals(Object.keys(value), 0);
+      }
+      return false;
+  }
+  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 lengthEquals(value, arg1) {
-      return numberEquals(value.length, arg1);
+  function lessThanOrEquals(value, lte) {
+      return numberEquals(value, lte) || lessThan(value, lte);
   }
-  var lengthNotEquals = bindNot(lengthEquals);
 
-  function isEmpty(value) {
-      if (!value) {
-          return true;
-      }
-      else if (hasOwnProperty(value, 'length')) {
-          return lengthEquals(value, 0);
-      }
-      else if (typeof value === 'object') {
-          return lengthEquals(Object.keys(value), 0);
-      }
-      return false;
+  function isBetween(value, min, max) {
+      return greaterThanOrEquals(value, min) && lessThanOrEquals(value, max);
   }
-  var isNotEmpty = bindNot(isEmpty);
+  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
@@ -179,10 +373,6 @@
       return false;
   };
 
-  function isPositive(value) {
-      return greaterThan(value, 0);
-  }
-
   var isNotString = bindNot(isStringValue);
 
   function isTruthy(value) {
@@ -203,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);
   }
@@ -327,37 +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(value, defaultValue) {
-      var _a;
-      return (_a = optionalFunctionValue(value)) !== null && _a !== void 0 ? _a : optionalFunctionValue(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 @typescript-eslint/ban-types
-  function StringObject(value) {
-      return new String(optionalFunctionValue(value));
-  }
-
   // eslint-disable-next-line max-lines-per-function
   function createContext(init) {
       var storage = { ancestry: [] };
@@ -544,23 +699,6 @@
       }
   }
 
-  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;
-          }
-      }
-  }
-
   // eslint-disable-next-line max-lines-per-function
   function genEnforceLazy(key) {
       var registeredRules = [];
@@ -674,109 +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;
-  }
-
   var IsolateTypes;
   (function (IsolateTypes) {
       IsolateTypes[IsolateTypes["DEFAULT"] = 0] = "DEFAULT";
@@ -1140,10 +1180,24 @@
       };
   }
 
-  function deferThrow(message) {
-      setTimeout(function () {
-          throw new Error(message);
-      }, 0);
+  /**
+   * @returns {Isolate} The current isolate layer
+   */
+  function useIsolate() {
+      return context.useX().isolate;
+  }
+  /**
+   * @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 usePrevKeys() {
@@ -1188,31 +1242,12 @@
       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) {
@@ -1242,10 +1277,6 @@
       return testObject.groupName === groupName;
   }
 
-  function either(a, b) {
-      return !!a !== !!b;
-  }
-
   /**
    * Checks that a given test object matches the currently specified severity level
    */
@@ -1684,28 +1715,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)) {
@@ -1748,10 +1757,6 @@
       });
   }
 
-  function callEach(arr) {
-      return arr.forEach(function (fn) { return fn(); });
-  }
-
   /**
    * Runs done callback per field when async tests are finished running.
    */
@@ -1773,10 +1778,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;
           }
@@ -1784,21 +1789,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();
@@ -1807,14 +1812,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();
@@ -1938,10 +1943,10 @@
    * only('username');
    */
   function only(item) {
-      return addTo(0 /* ONLY */, 'tests', item);
+      return addTo(0 /* ExclusionGroup.ONLY */, 'tests', item);
   }
   only.group = function (item) {
-      return addTo(0 /* ONLY */, 'groups', item);
+      return addTo(0 /* ExclusionGroup.ONLY */, 'groups', item);
   };
   /**
    * Adds a field or a list of fields into the exclusion list
@@ -1951,10 +1956,10 @@
    * skip('username');
    */
   function skip(item) {
-      return addTo(1 /* SKIP */, 'tests', item);
+      return addTo(1 /* ExclusionGroup.SKIP */, 'tests', item);
   }
   skip.group = function (item) {
-      return addTo(1 /* SKIP */, 'groups', item);
+      return addTo(1 /* ExclusionGroup.SKIP */, 'groups', item);
   };
   //Checks whether a certain test profile excluded by any of the exclusion groups.
   // eslint-disable-next-line complexity, max-statements, max-lines-per-function
@@ -2033,7 +2038,7 @@
               return;
           }
           context$1.exclusion[itemType][itemName] =
-              exclusionGroup === 0 /* ONLY */;
+              exclusionGroup === 0 /* ExclusionGroup.ONLY */;
       });
   }
   /**
@@ -2199,10 +2204,6 @@
       }
   }
 
-  function isPromise(value) {
-      return value && isFunction(value.then);
-  }
-
   function isSameProfileTest(testObject1, testObject2) {
       return (testObject1.fieldName === testObject2.fieldName &&
           testObject1.groupName === testObject2.groupName);
@@ -2467,7 +2468,7 @@
       ctx.currentTest.warn();
   }
 
-  var VERSION = "4.4.2";
+  var VERSION = "4.4.3-dev-c786f7";
 
   exports.VERSION = VERSION;
   exports.context = context;