vest 4.4.2 → 4.5.0

package/dist/cjs/vest.development.js

@@ -3,181 +3,12 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var n4s = require('n4s');
+var vestUtils = require('vest-utils');
 var context$1 = require('context');
 
-/**
- * @returns a unique numeric id.
- */
-var genId = (function (n) { return function () {
-    return "".concat(n++);
-}; })(0);
-
-function isStringValue(v) {
-    return String(v) === v;
-}
-
-function bindNot(fn) {
-    return function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        return !fn.apply(void 0, args);
-    };
-}
-
-function isUndefined(value) {
-    return value === undefined;
-}
-
 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);
-}
-
-var assign = Object.assign;
-
-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 numberEquals(value, eq) {
-    return isNumeric(value) && isNumeric(eq) && Number(value) === Number(eq);
-}
-
-function lengthEquals(value, arg1) {
-    return numberEquals(value.length, arg1);
-}
-
-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]; });
-        });
-    }
-}
-
-// The module is named "isArrayValue" since it
-// is conflicting with a nested npm dependency.
-// We may need to revisit this in the future.
-function isArray(value) {
-    return Boolean(Array.isArray(value));
-}
-
-function isNull(value) {
-    return value === null;
-}
-var isNotNull = bindNot(isNull);
-
-function isFunction(value) {
-    return typeof value === 'function';
-}
-
-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 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;
+    return vestUtils.isUndefined(message) && vestUtils.isStringValue(error);
 }
 
 var IsolateTypes;
