vest 3.2.8-dev-6d7c74 → 3.2.8

package/dist/es/vest.development.js

@@ -1,1604 +0,0 @@
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-var __assign = function () {
-  __assign = Object.assign || function __assign(t) {
-    for (var s, i = 1, n = arguments.length; i < n; i++) {
-      s = arguments[i];
-
-      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-    }
-
-    return t;
-  };
-
-  return __assign.apply(this, arguments);
-};
-function __spreadArray(to, from, pack) {
-  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-    if (ar || !(i in from)) {
-      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-      ar[i] = from[i];
-    }
-  }
-  return to.concat(ar || from);
-}
-
-var assign = Object.assign;
-
-function mapFirst(array, callback) {
-    var broke = false;
-    var breakoutValue = null;
-    for (var i = 0; i < array.length; i++) {
-        callback(array[i], breakout);
-        if (broke) {
-            return breakoutValue;
-        }
-    }
-    function breakout(value) {
-        broke = true;
-        breakoutValue = value;
-    }
-}
-
-/**
- * Throws a timed out error.
- */
-function throwError(message, type) {
-    if (type === void 0) { type = Error; }
-    throw new type(message);
-}
-
-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);
-    };
-}
-
-/**
- * A safe hasOwnProperty access
- */
-function hasOwnProperty(obj, key) {
-    return Object.prototype.hasOwnProperty.call(obj, key);
-}
-
-function isNumber(value) {
-    return Boolean(typeof value === 'number');
-}
-var isNotNumber = bindNot(isNumber);
-
-function lengthEquals(value, arg1) {
-    return value.length === Number(arg1);
-}
-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);
-    }
-    else if (typeof value === 'object') {
-        return lengthEquals(Object.keys(value), 0);
-    }
-    return true;
-}
-var isNotEmpty = bindNot(isEmpty);
-
-function failing() {
-    return { pass: false };
-}
-function passing() {
-    return { pass: true };
-}
-
-function anyOf(value) {
-    var _a;
-    var rules = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        rules[_i - 1] = arguments[_i];
-    }
-    return ((_a = mapFirst(rules, function (rule, breakout) {
-        var res = rule.run(value);
-        if (res.pass) {
-            breakout(res);
-        }
-    })) !== null && _a !== void 0 ? _a : failing);
-}
-
-function noneOf(value) {
-    var _a;
-    var rules = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        rules[_i - 1] = arguments[_i];
-    }
-    return ((_a = mapFirst(rules, function (rule, breakout) {
-        var res = rule.run(value);
-        if (res.pass) {
-            breakout(failing());
-        }
-    })) !== null && _a !== void 0 ? _a : passing());
-}
-
-function oneOf(value) {
-    var rules = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        rules[_i - 1] = arguments[_i];
-    }
-    var passing = [];
-    rules.every(function (rule) {
-        if (passing.length > 1) {
-            return false;
-        }
-        var result = rule.run(value);
-        if (result.pass) {
-            passing.push(result);
-        }
-        return result.pass;
-    });
-    return { pass: passing.length === 1 };
-}
-
-function allOf(value) {
-    var _a;
-    var rules = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        rules[_i - 1] = arguments[_i];
-    }
-    return ((_a = mapFirst(rules, function (rule, breakout) {
-        var res = rule.run(value);
-        if (!res.pass) {
-            breakout(res);
-        }
-    })) !== null && _a !== void 0 ? _a : passing());
-}
-
-var compounds = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    anyOf: anyOf,
-    noneOf: noneOf,
-    oneOf: oneOf,
-    allOf: allOf
-});
-
-function isStringValue (v) {
-    return String(v) === v;
-}
-
-function endsWith(value, arg1) {
-    return isStringValue(value) && isStringValue(arg1) && value.endsWith(arg1);
-}
-var doesNotEndWith = bindNot(endsWith);
-
-function equals(value, arg1) {
-    return value === arg1;
-}
-var notEquals = bindNot(equals);
-
-function isNumeric(value) {
-    var str = String(value);
-    var num = Number(value);
-    var result = !isNaN(parseFloat(str)) && !isNaN(Number(value)) && isFinite(num);
-    return Boolean(result);
-}
-var isNotNumeric = bindNot(isNumeric);
-
-function greaterThan(value, gt) {
-    return isNumeric(value) && isNumeric(gt) && Number(value) > Number(gt);
-}
-
-function greaterThanOrEquals(value, gte) {
-    return isNumeric(value) && isNumeric(gte) && Number(value) >= Number(gte);
-}
-
-function inside(value, arg1) {
-    if (Array.isArray(arg1) && /^[s|n|b]/.test(typeof value)) {
-        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);
-
-// The module is named "isArrayValue" since it
-// is conflicting with a nested npm dependency.
-// We may need to revisit this in the future.
-function isArray(value) {
-    return Boolean(Array.isArray(value));
-}
-var isNotArray = bindNot(isArray);
-
-function lessThanOrEquals(value, lte) {
-    return isNumeric(value) && isNumeric(lte) && Number(value) <= Number(lte);
-}
-
-function isBetween(value, min, max) {
-    return greaterThanOrEquals(value, min) && lessThanOrEquals(value, max);
-}
-var isNotBetween = bindNot(isBetween);
-
-function isBoolean(value) {
-    return !!value === value;
-}
-
-var isNotBoolean = bindNot(isBoolean);
-
-/**
- * Validates that a given value is an even number
- */
-var isEven = function (value) {
-    if (isNumeric(value)) {
-        return value % 2 === 0;
-    }
-    return false;
-};
-
-function isNaN$1(value) {
-    return Number.isNaN(value);
-}
-var isNotNaN = bindNot(isNaN$1);
-
-function isNegative(value) {
-    if (isNumeric(value)) {
-        return Number(value) < 0;
-    }
-    return false;
-}
-var isPositive = bindNot(isNegative);
-
-function isNull(value) {
-    return value === null;
-}
-var isNotNull = bindNot(isNull);
-
-/**
- * Validates that a given value is an odd number
- */
-var isOdd = function (value) {
-    if (isNumeric(value)) {
-        return value % 2 !== 0;
-    }
-    return false;
-};
-
-var isNotString = bindNot(isStringValue);
-
-function isTruthy(value) {
-    return !!value;
-}
-var isFalsy = bindNot(isTruthy);
-
-function isUndefined(value) {
-    return value === undefined;
-}
-var isNotUndefined = bindNot(isUndefined);
-
-function lessThan(value, lt) {
-    return isNumeric(value) && isNumeric(lt) && Number(value) < Number(lt);
-}
-
-function longerThan(value, arg1) {
-    return value.length > Number(arg1);
-}
-
-function longerThanOrEquals(value, arg1) {
-    return value.length >= Number(arg1);
-}
-
-function matches(value, regex) {
-    if (regex instanceof RegExp) {
-        return regex.test(value);
-    }
-    else if (isStringValue(regex)) {
-        return new RegExp(regex).test(value);
-    }
-    else {
-        return false;
-    }
-}
-var notMatches = bindNot(matches);
-
-function numberEquals(value, eq) {
-    return isNumeric(value) && isNumeric(eq) && Number(value) === Number(eq);
-}
-var numberNotEquals = bindNot(numberEquals);
-
-function shorterThan(value, arg1) {
-    return value.length < Number(arg1);
-}
-
-function shorterThanOrEquals(value, arg1) {
-    return value.length <= Number(arg1);
-}
-
-function startsWith(value, arg1) {
-    return isStringValue(value) && isStringValue(arg1) && value.startsWith(arg1);
-}
-var doesNotStartWith = bindNot(startsWith);
-
-// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-function rules() {
-    return {
-        doesNotEndWith: doesNotEndWith,
-        doesNotStartWith: doesNotStartWith,
-        endsWith: endsWith,
-        equals: equals,
-        greaterThan: greaterThan,
-        greaterThanOrEquals: greaterThanOrEquals,
-        gt: greaterThan,
-        gte: greaterThanOrEquals,
-        inside: inside,
-        isArray: isArray,
-        isBetween: isBetween,
-        isBoolean: isBoolean,
-        isEmpty: isEmpty,
-        isEven: isEven,
-        isFalsy: isFalsy,
-        isNaN: isNaN$1,
-        isNegative: isNegative,
-        isNotArray: isNotArray,
-        isNotBetween: isNotBetween,
-        isNotBoolean: isNotBoolean,
-        isNotEmpty: isNotEmpty,
-        isNotNaN: isNotNaN,
-        isNotNull: isNotNull,
-        isNotNumber: isNotNumber,
-        isNotNumeric: isNotNumeric,
-        isNotString: isNotString,
-        isNotUndefined: isNotUndefined,
-        isNull: isNull,
-        isNumber: isNumber,
-        isNumeric: isNumeric,
-        isOdd: isOdd,
-        isPositive: isPositive,
-        isString: isStringValue,
-        isTruthy: isTruthy,
-        isUndefined: isUndefined,
-        lengthEquals: lengthEquals,
-        lengthNotEquals: lengthNotEquals,
-        lessThan: lessThan,
-        lessThanOrEquals: lessThanOrEquals,
-        longerThan: longerThan,
-        longerThanOrEquals: longerThanOrEquals,
-        lt: lessThan,
-        lte: lessThanOrEquals,
-        matches: matches,
-        notEquals: notEquals,
-        notInside: notInside,
-        notMatches: notMatches,
-        numberEquals: numberEquals,
-        numberNotEquals: numberNotEquals,
-        shorterThan: shorterThan,
-        shorterThanOrEquals: shorterThanOrEquals,
-        startsWith: startsWith
-    };
-}
-
-var baseRules = rules();
-function getRule(ruleName) {
-    var _a;
-    return ((_a = baseRules[ruleName]) !== null && _a !== void 0 ? _a : compounds[ruleName] // eslint-disable-line import/namespace
-    );
-}
-
-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;
-}
-
-/**
- * Transform the result of a rule into a standard format
- */
-function transformResult(result, ruleName, value) {
-    var args = [];
-    for (var _i = 3; _i < arguments.length; _i++) {
-        args[_i - 3] = arguments[_i];
-    }
-    var defaultResult = getDefaultResult(value);
-    validateResult(result);
-    // if result is boolean
-    if (isBoolean(result)) {
-        return {
-            pass: result
-        };
-    }
-    else {
-        return __assign(__assign(__assign({}, defaultResult), { pass: result.pass }), (result.message && {
-            message: optionalFunctionValue.apply(void 0, __spreadArray([result.message,
-                ruleName,
-                value], args))
-        }));
-    }
-}
-function validateResult(result) {
-    // if result is boolean, or if result.pass is boolean
-    if (isBoolean(result) || (result && isBoolean(result.pass))) {
-        return;
-    }
-    {
-        throwError('Incorrect return value for rule: ' + JSON.stringify(result));
-    }
-}
-function getDefaultResult(value) {
-    return {
-        message: "invalid " + typeof value + " value"
-    };
-}
-
-function EnforceBase(value) {
-    var proxy = new Proxy({}, {
-        get: function (_, ruleName) {
-            var rule = getRule(ruleName);
-            if (rule) {
-                return function () {
-                    var args = [];
-                    for (var _i = 0; _i < arguments.length; _i++) {
-                        args[_i] = arguments[_i];
-                    }
-                    var transformedResult = transformResult.apply(void 0, __spreadArray([rule.apply(void 0, __spreadArray([value], args)), ruleName,
-                        value], args));
-                    if (!transformedResult.pass) {
-                        if (isEmpty(transformedResult.message)) {
-                            throwError("enforce/" + ruleName + " failed with " + JSON.stringify(value));
-                        }
-                        else {
-                            throw transformedResult.message;
-                        }
-                    }
-                    return proxy;
-                };
-            }
-        }
-    });
-    return proxy;
-}
-var enforce = new Proxy(EnforceBase, {
-    get: function (_, key) {
-        var registeredRules = [];
-        if (key === 'extend') {
-            return function extend(customRules) {
-                assign(baseRules, customRules);
-            };
-        }
-        if (!getRule(key)) {
-            return;
-        }
-        return addRegisteredRule(key);
-        function addRegisteredRule(ruleName) {
-            return function () {
-                var args = [];
-                for (var _i = 0; _i < arguments.length; _i++) {
-                    args[_i] = arguments[_i];
-                }
-                var rule = getRule(ruleName);
-                registeredRules.push(function (value) {
-                    return transformResult.apply(void 0, __spreadArray([rule.apply(void 0, __spreadArray([value], args)), ruleName, value], args));
-                });
-                var proxy = new Proxy({}, {
-                    get: function (_, key) {
-                        if (getRule(key)) {
-                            return addRegisteredRule(key);
-                        }
-                        if (key === 'run') {
-                            return function (value) {
-                                var _a;
-                                return ((_a = mapFirst(registeredRules, function (rule, breakout) {
-                                    var res = rule(value);
-                                    if (!res.pass) {
-                                        breakout(res);
-                                    }
-                                })) !== null && _a !== void 0 ? _a : passing());
-                            };
-                        }
-                        if (key === 'test') {
-                            return function (value) { return proxy.run(value).pass; };
-                        }
-                    }
-                });
-                return proxy;
-            };
-        }
-    }
-});
-
-function asArray(possibleArg) {
-    return [].concat(possibleArg);
-}
-
-/**
- * @returns a unique numeric id.
- */
-var genId = (function (n) { return function () {
-    return "" + n++;
-}; })(0);
-
-function createState(onStateChange) {
-    var state = {
-        references: []
-    };
-    var registrations = [];
-    return {
-        registerStateKey: registerStateKey,
-        reset: reset
-    };
-    /**
-     * Registers a new key in the state, takes the initial value (may be a function that returns the initial value), returns a function.
-     *
-     * @example
-     *
-     * const useColor = state.registerStateKey("blue");
-     *
-     * let [color, setColor] = useColor(); // -> ["blue", Function]
-     *
-     * setColor("green");
-     *
-     * useColor()[0]; -> "green"
-     */
-    function registerStateKey(initialState, onUpdate) {
-        var key = registrations.length;
-        registrations.push([initialState, onUpdate]);
-        return initKey(key, initialState);
-    }
-    function reset() {
-        state.references = [];
-        registrations.forEach(function (_a, index) {
-            var initialValue = _a[0];
-            return initKey(index, initialValue);
-        });
-    }
-    function initKey(key, initialState) {
-        current().push();
-        set(key, optionalFunctionValue(initialState));
-        return function useStateKey() {
-            return [
-                current()[key],
-                function (nextState) {
-                    return set(key, optionalFunctionValue(nextState, current()[key]));
-                },
-            ];
-        };
-    }
-    function current() {
-        return state.references;
-    }
-    function set(index, value) {
-        var prevValue = state.references[index];
-        state.references[index] = value;
-        var _a = registrations[index], onUpdate = _a[1];
-        if (isFunction(onUpdate)) {
-            onUpdate(value, prevValue);
-        }
-        if (isFunction(onStateChange)) {
-            onStateChange();
-        }
-    }
-}
-
-function createStateRef(state, _a) {
-    var suiteId = _a.suiteId;
-    return {
-        carryOverTests: state.registerStateKey(function () { return []; }),
-        lagging: state.registerStateKey(function () { return []; }),
-        optionalFields: state.registerStateKey(function () { return ({}); }),
-        pending: state.registerStateKey(function () { return []; }),
-        skippedTests: state.registerStateKey(function () { return []; }),
-        suiteId: state.registerStateKey(function () { return suiteId; }),
-        testCallbacks: state.registerStateKey(function () { return ({
-            fieldCallbacks: {},
-            doneCallbacks: []
-        }); }),
-        testObjects: state.registerStateKey(function () { return []; })
-    };
-}
-
-function createContext(init) {
-    var storage = { ancestry: [] };
-    return {
-        bind: bind,
-        run: run,
-        use: use,
-        useX: useX
-    };
-    function useX(errorMessage) {
-        var _a;
-        return ((_a = storage.ctx) !== null && _a !== void 0 ? _a : throwError(errorMessage !== null && errorMessage !== void 0 ? errorMessage : 'Context was used after it was closed'));
-    }
-    function run(ctxRef, fn) {
-        var _a;
-        var parentContext = use();
-        var out = __assign(__assign({}, (parentContext ? parentContext : {})), ((_a = init === null || init === void 0 ? void 0 : init(ctxRef, parentContext)) !== null && _a !== void 0 ? _a : ctxRef));
-        var ctx = set(Object.freeze(out));
-        storage.ancestry.unshift(ctx);
-        var res = fn(ctx);
-        clear();
-        return res;
-    }
-    function bind(ctxRef, fn) {
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore - this one's pretty hard to get right
-        var returnedFn = function () {
-            var runTimeArgs = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                runTimeArgs[_i] = arguments[_i];
-            }
-            return run(ctxRef, function () {
-                return fn.apply(void 0, runTimeArgs);
-            });
-        };
-        return returnedFn;
-    }
-    function use() {
-        return storage.ctx;
-    }
-    function set(value) {
-        return (storage.ctx = value);
-    }
-    function clear() {
-        var _a;
-        storage.ancestry.shift();
-        set((_a = storage.ancestry[0]) !== null && _a !== void 0 ? _a : null);
-    }
-}
-
-var ctx = createContext(function (ctxRef, parentContext) {
-    return parentContext
-        ? null
-        : assign({}, {
-            exclusion: {
-                tests: {},
-                groups: {}
-            }
-        }, ctxRef);
-});
-
-/**
- * Creates a cache function
- */
-function createCache(maxSize) {
-    if (maxSize === void 0) { maxSize = 10; }
-    var cacheStorage = [];
-    /**
-     * @param {any[]} deps  dependency array.
-     * @param {Function}    cache action function.
-     */
-    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 (cacheStorage.length > maxSize) {
-            cacheStorage.length = maxSize;
-        }
-        return result;
-    };
-    /**
-     * Retrieves an item from the cache.
-     * @param {deps} deps Dependency array
-     */
-    cache.get = function (deps) {
-        return cacheStorage[cacheStorage.findIndex(function (_a) {
-            var cachedDeps = _a[0];
-            return lengthEquals(deps, cachedDeps.length) &&
-                deps.every(function (dep, i) { return dep === cachedDeps[i]; });
-        })] || null;
-    };
-    return cache;
-}
-
-function useCarryOverTests() {
-    return useStateRef().carryOverTests();
-}
-function usePending() {
-    return useStateRef().pending();
-}
-function useLagging() {
-    return useStateRef().lagging();
-}
-function useSuiteId() {
-    return useStateRef().suiteId();
-}
-function useTestCallbacks() {
-    return useStateRef().testCallbacks();
-}
-function useTestObjects() {
-    return useStateRef().testObjects();
-}
-function useSkippedTests() {
-    return useStateRef().skippedTests();
-}
-function useOptionalFields() {
-    return useStateRef().optionalFields();
-}
-function useStateRef() {
-    return ctx.useX().stateRef;
-}
-
-/**
- * Checks if a given tests, or the suite as a whole still have remaining tests.
- */
-function hasRemainingTests(fieldName) {
-    var pending = usePending()[0];
-    var lagging = useLagging()[0];
-    var allIncomplete = pending.concat(lagging);
-    if (isEmpty(allIncomplete)) {
-        return false;
-    }
-    if (fieldName) {
-        return allIncomplete.some(function (testObject) { return testObject.fieldName === fieldName; });
-    }
-    return isNotEmpty(allIncomplete);
-}
-
-/**
- * Reads the testObjects list and gets full validation result from it.
- */
-function genTestsSummary() {
-    var testObjects = useTestObjects()[0];
-    var skippedTests = useSkippedTests()[0];
-    var summary = {
-        errorCount: 0,
-        groups: {},
-        testCount: 0,
-        tests: {},
-        warnCount: 0
-    };
-    appendSummary(testObjects);
-    appendSummary(skippedTests, true);
-    return countFailures(summary);
-    function appendSummary(testObjects, skipped) {
-        testObjects.forEach(function (testObject) {
-            var fieldName = testObject.fieldName, groupName = testObject.groupName;
-            summary.tests[fieldName] = genTestObject(summary.tests, testObject, skipped);
-            if (groupName) {
-                summary.groups[groupName] = summary.groups[groupName] || {};
-                summary.groups[groupName][fieldName] = genTestObject(summary.groups[groupName], testObject, skipped);
-            }
-        });
-    }
-}
-/**
- * Counts the failed tests and adds global counters
- */
-function countFailures(summary) {
-    for (var test in summary.tests) {
-        summary.errorCount += summary.tests[test].errorCount;
-        summary.warnCount += summary.tests[test].warnCount;
-        summary.testCount += summary.tests[test].testCount;
-    }
-    return summary;
-}
-function genTestObject(summaryKey, testObject, skipped) {
-    var fieldName = testObject.fieldName, isWarning = testObject.isWarning, failed = testObject.failed, message = testObject.message;
-    summaryKey[fieldName] = summaryKey[fieldName] || {
-        errorCount: 0,
-        warnCount: 0,
-        testCount: 0
-    };
-    var testKey = summaryKey[fieldName];
-    if (skipped) {
-        return testKey;
-    }
-    summaryKey[fieldName].testCount++;
-    // Adds to severity group
-    function addTo(countKey, group) {
-        testKey[countKey]++;
-        if (message) {
-            testKey[group] = (testKey[group] || []).concat(message);
-        }
-    }
-    if (failed) {
-        if (isWarning) {
-            addTo('warnCount', 'warnings');
-        }
-        else {
-            addTo('errorCount', 'errors');
-        }
-    }
-    return testKey;
-}
-
-function nonMatchingFieldName(testObject, fieldName) {
-    return !!(fieldName && testObject.fieldName !== fieldName);
-}
-
-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 === 'warnings', testObject.isWarning);
-}
-
-function collectFailureMessages(severity, testObjects, options) {
-    var _a;
-    if (options === void 0) { options = {}; }
-    var _b = options || {}, group = _b.group, fieldName = _b.fieldName;
-    var res = testObjects.reduce(function (collector, testObject) {
-        if (noMatch(testObject, severity, group, fieldName)) {
-            return collector;
-        }
-        if (!testObject.failed) {
-            return collector;
-        }
-        collector[testObject.fieldName] = (collector[testObject.fieldName] || []).concat(testObject.message || []);
-        return collector;
-    }, __assign({}, (fieldName && (_a = {}, _a[fieldName] = [], _a))));
-    return res;
-}
-function noGroupMatch(testObject, groupName) {
-    return !!(groupName && testObject.groupName !== groupName);
-}
-function noMatch(testObject, severity, group, fieldName) {
-    if (noGroupMatch(testObject, group)) {
-        return true;
-    }
-    if (nonMatchingFieldName(testObject, fieldName)) {
-        return true;
-    }
-    if (nonMatchingSeverityProfile(severity, testObject)) {
-        return true;
-    }
-    return false;
-}
-
-function getErrors(fieldName) {
-    return getFailures('errors', fieldName);
-}
-function getWarnings(fieldName) {
-    return getFailures('warnings', fieldName);
-}
-/**
- * @returns suite or field's errors or warnings.
- */
-function getFailures(severityKey, fieldName) {
-    var testObjects = useTestObjects()[0];
-    var failureMessages = collectFailureMessages(severityKey, testObjects, {
-        fieldName: fieldName
-    });
-    if (fieldName) {
-        return failureMessages[fieldName];
-    }
-    return failureMessages;
-}
-
-function getErrorsByGroup(groupName, fieldName) {
-    var errors = getByGroup('errors', groupName, fieldName);
-    if (fieldName) {
-        return errors[fieldName];
-    }
-    return errors;
-}
-function getWarningsByGroup(groupName, fieldName) {
-    var errors = getByGroup('warnings', groupName, fieldName);
-    if (fieldName) {
-        return errors[fieldName];
-    }
-    return errors;
-}
-/**
- * Gets failure messages by group.
- */
-function getByGroup(severityKey, group, fieldName) {
-    if (!group) {
-        throwError("get" + severityKey[0].toUpperCase() + severityKey.slice(1) + "ByGroup requires a group name. Received `" + group + "` instead.");
-    }
-    var testObjects = useTestObjects()[0];
-    var failureMessages = collectFailureMessages(severityKey, testObjects, {
-        group: group,
-        fieldName: fieldName
-    });
-    return failureMessages;
-}
-
-/**
- * Determines whether a certain test profile has failures.
- */
-function hasFailuresLogic(testObject, severityKey, fieldName) {
-    if (!testObject.failed) {
-        return false;
-    }
-    if (nonMatchingFieldName(testObject, fieldName)) {
-        return false;
-    }
-    if (nonMatchingSeverityProfile(severityKey, testObject)) {
-        return false;
-    }
-    return true;
-}
-
-function hasErrors(fieldName) {
-    return has('errors', fieldName);
-}
-function hasWarnings(fieldName) {
-    return has('warnings', fieldName);
-}
-function has(severityKey, fieldName) {
-    var testObjects = useTestObjects()[0];
-    return testObjects.some(function (testObject) {
-        return hasFailuresLogic(testObject, severityKey, fieldName);
-    });
-}
-
-function hasErrorsByGroup(groupName, fieldName) {
-    return hasByGroup('errors', groupName, fieldName);
-}
-function hasWarningsByGroup(groupName, fieldName) {
-    return hasByGroup('warnings', groupName, fieldName);
-}
-/**
- * Checks whether there are failures in a given group.
- */
-function hasByGroup(severityKey, group, fieldName) {
-    var testObjects = useTestObjects()[0];
-    return testObjects.some(function (testObject) {
-        if (group !== testObject.groupName) {
-            return false;
-        }
-        return hasFailuresLogic(testObject, severityKey, fieldName);
-    });
-}
-
-function isValid(result) {
-    if (result.hasErrors()) {
-        return false;
-    }
-    var testObjects = useTestObjects()[0];
-    if (isEmpty(testObjects)) {
-        return false;
-    }
-    var pending = usePending()[0];
-    var lagging = useLagging()[0];
-    if (isNotEmpty(pending.concat(lagging).filter(function (testObject) { return !testObject.isWarning; }))) {
-        return false;
-    }
-    return noMissingRequiredTestRuns(result);
-}
-function noMissingRequiredTestRuns(result) {
-    var optionalFields = useOptionalFields()[0];
-    for (var test in result.tests) {
-        if (!optionalFields[test] && result.tests[test].testCount === 0) {
-            return false;
-        }
-    }
-    return true;
-}
-
-var cache$1 = createCache(20);
-function produceDraft() {
-    var testObjects = useTestObjects()[0];
-    var ctxRef = { stateRef: useStateRef() };
-    return cache$1([testObjects], ctx.bind(ctxRef, function () {
-        return __assign(__assign({}, genTestsSummary()), { getErrors: ctx.bind(ctxRef, getErrors), getErrorsByGroup: ctx.bind(ctxRef, getErrorsByGroup), getWarnings: ctx.bind(ctxRef, getWarnings), getWarningsByGroup: ctx.bind(ctxRef, getWarningsByGroup), hasErrors: ctx.bind(ctxRef, hasErrors), hasErrorsByGroup: ctx.bind(ctxRef, hasErrorsByGroup), hasWarnings: ctx.bind(ctxRef, hasWarnings), hasWarningsByGroup: ctx.bind(ctxRef, hasWarningsByGroup), isValid: ctx.bind(ctxRef, function () { return isValid(produceDraft()); }) });
-    }));
-}
-
-var cache = createCache(20);
-function produceFullResult() {
-    var testObjects = useTestObjects()[0];
-    var ctxRef = { stateRef: useStateRef() };
-    return cache([testObjects], ctx.bind(ctxRef, function () {
-        return assign({}, produceDraft(), {
-            done: ctx.bind(ctxRef, done)
-        });
-    }));
-}
-function shouldSkipDoneRegistration(callback, fieldName, output) {
-    // If we do not have any test runs for the current field
-    return !!(!isFunction(callback) ||
-        (fieldName &&
-            (!output.tests[fieldName] || output.tests[fieldName].testCount === 0)));
-}
-function shouldRunDoneCallback(fieldName) {
-    // is suite finished || field name exists, and test is finished;
-    return !!(!hasRemainingTests() ||
-        (fieldName && !hasRemainingTests(fieldName)));
-}
-/**
- * Registers done callbacks.
- * @register {Object} Vest output object.
- */
-var done = function done() {
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-    }
-    var _a = args.reverse(), callback = _a[0], fieldName = _a[1];
-    var stateRef = useStateRef();
-    var output = produceFullResult();
-    if (shouldSkipDoneRegistration(callback, fieldName, output)) {
-        return output;
-    }
-    var deferredCallback = ctx.bind({ stateRef: stateRef }, function () {
-        return callback(produceDraft());
-    });
-    if (shouldRunDoneCallback(fieldName)) {
-        deferredCallback();
-        return output;
-    }
-    var _b = useTestCallbacks(), setTestCallbacks = _b[1];
-    setTestCallbacks(function (current) {
-        if (fieldName) {
-            current.fieldCallbacks[fieldName] = (current.fieldCallbacks[fieldName] || []).concat(deferredCallback);
-        }
-        else {
-            current.doneCallbacks.push(deferredCallback);
-        }
-        return current;
-    });
-    return output;
-};
-
-function create(suiteCallback) {
-    if (!isFunction(suiteCallback)) {
-        throwError('Suite initialization error. Expected `tests` to be a function.');
-    }
-    var handlers = [];
-    var state = createState(function () {
-        handlers.forEach(function (fn) {
-            return fn({
-                suiteState: stateRef,
-                type: 'suiteStateUpdate'
-            });
-        });
-    });
-    var stateRef = createStateRef(state, { suiteId: genId() });
-    var suite = assign(ctx.bind({ stateRef: stateRef }, function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        var previousTestObjects = useTestObjects()[0];
-        var _a = useCarryOverTests(), setCarryOverTests = _a[1];
-        var pending = usePending()[0];
-        var _b = useLagging(), prevLagging = _b[0], setLagging = _b[1];
-        state.reset();
-        setCarryOverTests(function () { return previousTestObjects; });
-        // Move all the active pending tests to the lagging array
-        setLagging(pending.concat(prevLagging));
-        // Run the consumer's callback
-        suiteCallback.apply(void 0, args);
-        var res = produceFullResult();
-        return res;
-    }), {
-        get: ctx.bind({ stateRef: stateRef }, produceDraft),
-        remove: ctx.bind({ stateRef: stateRef }, function (name) {
-            var testObjects = useTestObjects()[0];
-            // We're mutating the array in `cancel`, so we have to first copy it.
-            asArray(testObjects).forEach(function (testObject) {
-                if (testObject.fieldName === name) {
-                    testObject.cancel();
-                }
-            });
-        }),
-        reset: state.reset,
-        subscribe: function (handler) {
-            if (!isFunction(handler))
-                return;
-            handlers.push(handler);
-            handler({
-                type: 'suiteSubscribeInit',
-                suiteState: stateRef
-            });
-        }
-    });
-    return suite;
-}
-
-/**
- * Error message to display when a hook was called outside of context.
- */
-var ERROR_HOOK_CALLED_OUTSIDE = 'hook called outside of a running suite.';
-
-/**
- * Adds a field or multiple fields to inclusion group.
- */
-function only(item) {
-    return addTo('only', 'tests', item);
-}
-only.group = function (item) { return addTo('only', 'groups', item); };
-/**
- * Adds a field or multiple fields to exclusion group.
- * @param {String[]|String} item Item to be added to exclusion group.
- */
-function skip(item) {
-    return addTo('skip', 'tests', item);
-}
-skip.group = function (item) { return addTo('skip', 'groups', item); };
-//Checks whether a certain test profile excluded by any of the exclusion groups.
-// eslint-disable-next-line complexity
-function isExcluded(testObject) {
-    var fieldName = testObject.fieldName, groupName = testObject.groupName;
-    var context = ctx.useX();
-    var exclusion = context.exclusion;
-    var keyTests = exclusion.tests;
-    var testValue = keyTests[fieldName];
-    // if test is skipped
-    // no need to proceed
-    if (testValue === false) {
-        return true;
-    }
-    var isTestIncluded = testValue === true;
-    // If inside a group
-    if (groupName) {
-        if (isGroupExcluded(groupName)) {
-            return true; // field excluded by group
-            // if group is `only`ed
-        }
-        else if (exclusion.groups[groupName] === true) {
-            if (isTestIncluded) {
-                return false;
-            }
-            // If there is _ANY_ `only`ed test (and we already know this one isn't)
-            if (hasIncludedTests(keyTests)) {
-                return true; // Excluded implicitly
-            }
-            return keyTests[fieldName] === false;
-        }
-    }
-    // if field is only'ed
-    if (isTestIncluded) {
-        return false;
-    }
-    // If there is _ANY_ `only`ed test (and we already know this one isn't) return true
-    // Otherwise return false
-    return hasIncludedTests(keyTests);
-}
-/**
- * Checks whether a given group is excluded from running.
- * @param {String} groupName
- * @return {Boolean}
- */
-function isGroupExcluded(groupName) {
-    var context = ctx.useX();
-    var exclusion = context.exclusion;
-    var keyGroups = exclusion.groups;
-    var groupPresent = hasOwnProperty(keyGroups, groupName);
-    // When group is either only'ed or skipped
-    if (groupPresent) {
-        // Return true if group is skipped and false if only'ed
-        return keyGroups[groupName] === false;
-    }
-    // Group is not present
-    for (var group in keyGroups) {
-        // If any other group is only'ed
-        if (keyGroups[group] === true) {
-            return true;
-        }
-    }
-    return false;
-}
-/**
- * Adds fields to a specified exclusion group.
- */
-function addTo(exclusionGroup, itemType, item) {
-    var context = ctx.useX(ERROR_HOOK_CALLED_OUTSIDE);
-    if (!item) {
-        return;
-    }
-    asArray(item).forEach(function (itemName) {
-        if (!isStringValue(itemName)) {
-            return;
-        }
-        context.exclusion[itemType][itemName] = exclusionGroup === 'only';
-    });
-}
-/**
- * Checks if context has included tests
- */
-function hasIncludedTests(keyTests) {
-    for (var test in keyTests) {
-        if (keyTests[test] === true) {
-            return true; // excluded implicitly
-        }
-    }
-    return false;
-}
-
-/**
- * @type {String} Error message to display when `warn` gets called outside of a test.
- */
-var ERROR_OUTSIDE_OF_TEST = "warn hook called outside of a test callback. It won't have an effect."
-    ;
-/**
- * Sets a running test to warn only mode.
- */
-function warn() {
-    var ctx$1 = ctx.useX('warn ' + ERROR_HOOK_CALLED_OUTSIDE);
-    if (!ctx$1.currentTest) {
-        throwError(ERROR_OUTSIDE_OF_TEST);
-        return;
-    }
-    ctx$1.currentTest.warn();
-}
-
-/**
- * Runs a group callback.
- */
-function group(groupName, tests) {
-    if (!isStringValue(groupName)) {
-        throwGroupError(groupName);
-    }
-    if (!isFunction(tests)) {
-        throwGroupError(tests);
-    }
-    // Running with the context applied
-    ctx.bind({ groupName: groupName }, tests)();
-}
-function throwGroupError(value) {
-    throwError("group initialization error. Expected \"" + value + "\" to be a string."
-        );
-}
-
-function optional(optionals) {
-    var _a = useOptionalFields(), setOptionalFields = _a[1];
-    setOptionalFields(function (state) {
-        asArray(optionals).forEach(function (optionalField) {
-            state[optionalField] = true;
-        });
-        return state;
-    });
-}
-
-/**
- * Removes first found element from array
- * WARNING: Mutates array
- */
-function removeElementFromArray(array, element) {
-    var index = array.indexOf(element);
-    if (index !== -1) {
-        array.splice(index, 1);
-    }
-    return array;
-}
-
-function isSameProfileTest(testObject1, testObject2) {
-    return (testObject1.fieldName === testObject2.fieldName &&
-        testObject1.groupName === testObject2.groupName);
-}
-
-/**
- * Sets a test as pending in the state.
- */
-function setPending(testObject) {
-    var _a = useLagging(), lagging = _a[0], setLagging = _a[1];
-    var _b = usePending(), setPending = _b[1];
-    var nextLagging = asArray(lagging).reduce(function (lagging, laggingTestObject) {
-        /**
-         * If the test is of the same profile
-         * (same name + same group) we cancel
-         * it. Otherwise, it is lagging.
-         */
-        if (isSameProfileTest(testObject, laggingTestObject) &&
-            // This last case handles memoized tests
-            // because that retain their od across runs
-            laggingTestObject.id !== testObject.id) {
-            laggingTestObject.cancel();
-        }
-        else {
-            lagging.push(laggingTestObject);
-        }
-        return lagging;
-    }, []);
-    setLagging(function () { return nextLagging; });
-    setPending(function (pending) { return pending.concat(testObject); });
-}
-/**
- * Removes a tests from the pending and lagging arrays.
- */
-function removePending(testObject) {
-    var _a = usePending(), setPending = _a[1];
-    var _b = useLagging(), setLagging = _b[1];
-    setPending(function (setPending) { return removeElementFromArray(setPending, testObject); });
-    setLagging(function (lagging) { return removeElementFromArray(lagging, testObject); });
-}
-
-/**
- * Removes test object from suite state
- */
-function removeTestFromState (testObject) {
-    var _a = useTestObjects(), setTestObjects = _a[1];
-    setTestObjects(function (testObjects) {
-        // using asArray to clear the cache.
-        return asArray(removeElementFromArray(testObjects, testObject));
-    });
-}
-
-var VestTest = /** @class */ (function () {
-    function VestTest(fieldName, testFn, _a) {
-        var _b = _a === void 0 ? {} : _a, message = _b.message, groupName = _b.groupName;
-        this.id = genId();
-        this.failed = false;
-        this.isWarning = false;
-        this.canceled = false;
-        this.fieldName = fieldName;
-        this.testFn = testFn;
-        if (groupName) {
-            this.groupName = groupName;
-        }
-        if (message) {
-            this.message = message;
-        }
-    }
-    VestTest.prototype.run = function () {
-        var result;
-        try {
-            result = this.testFn();
-        }
-        catch (error) {
-            if (isUndefined(this.message) && isStringValue(error)) {
-                this.message = error;
-            }
-            result = false;
-        }
-        if (result === false) {
-            this.fail();
-        }
-        return result;
-    };
-    VestTest.prototype.fail = function () {
-        this.failed = true;
-    };
-    VestTest.prototype.warn = function () {
-        this.isWarning = true;
-    };
-    VestTest.prototype.cancel = function () {
-        this.canceled = true;
-        removePending(this);
-        removeTestFromState(this);
-    };
-    VestTest.prototype.valueOf = function () {
-        return this.failed !== true;
-    };
-    return VestTest;
-}());
-
-function partition(array, predicate) {
-    return array.reduce(function (partitions, value, number) {
-        partitions[predicate(value, number, array) ? 0 : 1].push(value);
-        return partitions;
-    }, [[], []]);
-}
-
-function mergeCarryOverTests(testObject) {
-    var _a = useCarryOverTests(), carryOverTests = _a[0], setCarryOverTests = _a[1];
-    var _b = useTestObjects(), setTestObjects = _b[1];
-    var _c = partition(carryOverTests, function (carryOverTest) { return isSameProfileTest(carryOverTest, testObject); }), moveToTestObjects = _c[0], keepInCarryOvers = _c[1];
-    setCarryOverTests(function () { return keepInCarryOvers; });
-    setTestObjects(function (testObjects) { return testObjects.concat(moveToTestObjects); });
-}
-
-function isPromise(value) {
-    return value && isFunction(value.then);
-}
-
-/**
- * Stores test object inside suite state.
- */
-var addTestToState = (function (testObject) {
-    var _a = useTestObjects(), setTestObjects = _a[1];
-    setTestObjects(function (testObjects) { return testObjects.concat(testObject); });
-});
-
-function callEach(arr) {
-    return arr.forEach(function (fn) { return fn(); });
-}
-
-/**
- * Runs async test.
- */
-function runAsyncTest(testObject) {
-    var asyncTest = testObject.asyncTest, message = testObject.message;
-    if (!isPromise(asyncTest))
-        return;
-    var stateRef = useStateRef();
-    var done = ctx.bind({ stateRef: stateRef }, function () {
-        removePending(testObject);
-        // This is for cases in which the suite state was already reset
-        if (testObject.canceled) {
-            return;
-        }
-        // Perform required done callback calls and cleanups after the test is finished
-        runDoneCallbacks(testObject.fieldName);
-    });
-    var fail = ctx.bind({ stateRef: stateRef }, function (rejectionMessage) {
-        testObject.message = isStringValue(rejectionMessage)
-            ? rejectionMessage
-            : message;
-        testObject.fail();
-        // Spreading the array to invalidate the cache
-        var _a = useTestObjects(), setTestObjects = _a[1];
-        setTestObjects(function (testObjects) { return testObjects.slice(); });
-        done();
-    });
-    try {
-        asyncTest.then(done, fail);
-    }
-    catch (e) {
-        fail();
-    }
-}
-/**
- * Runs done callback when async tests are finished running.
- */
-function runDoneCallbacks(fieldName) {
-    var _a = useTestCallbacks()[0], fieldCallbacks = _a.fieldCallbacks, doneCallbacks = _a.doneCallbacks;
-    if (fieldName) {
-        if (!hasRemainingTests(fieldName) &&
-            Array.isArray(fieldCallbacks[fieldName])) {
-            callEach(fieldCallbacks[fieldName]);
-        }
-    }
-    if (!hasRemainingTests()) {
-        callEach(doneCallbacks);
-    }
-}
-
-/**
- * Runs sync tests - or extracts promise.
- */
-function runSyncTest(testObject) {
-    return ctx.run({ currentTest: testObject }, function () {
-        var result;
-        try {
-            result = testObject.testFn();
-        }
-        catch (e) {
-            if (isUndefined(testObject.message) && isStringValue(e)) {
-                testObject.message = e;
-            }
-            result = false;
-        }
-        if (result === false) {
-            testObject.fail();
-        }
-        return result;
-    });
-}
-
-/**
- * Registers test, if async - adds to pending array
- */
-function registerTest(testObject) {
-    addTestToState(testObject);
-    // Run test callback.
-    // If a promise is returned, set as async and
-    // Move to pending list.
-    var result = runSyncTest(testObject);
-    try {
-        // try catch for safe property access
-        // in case object is an enforce chain
-        if (isPromise(result)) {
-            testObject.asyncTest = result;
-            setPending(testObject);
-            runAsyncTest(testObject);
-        }
-    }
-    catch (_a) {
-        {
-            throwError("Your test function " + testObject.fieldName + " returned " + JSON.stringify(result) + ". Only \"false\" or a Promise are supported. Return values may cause unexpected behavior.");
-        }
-    }
-}
-
-/* eslint-disable jest/no-export */
-function bindTestEach(test) {
-    /**
-     * Run multiple tests using a parameter table
-     */
-    function each(table) {
-        if (!Array.isArray(table)) {
-            throwError('test.each: Expected table to be an array.');
-        }
-        function eachReturn(fieldName) {
-            var args = [];
-            for (var _i = 1; _i < arguments.length; _i++) {
-                args[_i - 1] = arguments[_i];
-            }
-            var _a = args.reverse(), testFn = _a[0], message = _a[1];
-            return table.map(function (item) {
-                item = asArray(item);
-                return test(optionalFunctionValue.apply(void 0, __spreadArray([fieldName], item)), optionalFunctionValue.apply(void 0, __spreadArray([message], item)), function () { return testFn.apply(void 0, item); });
-            });
-        }
-        return eachReturn;
-    }
-    return each;
-}
-
-/* eslint-disable jest/no-export */
-function bindTestMemo(test) {
-    var cache = createCache(100); // arbitrary cache size
-    function memo(fieldName) {
-        var args = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            args[_i - 1] = arguments[_i];
-        }
-        var suiteId = useSuiteId()[0];
-        var _a = args.reverse(), deps = _a[0], testFn = _a[1], msg = _a[2];
-        // Implicit dependency for more specificity
-        var dependencies = [suiteId, fieldName].concat(deps);
-        var cached = cache.get(dependencies);
-        if (isNull(cached)) {
-            // Cache miss. Start fresh
-            return cache(dependencies, function () { return test(fieldName, msg, testFn); });
-        }
-        var testObject = cached[1];
-        if (isExcluded(testObject)) {
-            return testObject;
-        }
-        addTestToState(testObject);
-        if (testObject && isPromise(testObject.asyncTest)) {
-            setPending(testObject);
-            runAsyncTest(testObject);
-        }
-        return testObject;
-    }
-    return memo;
-}
-
-function testBase(fieldName) {
-    var args = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        args[_i - 1] = arguments[_i];
-    }
-    var _a = args.reverse(), testFn = _a[0], message = _a[1];
-    var _b = useSkippedTests(), setSkippedTests = _b[1];
-    var context = ctx.use();
-    var testObject = new VestTest(fieldName, testFn, {
-        message: message,
-        groupName: context === null || context === void 0 ? void 0 : context.groupName
-    });
-    if (isExcluded(testObject)) {
-        setSkippedTests(function (skippedTests) { return skippedTests.concat(testObject); });
-        mergeCarryOverTests(testObject);
-        return testObject;
-    }
-    if (!isFunction(testFn)) {
-        return testObject;
-    }
-    registerTest(testObject);
-    return testObject;
-}
-var test = assign(testBase, {
-    each: bindTestEach(testBase),
-    memo: bindTestMemo(testBase)
-});
-
-var VERSION = "3.2.8-dev-6d7c74";
-
-export { VERSION, create, enforce, group, only, optional, skip, test, warn };