@@ -234,7 +65,7 @@ function generateIsolate(type, path) {
 var context = context$1.createContext(function (ctxRef, parentContext) {
     return parentContext
         ? null
-        : assign({}, {
+        : vestUtils.assign({
             exclusion: {
                 tests: {},
                 groups: {}
@@ -272,8 +103,8 @@ function useSetOptionalField(fieldName, setter) {
     var _a = useOptionalFields(), setOptionalFields = _a[1];
     setOptionalFields(function (optionalFields) {
         var _a;
-        return assign(optionalFields, (_a = {},
-            _a[fieldName] = optionalFunctionValue(setter, optionalFields[fieldName]),
+        return vestUtils.assign(optionalFields, (_a = {},
+            _a[fieldName] = vestUtils.optionalFunctionValue(setter, optionalFields[fieldName]),
             _a));
     });
 }
@@ -298,7 +129,7 @@ function useSetTests(handler) {
         var current = _a.current, prev = _a.prev;
         return ({
             prev: prev,
-            current: asArray(handler(current))
+            current: vestUtils.asArray(handler(current))
         });
     });
 }
@@ -306,10 +137,10 @@ function useSetTests(handler) {
 function useAllIncomplete() {
     return useTestsFlat().filter(function (test) { return test.isPending(); });
 }
-var flatCache = createCache();
+var flatCache = vestUtils.cache();
 function useTestsFlat() {
     var current = useTestObjects()[0].current;
-    return flatCache([current], function () { return flatten(current); });
+    return flatCache([current], function () { return vestUtils.nestedArray.flatten(current); });
 }
 function useEachTestObject(handler) {
     var testObjects = useTestsFlat();
@@ -325,7 +156,7 @@ var VestTest = /** @class */ (function () {
     function VestTest(fieldName, testFn, _a) {
         var _b = _a === void 0 ? {} : _a, message = _b.message, groupName = _b.groupName, key = _b.key;
         this.key = null;
-        this.id = genId();
+        this.id = vestUtils.seq();
         this.severity = TestSeverity.Error;
         this.status = STATUS_UNTESTED;
         this.fieldName = fieldName;
@@ -460,20 +291,6 @@ var STATUS_PENDING = 'PENDING';
 var STATUS_CANCELED = 'CANCELED';
 var STATUS_OMITTED = 'OMITTED';
 
-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 createState(onStateChange) {
     var state = {
@@ -512,12 +329,12 @@ function createState(onStateChange) {
     }
     function initKey(key, initialState, prevState) {
         current().push();
-        set(key, optionalFunctionValue(initialState, prevState));
+        set(key, vestUtils.optionalFunctionValue(initialState, prevState));
         return function useStateKey() {
             return [
                 current()[key],
                 function (nextState) {
-                    return set(key, optionalFunctionValue(nextState, current()[key]));
+                    return set(key, vestUtils.optionalFunctionValue(nextState, current()[key]));
                 },
             ];
         };
@@ -529,10 +346,10 @@ function createState(onStateChange) {
         var prevValue = state.references[index];
         state.references[index] = value;
         var _a = registrations[index], onUpdate = _a[1];
-        if (isFunction(onUpdate)) {
+        if (vestUtils.isFunction(onUpdate)) {
             onUpdate(value, prevValue);
         }
-        if (isFunction(onStateChange)) {
+        if (vestUtils.isFunction(onStateChange)) {
             onStateChange();
         }
     }
@@ -557,23 +374,33 @@ function createStateRef(state, _a) {
     };
 }
 
-function isNullish(value) {
-    return isNull(value) || isUndefined(value);
+/**
+ * @returns {Isolate} The current isolate layer
+ */
+function useIsolate() {
+    return context.useX().isolate;
 }
-
-function deferThrow(message) {
-    setTimeout(function () {
-        throw new Error(message);
-    }, 0);
+/**
+ * @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() {
     var prev = useTestObjects()[0].prev;
-    return asArray(getCurrent(prev, useCurrentPath())).reduce(function (prevKeys, testObject) {
+    return vestUtils.asArray(vestUtils.nestedArray.getCurrent(prev, useCurrentPath())).reduce(function (prevKeys, testObject) {
         if (!(testObject instanceof VestTest)) {
             return prevKeys;
         }
-        if (isNullish(testObject.key)) {
+        if (vestUtils.isNullish(testObject.key)) {
             return prevKeys;
         }
         prevKeys[testObject.key] = testObject;
@@ -586,22 +413,22 @@ function usePrevTestByKey(key) {
 }
 function useRetainTestKey(key, testObject) {
     var current = useIsolate().keys.current;
-    if (isNullish(current[key])) {
+    if (vestUtils.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."));
+        vestUtils.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));
+    vestUtils.invariant(vestUtils.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, []); });
+        useSetTests(function (tests) { return vestUtils.nestedArray.setValueAtPath(tests, isolate.path, []); });
         var res = callback();
         return res;
     });
@@ -609,31 +436,12 @@ function isolate(_a, callback) {
     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) {
@@ -651,27 +459,6 @@ function countKeyBySeverity(severity) {
         : SeverityCount.WARN_COUNT;
 }
 
-/**
- * A safe hasOwnProperty access
- */
-function hasOwnProperty(obj, key) {
-    return Object.prototype.hasOwnProperty.call(obj, key);
-}
-
-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 nonMatchingFieldName(testObject, fieldName) {
     return !!fieldName && !matchingFieldName(testObject, fieldName);
 }
@@ -679,20 +466,16 @@ function matchingFieldName(testObject, fieldName) {
     return !!(fieldName && testObject.fieldName === fieldName);
 }
 
-var nonMatchingGroupName = bindNot(matchingGroupName);
+var nonMatchingGroupName = vestUtils.bindNot(matchingGroupName);
 function matchingGroupName(testObject, groupName) {
     return testObject.groupName === groupName;
 }
 
-function either(a, b) {
-    return !!a !== !!b;
-}
-
 /**
  * Checks that a given test object matches the currently specified severity level
  */
 function nonMatchingSeverityProfile(severity, testObject) {
-    return either(severity === Severity.WARNINGS, testObject.warns());
+    return vestUtils.either(severity === Severity.WARNINGS, testObject.warns());
 }
 
 /**
@@ -742,7 +525,7 @@ function shouldAddValidProperty(fieldName) {
         return false;
     }
     var testObjects = useTestsFlat();
-    if (isEmpty(testObjects)) {
+    if (vestUtils.isEmpty(testObjects)) {
         return false;
     }
     // Does the given field have any pending tests that are not optional?
@@ -772,13 +555,13 @@ function fieldIsOmitted(fieldName) {
 }
 // Does the given field have any pending tests that are not optional?
 function hasNonOptionalIncomplete(fieldName) {
-    return isNotEmpty(useAllIncomplete().filter(function (testObject) {
+    return vestUtils.isNotEmpty(useAllIncomplete().filter(function (testObject) {
         return isOptionalFieldIncomplete(testObject, fieldName);
     }));
 }
 // Do the given group/field have any pending tests that are not optional?
 function hasNonOptionalIncompleteByGroup(groupName, fieldName) {
-    return isNotEmpty(useAllIncomplete().filter(function (testObject) {
+    return vestUtils.isNotEmpty(useAllIncomplete().filter(function (testObject) {
         if (nonMatchingGroupName(testObject, groupName)) {
             return false;
         }
@@ -818,17 +601,12 @@ function missingTestsLogic(testObject, fieldName) {
         testObject.isOmitted());
 }
 
-function useSummary() {
-    var summary = context.useX().summary;
-    invariant(summary);
-    return summary;
-}
 /**
  * Reads the testObjects list and gets full validation result from it.
  */
 function genTestsSummary() {
     var testObjects = useTestsFlat();
-    var summary = assign(baseStats(), {
+    var summary = vestUtils.assign(baseStats(), {
         groups: {},
         tests: {},
         valid: false
@@ -905,16 +683,12 @@ function baseStats() {
     };
 }
 function baseTestStats() {
-    return assign(baseStats(), {
+    return vestUtils.assign(baseStats(), {
         errors: [],
         warnings: []
     });
 }
 
-function isPositive(value) {
-    return greaterThan(value, 0);
-}
-
 // calls collectAll or getByFieldName depending on whether fieldName is provided
 function gatherFailures(testGroup, severityKey, fieldName) {
     return fieldName
@@ -929,7 +703,7 @@ function collectAll(testGroup, severityKey) {
     var output = {};
     var countKey = countKeyBySeverity(severityKey);
     for (var field in testGroup) {
-        if (isPositive(testGroup[field][countKey])) {
+        if (vestUtils.isPositive(testGroup[field][countKey])) {
             // We will probably never get to the fallback array
             // leaving it just in case the implementation changes
             output[field] = testGroup[field][severityKey] || [];
@@ -938,118 +712,117 @@ function collectAll(testGroup, severityKey) {
     return output;
 }
 
-function getErrors(fieldName) {
-    return getFailures(Severity.ERRORS, fieldName);
-}
-function getWarnings(fieldName) {
-    return getFailures(Severity.WARNINGS, fieldName);
+// eslint-disable-next-line max-lines-per-function, max-statements
+function suiteSelectors(summary) {
+    var selectors = {
+        getErrors: getErrors,
+        getErrorsByGroup: getErrorsByGroup,
+        getWarnings: getWarnings,
+        getWarningsByGroup: getWarningsByGroup,
+        hasErrors: hasErrors,
+        hasErrorsByGroup: hasErrorsByGroup,
+        hasWarnings: hasWarnings,
+        hasWarningsByGroup: hasWarningsByGroup,
+        isValid: isValid,
+        isValidByGroup: isValidByGroup
+    };
+    return selectors;
+    // Booleans
+    function isValid(fieldName) {
+        var _a;
+        return fieldName ? Boolean((_a = summary.tests[fieldName]) === null || _a === void 0 ? void 0 : _a.valid) : summary.valid;
+    }
+    function isValidByGroup(groupName, fieldName) {
+        var group = summary.groups[groupName];
+        if (!group) {
+            return false;
+        }
+        if (fieldName) {
+            return isFieldValid(group, fieldName);
+        }
+        for (var fieldName_1 in group) {
+            if (!isFieldValid(group, fieldName_1)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    function hasWarnings(fieldName) {
+        return hasFailures(summary, SeverityCount.WARN_COUNT, fieldName);
+    }
+    function hasErrors(fieldName) {
+        return hasFailures(summary, SeverityCount.ERROR_COUNT, fieldName);
+    }
+    function hasWarningsByGroup(groupName, fieldName) {
+        return hasFailuresByGroup(summary, SeverityCount.WARN_COUNT, groupName, fieldName);
+    }
+    function hasErrorsByGroup(groupName, fieldName) {
+        return hasFailuresByGroup(summary, SeverityCount.ERROR_COUNT, groupName, fieldName);
+    }
+    function getWarnings(fieldName) {
+        return getFailures(summary, Severity.WARNINGS, fieldName);
+    }
+    function getErrors(fieldName) {
+        return getFailures(summary, Severity.ERRORS, fieldName);
+    }
+    function getErrorsByGroup(groupName, fieldName) {
+        return getFailuresByGroup(summary, Severity.ERRORS, groupName, fieldName);
+    }
+    function getWarningsByGroup(groupName, fieldName) {
+        return getFailuresByGroup(summary, Severity.WARNINGS, groupName, fieldName);
+    }
 }
-/**
- * @returns suite or field's errors or warnings.
- */
-function getFailures(severityKey, fieldName) {
-    var summary = useSummary();
+// Gathers all failures of a given severity
+// With a fieldName, it will only gather failures for that field
+function getFailures(summary, severityKey, fieldName) {
     return gatherFailures(summary.tests, severityKey, fieldName);
 }
-
-function getErrorsByGroup(groupName, fieldName) {
-    return getFailuresByGroup(groupName, Severity.ERRORS, fieldName);
-}
-function getWarningsByGroup(groupName, fieldName) {
-    return getFailuresByGroup(groupName, Severity.WARNINGS, fieldName);
-}
-function getFailuresByGroup(groupName, severityKey, fieldName) {
-    var summary = useSummary();
+// Gathers all failures of a given severity within a group
+// With a fieldName, it will only gather failures for that field
+function getFailuresByGroup(summary, severityKey, groupName, fieldName) {
     return gatherFailures(summary.groups[groupName], severityKey, fieldName);
 }
-
-function hasErrors(fieldName) {
-    return hasFailures(SeverityCount.ERROR_COUNT, fieldName);
-}
-function hasWarnings(fieldName) {
-    return hasFailures(SeverityCount.WARN_COUNT, fieldName);
-}
-function hasFailures(severityCount, fieldName) {
+// Checks if a field is valid within a container object - can be within a group or top level
+function isFieldValid(testContainer, fieldName) {
     var _a;
-    var summary = useSummary();
-    if (fieldName) {
-        return isPositive((_a = summary.tests[fieldName]) === null || _a === void 0 ? void 0 : _a[severityCount]);
-    }
-    return isPositive(summary[severityCount]);
-}
-
-function hasErrorsByGroup(groupName, fieldName) {
-    return hasFailuresByGroup(Severity.ERRORS, groupName, fieldName);
-}
-function hasWarningsByGroup(groupName, fieldName) {
-    return hasFailuresByGroup(Severity.WARNINGS, groupName, fieldName);
+    return !!((_a = testContainer[fieldName]) === null || _a === void 0 ? void 0 : _a.valid);
 }
-// eslint-disable-next-line max-statements
-function hasFailuresByGroup(severityKey, groupName, fieldName) {
+// Checks if a there are any failures of a given severity within a group
+// If a fieldName is provided, it will only check for failures within that field
+function hasFailuresByGroup(summary, severityCount, groupName, fieldName) {
     var _a, _b;
-    var summary = useSummary();
-    var severityCount = countKeyBySeverity(severityKey);
     var group = summary.groups[groupName];
     if (!group) {
         return false;
     }
     if (fieldName) {
-        return isPositive((_a = group[fieldName]) === null || _a === void 0 ? void 0 : _a[severityCount]);
+        return vestUtils.isPositive((_a = group[fieldName]) === null || _a === void 0 ? void 0 : _a[severityCount]);
     }
     for (var field in group) {
-        if (isPositive((_b = group[field]) === null || _b === void 0 ? void 0 : _b[severityCount])) {
+        if (vestUtils.isPositive((_b = group[field]) === null || _b === void 0 ? void 0 : _b[severityCount])) {
             return true;
         }
     }
     return false;
 }
-
-function isValid(fieldName) {
-    var summary = useSummary();
-    return fieldName
-        ? Boolean(isFieldValid(summary.tests, fieldName))
-        : summary.valid;
-}
-function isValidByGroup(groupName, fieldName) {
-    var summary = useSummary();
-    var group = summary.groups[groupName];
-    if (!group) {
-        return false;
-    }
-    if (fieldName) {
-        return isFieldValid(group, fieldName);
-    }
-    for (var fieldName_1 in group) {
-        if (!isFieldValid(group, fieldName_1)) {
-            return false;
-        }
-    }
-    return true;
-}
-function isFieldValid(testContainer, fieldName) {
+// Checks if there are any failures of a given severity
+// If a fieldName is provided, it will only check for failures within that field
+function hasFailures(summary, countKey, fieldName) {
     var _a;
-    return !!((_a = testContainer[fieldName]) === null || _a === void 0 ? void 0 : _a.valid);
+    var failureCount = fieldName
+        ? (_a = summary.tests[fieldName]) === null || _a === void 0 ? void 0 : _a[countKey]
+        : summary[countKey] || 0;
+    return vestUtils.isPositive(failureCount);
 }
 
-var cache$1 = createCache(1);
+var cache$1 = vestUtils.cache(1);
 function produceSuiteResult() {
     var testObjects = useTestsFlat();
     var ctxRef = { stateRef: useStateRef() };
     return cache$1([testObjects], context.bind(ctxRef, function () {
         var summary = genTestsSummary();
         var suiteName = useSuiteName();
-        var ref = { summary: summary };
-        return assign(summary, {
-            getErrors: context.bind(ref, getErrors),
-            getErrorsByGroup: context.bind(ref, getErrorsByGroup),
-            getWarnings: context.bind(ref, getWarnings),
-            getWarningsByGroup: context.bind(ref, getWarningsByGroup),
-            hasErrors: context.bind(ref, hasErrors),
-            hasErrorsByGroup: context.bind(ref, hasErrorsByGroup),
-            hasWarnings: context.bind(ref, hasWarnings),
-            hasWarningsByGroup: context.bind(ref, hasWarningsByGroup),
-            isValid: context.bind(ref, isValid),
-            isValidByGroup: context.bind(ref, isValidByGroup),
+        return vestUtils.assign(summary, suiteSelectors(summary), {
             suiteName: suiteName
         });
     }));
@@ -1060,7 +833,7 @@ function produceSuiteResult() {
  */
 function hasRemainingTests(fieldName) {
     var allIncomplete = useAllIncomplete();
-    if (isEmpty(allIncomplete)) {
+    if (vestUtils.isEmpty(allIncomplete)) {
         return false;
     }
     if (fieldName) {
@@ -1068,15 +841,15 @@ function hasRemainingTests(fieldName) {
             return matchingFieldName(testObject, fieldName);
         });
     }
-    return isNotEmpty(allIncomplete);
+    return true;
 }
 
-var cache = createCache(20);
+var cache = vestUtils.cache(20);
 function produceFullResult() {
     var testObjects = useTestsFlat();
     var ctxRef = { stateRef: useStateRef() };
     return cache([testObjects], context.bind(ctxRef, function () {
-        return assign({}, produceSuiteResult(), {
+        return vestUtils.assign({}, produceSuiteResult(), {
             done: context.bind(ctxRef, done)
         });
     }));
@@ -1085,10 +858,10 @@ function produceFullResult() {
  * DONE is here and not in its own module to prevent circular dependency issues.
  */
 function shouldSkipDoneRegistration(callback, fieldName, output) {
+    var _a;
     // If we do not have any test runs for the current field
-    return !!(!isFunction(callback) ||
-        (fieldName &&
-            (!output.tests[fieldName] || isEmpty(output.tests[fieldName].testCount))));
+    return !!(!vestUtils.isFunction(callback) ||
+        (fieldName && vestUtils.numberEquals((_a = output.tests[fieldName]) === null || _a === void 0 ? void 0 : _a.testCount, 0)));
 }
 function shouldRunDoneCallback(fieldName) {
     // is suite finished || field name exists, and test is finished;
@@ -1130,38 +903,16 @@ function deferDoneCallback(doneCallback, fieldName) {
     });
 }
 
-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)) {
+    if (vestUtils.isEmpty(optionalFields)) {
         return;
     }
     var shouldOmit = {};
     useSetTests(function (tests) {
-        return transform(tests, function (testObject) {
+        return vestUtils.nestedArray.transform(tests, function (testObject) {
             var fieldName = testObject.fieldName;
-            if (hasOwnProperty(shouldOmit, fieldName)) {
+            if (vestUtils.hasOwnProperty(shouldOmit, fieldName)) {
                 verifyAndOmit(testObject);
             }
             else {
@@ -1178,7 +929,7 @@ function omitOptionalFields() {
     }
     function runOptionalConfig(testObject) {
         var optionalConfig = useOptionalFieldConfig(testObject.fieldName);
-        if (isFunction(optionalConfig)) {
+        if (vestUtils.isFunction(optionalConfig)) {
             shouldOmit[testObject.fieldName] = optionalConfig();
             verifyAndOmit(testObject);
         }
@@ -1190,14 +941,10 @@ function omitOptionalFields() {
  */
 function removeTestFromState (testObject) {
     useSetTests(function (tests) {
-        return transform(tests, function (test) { return (testObject !== test ? test : null); });
+        return vestUtils.nestedArray.transform(tests, function (test) { return (testObject !== test ? test : null); });
     });
 }
 
-function callEach(arr) {
-    return arr.forEach(function (fn) { return fn(); });
-}
-
 /**
  * Runs done callback per field when async tests are finished running.
  */
@@ -1205,8 +952,8 @@ function runFieldCallbacks(fieldName) {
     var fieldCallbacks = useTestCallbacks()[0].fieldCallbacks;
     if (fieldName &&
         !hasRemainingTests(fieldName) &&
-        isArray(fieldCallbacks[fieldName])) {
-        callEach(fieldCallbacks[fieldName]);
+        vestUtils.isArray(fieldCallbacks[fieldName])) {
+        vestUtils.callEach(fieldCallbacks[fieldName]);
     }
 }
 /**
@@ -1214,15 +961,15 @@ function runFieldCallbacks(fieldName) {
  */
 function runDoneCallbacks() {
     var doneCallbacks = useTestCallbacks()[0].doneCallbacks;
-    callEach(doneCallbacks);
+    vestUtils.callEach(doneCallbacks);
 }
 
 // eslint-disable-next-line max-lines-per-function
 function initBus() {
-    var bus = createBus();
+    var vestBus = vestUtils.bus.createBus();
     // Report a the completion of a test. There may be other tests with the same
     // name that are still running, or not yet started.
-    bus.on(Events.TEST_COMPLETED, function (testObject) {
+    vestBus.on(Events.TEST_COMPLETED, function (testObject) {
         if (testObject.isCanceled()) {
             return;
         }
@@ -1230,21 +977,21 @@ function initBus() {
         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();
@@ -1253,18 +1000,18 @@ function initBus() {
         });
     });
     // 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();
-    invariant(context$1.bus);
+    vestUtils.invariant(context$1.bus);
     return context$1.bus;
 }
 var Events;
@@ -1283,16 +1030,16 @@ function create() {
         args[_i] = arguments[_i];
     }
     var _a = args.reverse(), suiteCallback = _a[0], suiteName = _a[1];
-    invariant(isFunction(suiteCallback), 'vest.create: Expected callback to be a function.');
+    vestUtils.invariant(vestUtils.isFunction(suiteCallback), 'vest.create: Expected callback to be a function.');
     // Event bus initialization
     var bus = initBus();
     // State initialization
     var state = createState();
     // State reference - this holds the actual state values
-    var stateRef = createStateRef(state, { suiteId: genId(), suiteName: suiteName });
+    var stateRef = createStateRef(state, { suiteId: vestUtils.seq(), suiteName: suiteName });
     // Create base context reference. All hooks will derive their data from this
     var ctxRef = { stateRef: stateRef, bus: bus };
-    var suite = assign(
+    var suite = vestUtils.assign(
     // Bind the suite body to the context
     context.bind(ctxRef, function () {
         var args = [];
@@ -1338,7 +1085,7 @@ function create() {
  * })
  */
 function each(list, callback) {
-    invariant(isFunction(callback), 'each callback must be a function');
+    vestUtils.invariant(vestUtils.isFunction(callback), 'each callback must be a function');
     isolate({ type: IsolateTypes.EACH }, function () {
         list.forEach(function (arg, index) {
             callback(arg, index);
@@ -1368,7 +1115,7 @@ function skipWhen(conditional, callback) {
             // we should skip the test if the parent conditional is true.
             isExcludedIndividually() ||
                 // Otherwise, we should skip the test if the conditional is true.
-                optionalFunctionValue(conditional, optionalFunctionValue(produceSuiteResult))
+                vestUtils.optionalFunctionValue(conditional, vestUtils.optionalFunctionValue(produceSuiteResult))
         }, function () { return callback(); });
     });
 }
@@ -1384,10 +1131,10 @@ function isExcludedIndividually() {
  * 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
@@ -1397,13 +1144,13 @@ only.group = function (item) {
  * 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
+// eslint-disable-next-line complexity, max-statements
 function isExcluded(testObject) {
     var fieldName = testObject.fieldName, groupName = testObject.groupName;
     if (isExcludedIndividually())
@@ -1444,7 +1191,7 @@ function isExcluded(testObject) {
         // Check if inclusion rules for this field (`include` hook)
         // TODO: Check if this may need to be moved outside of the condition.
         // What if there are no included tests? This shouldn't run then?
-        return !optionalFunctionValue(inclusion[fieldName]);
+        return !vestUtils.optionalFunctionValue(inclusion[fieldName]);
     }
     // We're done here. This field is not excluded
     return false;
@@ -1456,7 +1203,7 @@ function isGroupExcluded(groupName) {
     var context$1 = context.useX();
     var exclusion = context$1.exclusion;
     var keyGroups = exclusion.groups;
-    var groupPresent = hasOwnProperty(keyGroups, groupName);
+    var groupPresent = vestUtils.hasOwnProperty(keyGroups, groupName);
     // When group is either only'ed or skipped
     if (groupPresent) {
         // Return true if group is skipped and false if only'ed
@@ -1474,12 +1221,12 @@ function addTo(exclusionGroup, itemType, item) {
     if (!item) {
         return;
     }
-    asArray(item).forEach(function (itemName) {
-        if (!isStringValue(itemName)) {
+    vestUtils.asArray(item).forEach(function (itemName) {
+        if (!vestUtils.isStringValue(itemName)) {
             return;
         }
         context$1.exclusion[itemType][itemName] =
-            exclusionGroup === 0 /* ONLY */;
+            exclusionGroup === 0 /* ExclusionGroup.ONLY */;
     });
 }
 /**
@@ -1522,8 +1269,8 @@ function hasIncludedGroups() {
  * });
  */
 function group(groupName, tests) {
-    invariant(isStringValue(groupName), groupErrorMsg('name must be a string'));
-    invariant(isFunction(tests), groupErrorMsg('callback must be a function'));
+    vestUtils.invariant(vestUtils.isStringValue(groupName), groupErrorMsg('name must be a string'));
+    vestUtils.invariant(vestUtils.isFunction(tests), groupErrorMsg('callback must be a function'));
     // Running with the context applied
     isolate({ type: IsolateTypes.GROUP }, function () {
         context.run({ groupName: groupName }, tests);
@@ -1536,24 +1283,24 @@ function groupErrorMsg(error) {
 function include(fieldName) {
     var context$1 = context.useX();
     var inclusion = context$1.inclusion, exclusion = context$1.exclusion;
-    invariant(isStringValue(fieldName));
-    inclusion[fieldName] = defaultTo(exclusion.tests[fieldName], true);
+    vestUtils.invariant(vestUtils.isStringValue(fieldName));
+    inclusion[fieldName] = vestUtils.defaultTo(exclusion.tests[fieldName], true);
     return { when: when };
     function when(condition) {
         var context$1 = context.useX();
         var inclusion = context$1.inclusion, exclusion = context$1.exclusion;
         // This callback will run as part of the "isExcluded" series of checks
         inclusion[fieldName] = function () {
-            if (hasOwnProperty(exclusion.tests, fieldName)) {
+            if (vestUtils.hasOwnProperty(exclusion.tests, fieldName)) {
                 // I suspect this code is technically unreachable because
                 // if there are any skip/only rules applied to the current
                 // field, the "isExcluded" function will have already bailed
-                return defaultTo(exclusion.tests[fieldName], true);
+                return vestUtils.defaultTo(exclusion.tests[fieldName], true);
             }
-            if (isStringValue(condition)) {
+            if (vestUtils.isStringValue(condition)) {
                 return Boolean(exclusion.tests[condition]);
             }
-            return optionalFunctionValue(condition, optionalFunctionValue(produceSuiteResult));
+            return vestUtils.optionalFunctionValue(condition, vestUtils.optionalFunctionValue(produceSuiteResult));
         };
     }
 }
@@ -1608,7 +1355,7 @@ function omitWhen(conditional, callback) {
     isolate({ type: IsolateTypes.OMIT_WHEN }, function () {
         context.run({
             omitted: isOmitted() ||
-                optionalFunctionValue(conditional, optionalFunctionValue(produceSuiteResult))
+                vestUtils.optionalFunctionValue(conditional, vestUtils.optionalFunctionValue(produceSuiteResult))
         }, function () { return callback(); });
     });
 }
@@ -1630,8 +1377,8 @@ function isOmitted() {
 function optional(optionals) {
     // When the optional is given as a string or a list of strings
     // we just add them to the list of optional fields.
-    if (isArray(optionals) || isStringValue(optionals)) {
-        asArray(optionals).forEach(function (optionalField) {
+    if (vestUtils.isArray(optionals) || vestUtils.isStringValue(optionals)) {
+        vestUtils.asArray(optionals).forEach(function (optionalField) {
             useSetOptionalField(optionalField, [true, false]);
         });
     }
@@ -1670,9 +1417,7 @@ function __spreadArray(to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 }
 
-function isPromise(value) {
-    return value && isFunction(value.then);
-}
+vestUtils.bindNot(vestUtils.isStringValue);
 
 function isSameProfileTest(testObject1, testObject2) {
     return (testObject1.fieldName === testObject2.fieldName &&
@@ -1692,7 +1437,7 @@ function cancelOverriddenPendingTest(prevRunTestObject, currentRunTestObject) {
  */
 function runAsyncTest(testObject) {
     var asyncTest = testObject.asyncTest, message = testObject.message;
-    if (!isPromise(asyncTest))
+    if (!vestUtils.isPromise(asyncTest))
         return;
     var emit = useBus().emit;
     var stateRef = useStateRef();
@@ -1705,7 +1450,7 @@ function runAsyncTest(testObject) {
         if (testObject.isCanceled()) {
             return;
         }
-        testObject.message = isStringValue(rejectionMessage)
+        testObject.message = vestUtils.isStringValue(rejectionMessage)
             ? rejectionMessage
             : message;
         testObject.fail();
@@ -1740,7 +1485,7 @@ function registerTest(testObject) {
     try {
         // try catch for safe property access
         // in case object is an enforce chain
-        if (isPromise(result)) {
+        if (vestUtils.isPromise(result)) {
             testObject.asyncTest = result;
             testObject.setPending();
             runAsyncTest(testObject);
@@ -1767,12 +1512,12 @@ function registerTest(testObject) {
 function useTestAtCursor(newTestObject) {
     var testObjects = useTestObjects()[0];
     var prevTests = testObjects.prev;
-    if (isEmpty(prevTests)) {
+    if (vestUtils.isEmpty(prevTests)) {
         useSetTestAtCursor(newTestObject);
         return newTestObject;
     }
     var prevTest = useGetTestAtCursor(prevTests);
-    if (!isNullish(newTestObject.key)) {
+    if (!vestUtils.isNullish(newTestObject.key)) {
         var nextTest_1 = handleKeyTest(newTestObject.key, newTestObject);
         useSetTestAtCursor(nextTest_1);
         return nextTest_1;
@@ -1783,7 +1528,7 @@ function useTestAtCursor(newTestObject) {
         // Need to see if this has any effect at all.
         prevTest = null;
     }
-    var nextTest = defaultTo(prevTest, newTestObject);
+    var nextTest = vestUtils.defaultTo(prevTest, newTestObject);
     useSetTestAtCursor(nextTest);
     return nextTest;
 }
@@ -1800,21 +1545,21 @@ function removeAllNextTestsInIsolate() {
 function useSetTestAtCursor(testObject) {
     var cursorPath = useCurrentPath();
     useSetTests(function (tests) {
-        return setValueAtPath(tests, cursorPath, testObject);
+        return vestUtils.nestedArray.setValueAtPath(tests, cursorPath, testObject);
     });
 }
 function useGetTestAtCursor(tests) {
     var cursorPath = useCurrentPath();
-    return valueAtPath(tests, cursorPath);
+    return vestUtils.nestedArray.valueAtPath(tests, cursorPath);
 }
 function testReorderDetected(prevTest, newTest) {
-    return isNotEmpty(prevTest) && !isSameProfileTest(prevTest, newTest);
+    return vestUtils.isNotEmpty(prevTest) && !isSameProfileTest(prevTest, newTest);
 }
 function throwTestOrderError(prevTest, newTestObject) {
     if (shouldAllowReorder()) {
         return;
     }
-    deferThrow("Vest Critical Error: Tests called in different order than previous run.\n    expected: ".concat(prevTest.fieldName, "\n    received: ").concat(newTestObject.fieldName, "\n    This can happen on one of two reasons:\n    1. You're using if/else statements to conditionally select tests. Instead, use \"skipWhen\".\n    2. You are iterating over a list of tests, and their order changed. Use \"each\" and a custom key prop so that Vest retains their state."));
+    vestUtils.deferThrow("Vest Critical Error: Tests called in different order than previous run.\n    expected: ".concat(prevTest.fieldName, "\n    received: ").concat(newTestObject.fieldName, "\n    This can happen on one of two reasons:\n    1. You're using if/else statements to conditionally select tests. Instead, use \"skipWhen\".\n    2. You are iterating over a list of tests, and their order changed. Use \"each\" and a custom key prop so that Vest retains their state."));
 }
 function handleKeyTest(key, newTestObject) {
     var prevTestByKey = usePrevTestByKey(key);
@@ -1860,16 +1605,15 @@ function registerTestObjectByTier(testObject) {
     if (testObject.isUntested()) {
         registerTest(testObject);
     }
-    else if (isPromise(testObject.asyncTest)) {
+    else if (vestUtils.isPromise(testObject.asyncTest)) {
         testObject.setPending();
         runAsyncTest(testObject);
     }
 }
 
 /* eslint-disable jest/valid-title */
-// eslint-disable-next-line max-lines-per-function
 function bindTestMemo(test) {
-    var cache = createCache(10); // arbitrary cache size
+    var cache = vestUtils.cache(10); // arbitrary cache size
     // eslint-disable-next-line max-statements
     function memo(fieldName) {
         var args = [];
@@ -1881,7 +1625,7 @@ function bindTestMemo(test) {
         // Implicit dependency for more specificity
         var dependencies = [useSuiteId(), fieldName, cursorAt].concat(deps);
         var cached = cache.get(dependencies);
-        if (isNull(cached)) {
+        if (vestUtils.isNull(cached)) {
             // cache miss
             return cache(dependencies, function () { return test(fieldName, msg, testFn); });
         }
@@ -1900,9 +1644,9 @@ function testBase(fieldName) {
     for (var _i = 1; _i < arguments.length; _i++) {
         args[_i - 1] = arguments[_i];
     }
-    var _a = (isFunction(args[1]) ? args : __spreadArray([undefined], args, true)), message = _a[0], testFn = _a[1], key = _a[2];
-    invariant(isStringValue(fieldName), incompatibleParamsError('fieldName', 'string'));
-    invariant(isFunction(testFn), incompatibleParamsError('Test callback', 'function'));
+    var _a = (vestUtils.isFunction(args[1]) ? args : __spreadArray([undefined], args, true)), message = _a[0], testFn = _a[1], key = _a[2];
+    vestUtils.invariant(vestUtils.isStringValue(fieldName), incompatibleParamsError('fieldName', 'string'));
+    vestUtils.invariant(vestUtils.isFunction(testFn), incompatibleParamsError('Test callback', 'function'));
     var context$1 = context.useX();
     var testObject = new VestTest(fieldName, testFn, {
         message: message,
@@ -1920,7 +1664,7 @@ function testBase(fieldName) {
  *  enforce(data.username).isNotBlank();
  * });
  */
-var test = assign(testBase, {
+var test = vestUtils.assign(testBase, {
     memo: bindTestMemo(testBase)
 });
 function incompatibleParamsError(name, expected) {
@@ -1934,11 +1678,11 @@ var ERROR_OUTSIDE_OF_TEST = "warn hook called outside of a test callback. It won
  */
 function warn() {
     var ctx = context.useX('warn ' + ERROR_HOOK_CALLED_OUTSIDE);
-    invariant(ctx.currentTest, ERROR_OUTSIDE_OF_TEST);
+    vestUtils.invariant(ctx.currentTest, ERROR_OUTSIDE_OF_TEST);
     ctx.currentTest.warn();
 }
 
-var VERSION = "4.4.2";
+var VERSION = "4.5.0";
 
 Object.defineProperty(exports, 'enforce', {
   enumerable: true,
@@ -1958,5 +1702,6 @@ exports.only = only;
 exports.optional = optional;
 exports.skip = skip;
 exports.skipWhen = skipWhen;
+exports.suiteSelectors = suiteSelectors;
 exports.test = test;
 exports.warn = warn;