vest 4.2.1 → 4.3.0

package/dist/es/vest.development.js

@@ -447,16 +447,18 @@ var STATUS_PENDING = 'PENDING';
 var STATUS_CANCELED = 'CANCELED';
 var STATUS_OMITTED = 'OMITTED';
 
-/**
- * Throws a timed out error.
- */
-function throwError(devMessage, productionMessage) {
-    throw new Error(devMessage );
-}
-function throwErrorDeferred(devMessage, productionMessage) {
-    setTimeout(function () {
-        throwError(devMessage);
-    }, 0);
+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
@@ -546,6 +548,12 @@ function isNullish(value) {
     return isNull(value) || isUndefined(value);
 }
 
+function deferThrow(message) {
+    setTimeout(function () {
+        throw new Error(message);
+    }, 0);
+}
+
 function usePath() {
     var context$1 = context.useX();
     return context$1.testCursor.getCursor();
@@ -591,7 +599,7 @@ function useRetainTestKey(key, testObject) {
         current[key] = testObject;
     }
     else {
-        throwErrorDeferred("Encountered the same test key \"".concat(key, "\" twice. This may lead to tests overriding each other's results, or to tests being unexpectedly omitted."));
+        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."));
     }
 }
 
@@ -624,6 +632,140 @@ var Severity;
     Severity["WARNINGS"] = "warnings";
     Severity["ERRORS"] = "errors";
 })(Severity || (Severity = {}));
+var SeverityCount;
+(function (SeverityCount) {
+    SeverityCount["ERROR_COUNT"] = "errorCount";
+    SeverityCount["WARN_COUNT"] = "warnCount";
+})(SeverityCount || (SeverityCount = {}));
+
+/**
+ * A safe hasOwnProperty access
+ */
+function hasOwnProperty(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+function isNumber(value) {
+    return Boolean(typeof value === 'number');
+}
+
+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 nonMatchingFieldName(testObject, fieldName) {
+    return !!fieldName && !matchingFieldName(testObject, fieldName);
+}
+function matchingFieldName(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 === Severity.WARNINGS, testObject.warns());
+}
+
+/**
+ * Determines whether a certain test profile has failures.
+ */
+function hasFailuresLogic(testObject, severityKey, fieldName) {
+    if (!testObject.hasFailures()) {
+        return false;
+    }
+    if (nonMatchingFieldName(testObject, fieldName)) {
+        return false;
+    }
+    if (nonMatchingSeverityProfile(severityKey, testObject)) {
+        return false;
+    }
+    return true;
+}
+
+function hasErrors(fieldName) {
+    return has(Severity.ERRORS, fieldName);
+}
+function hasWarnings(fieldName) {
+    return has(Severity.WARNINGS, fieldName);
+}
+function has(severityKey, fieldName) {
+    var testObjects = useTestsFlat();
+    return testObjects.some(function (testObject) {
+        return hasFailuresLogic(testObject, severityKey, fieldName);
+    });
+}
+
+// eslint-disable-next-line max-statements, complexity
+function isValid(fieldName) {
+    if (fieldIsOmitted(fieldName)) {
+        return true;
+    }
+    if (hasErrors(fieldName)) {
+        return false;
+    }
+    var testObjects = useTestsFlat();
+    if (isEmpty(testObjects)) {
+        return false;
+    }
+    if (fieldDoesNotExist(fieldName)) {
+        return false;
+    }
+    if (hasNonOptionalIncomplete(fieldName)) {
+        return false;
+    }
+    return noMissingTests(fieldName);
+}
+function fieldIsOmitted(fieldName) {
+    var omittedFields = useOmittedFields();
+    if (!fieldName) {
+        return false;
+    }
+    return !!omittedFields[fieldName];
+}
+function hasNonOptionalIncomplete(fieldName) {
+    var optionalFields = useOptionalFields()[0];
+    return isNotEmpty(useAllIncomplete().filter(function (testObject) {
+        if (nonMatchingFieldName(testObject, fieldName)) {
+            return false;
+        }
+        return optionalFields[testObject.fieldName] !== true;
+    }));
+}
+function fieldDoesNotExist(fieldName) {
+    var testObjects = useTestsFlat();
+    return (!!fieldName &&
+        !testObjects.find(function (testObject) { return testObject.fieldName === fieldName; }));
+}
+function noMissingTests(fieldName) {
+    var testObjects = useTestsFlat();
+    var optionalFields = useOptionalFields()[0];
+    return testObjects.every(function (testObject) {
+        if (nonMatchingFieldName(testObject, fieldName)) {
+            return true;
+        }
+        return (optionalFields[testObject.fieldName] === true ||
+            testObject.isTested() ||
+            testObject.isOmitted());
+    });
+}
 
 /**
  * Reads the testObjects list and gets full validation result from it.
@@ -632,20 +774,35 @@ function genTestsSummary() {
     var testObjects = useTestsFlat();
     var summary = assign(baseStats(), {
         groups: {},
-        tests: {}
+        tests: {},
+        valid: false
     });
-    appendSummary(testObjects);
+    testObjects.reduce(function (summary, testObject) {
+        appendToTest(summary.tests, testObject);
+        appendToGroup(summary.groups, testObject);
+        return summary;
+    }, summary);
+    summary.valid = isValid();
     return countFailures(summary);
-    function appendSummary(testObjects) {
-        testObjects.forEach(function (testObject) {
-            var fieldName = testObject.fieldName, groupName = testObject.groupName;
-            summary.tests[fieldName] = genTestObject(summary.tests, testObject);
-            if (groupName) {
-                summary.groups[groupName] = summary.groups[groupName] || {};
-                summary.groups[groupName][fieldName] = genTestObject(summary.groups[groupName], testObject);
-            }
-        });
+}
+function appendToTest(tests, testObject) {
+    tests[testObject.fieldName] = appendTestObject(tests, testObject);
+    // If `valid` is false to begin with, keep it that way. Otherwise, assess.
+    tests[testObject.fieldName].valid =
+        tests[testObject.fieldName].valid === false
+            ? false
+            : isValid(testObject.fieldName);
+}
+/**
+ * Appends to a group object if within a group
+ */
+function appendToGroup(groups, testObject) {
+    var groupName = testObject.groupName;
+    if (!groupName) {
+        return;
     }
+    groups[groupName] = groups[groupName] || {};
+    groups[groupName][testObject.fieldName] = appendTestObject(groups[groupName], testObject);
 }
 /**
  * Counts the failed tests and adds global counters
@@ -658,29 +815,36 @@ function countFailures(summary) {
     }
     return summary;
 }
+/**
+ * Appends the test to a results object
+ */
 // eslint-disable-next-line max-statements
-function genTestObject(summaryKey, testObject) {
+function appendTestObject(summaryKey, testObject) {
     var fieldName = testObject.fieldName, message = testObject.message;
     summaryKey[fieldName] = summaryKey[fieldName] || baseStats();
     var testKey = summaryKey[fieldName];
     if (testObject.isNonActionable())
         return testKey;
     summaryKey[fieldName].testCount++;
-    // Adds to severity group
-    function addTo(severity) {
-        var countKey = severity === Severity.ERRORS ? 'errorCount' : 'warnCount';
-        testKey[countKey]++;
-        if (message) {
-            testKey[severity] = (testKey[severity] || []).concat(message);
-        }
-    }
     if (testObject.isFailing()) {
-        addTo(Severity.ERRORS);
+        incrementFailures(Severity.ERRORS);
     }
     else if (testObject.isWarning()) {
-        addTo(Severity.WARNINGS);
+        incrementFailures(Severity.WARNINGS);
     }
     return testKey;
+    function incrementFailures(severity) {
+        var countKey = getCountKey(severity);
+        testKey[countKey]++;
+        if (message) {
+            testKey[severity] = (testKey[severity] || []).concat(message);
+        }
+    }
+}
+function getCountKey(severity) {
+    return severity === Severity.ERRORS
+        ? SeverityCount.ERROR_COUNT
+        : SeverityCount.WARN_COUNT;
 }
 function baseStats() {
     return {
@@ -726,24 +890,6 @@ function __spreadArray(to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 }
 
-function nonMatchingFieldName(testObject, fieldName) {
-    return !!fieldName && !matchingFieldName(testObject, fieldName);
-}
-function matchingFieldName(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 === Severity.WARNINGS, testObject.warns());
-}
-
 function collectFailureMessages(severity, testObjects, options) {
     var _a;
     if (options === void 0) { options = {}; }
@@ -811,9 +957,7 @@ function getWarningsByGroup(groupName, fieldName) {
  * Gets failure messages by group.
  */
 function getByGroup(severityKey, group, fieldName) {
-    if (!group) {
-        throwError("get".concat(severityKey[0].toUpperCase()).concat(severityKey.slice(1), "ByGroup requires a group name. Received `").concat(group, "` instead."));
-    }
+    invariant(group, "get".concat(severityKey[0].toUpperCase()).concat(severityKey.slice(1), "ByGroup requires a group name. Received `").concat(group, "` instead."));
     var testObjects = useTestsFlat();
     return collectFailureMessages(severityKey, testObjects, {
         group: group,
@@ -821,35 +965,6 @@ function getByGroup(severityKey, group, fieldName) {
     });
 }
 
-/**
- * Determines whether a certain test profile has failures.
- */
-function hasFailuresLogic(testObject, severityKey, fieldName) {
-    if (!testObject.hasFailures()) {
-        return false;
-    }
-    if (nonMatchingFieldName(testObject, fieldName)) {
-        return false;
-    }
-    if (nonMatchingSeverityProfile(severityKey, testObject)) {
-        return false;
-    }
-    return true;
-}
-
-function hasErrors(fieldName) {
-    return has(Severity.ERRORS, fieldName);
-}
-function hasWarnings(fieldName) {
-    return has(Severity.WARNINGS, fieldName);
-}
-function has(severityKey, fieldName) {
-    var testObjects = useTestsFlat();
-    return testObjects.some(function (testObject) {
-        return hasFailuresLogic(testObject, severityKey, fieldName);
-    });
-}
-
 function hasErrorsByGroup(groupName, fieldName) {
     return hasByGroup(Severity.ERRORS, groupName, fieldName);
 }
@@ -868,86 +983,6 @@ function hasByGroup(severityKey, group, fieldName) {
     });
 }
 
-/**
- * A safe hasOwnProperty access
- */
-function hasOwnProperty(obj, key) {
-    return Object.prototype.hasOwnProperty.call(obj, key);
-}
-
-function isNumber(value) {
-    return Boolean(typeof value === 'number');
-}
-
-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);
-
-// eslint-disable-next-line max-statements, complexity
-function isValid(result, fieldName) {
-    if (fieldIsOmitted(fieldName)) {
-        return true;
-    }
-    if (result.hasErrors(fieldName)) {
-        return false;
-    }
-    var testObjects = useTestsFlat();
-    if (isEmpty(testObjects)) {
-        return false;
-    }
-    if (fieldDoesNotExist(result, fieldName)) {
-        return false;
-    }
-    if (hasNonOptionalIncomplete(fieldName)) {
-        return false;
-    }
-    return noMissingTests(fieldName);
-}
-function fieldIsOmitted(fieldName) {
-    var omittedFields = useOmittedFields();
-    if (!fieldName) {
-        return false;
-    }
-    return !!omittedFields[fieldName];
-}
-function hasNonOptionalIncomplete(fieldName) {
-    var optionalFields = useOptionalFields()[0];
-    return isNotEmpty(useAllIncomplete().filter(function (testObject) {
-        if (nonMatchingFieldName(testObject, fieldName)) {
-            return false;
-        }
-        return optionalFields[testObject.fieldName] !== true;
-    }));
-}
-function fieldDoesNotExist(result, fieldName) {
-    return !!fieldName && isEmpty(result.tests[fieldName]);
-}
-function noMissingTests(fieldName) {
-    var testObjects = useTestsFlat();
-    var optionalFields = useOptionalFields()[0];
-    return testObjects.every(function (testObject) {
-        if (nonMatchingFieldName(testObject, fieldName)) {
-            return true;
-        }
-        return (optionalFields[testObject.fieldName] === true ||
-            testObject.isTested() ||
-            testObject.isOmitted());
-    });
-}
-
 var cache$1 = createCache(20);
 function produceSuiteResult() {
     var testObjects = useTestsFlat();
@@ -963,9 +998,7 @@ function produceSuiteResult() {
             hasErrorsByGroup: context.bind(ctxRef, hasErrorsByGroup),
             hasWarnings: context.bind(ctxRef, hasWarnings),
             hasWarningsByGroup: context.bind(ctxRef, hasWarningsByGroup),
-            isValid: context.bind(ctxRef, function (fieldName) {
-                return isValid(produceSuiteResult(), fieldName);
-            }),
+            isValid: context.bind(ctxRef, isValid),
             suiteName: suiteName
         });
     }));
@@ -1174,9 +1207,7 @@ function initBus() {
 }
 function useBus() {
     var context$1 = context.useX();
-    if (!context$1.bus) {
-        throwError();
-    }
+    invariant(context$1.bus);
     return context$1.bus;
 }
 var Events;
@@ -1195,9 +1226,7 @@ function create() {
         args[_i] = arguments[_i];
     }
     var _a = args.reverse(), suiteCallback = _a[0], suiteName = _a[1];
-    if (!isFunction(suiteCallback)) {
-        throwError('vest.create: Expected callback to be a function.');
-    }
+    invariant(isFunction(suiteCallback), 'vest.create: Expected callback to be a function.');
     // Event bus initialization
     var bus = initBus();
     // State initialization
@@ -1252,9 +1281,7 @@ function create() {
  * })
  */
 function each(list, callback) {
-    if (!isFunction(callback)) {
-        throwError('each callback must be a function');
-    }
+    invariant(isFunction(callback), 'each callback must be a function');
     isolate({ type: IsolateTypes.EACH }, function () {
         list.forEach(function (arg, index) {
             callback(arg, index);
@@ -1451,19 +1478,15 @@ function hasIncludedTests(keyTests) {
  * });
  */
 function group(groupName, tests) {
-    if (!isStringValue(groupName)) {
-        throwGroupError('name must be a string');
-    }
-    if (!isFunction(tests)) {
-        throwGroupError('callback must be a function');
-    }
+    invariant(isStringValue(groupName), groupErrorMsg('name must be a string'));
+    invariant(isFunction(tests), groupErrorMsg('callback must be a function'));
     // Running with the context applied
     isolate({ type: IsolateTypes.GROUP }, function () {
         context.run({ groupName: groupName }, tests);
     });
 }
-function throwGroupError(error) {
-    throwError("Wrong arguments passed to group. Group ".concat(error, "."));
+function groupErrorMsg(error) {
+    return "Wrong arguments passed to group. Group ".concat(error, ".");
 }
 
 function include(fieldName) {
@@ -1579,8 +1602,6 @@ function optional(optionals) {
     });
 }
 
-var isNotString = bindNot(isStringValue);
-
 function isPromise(value) {
     return value && isFunction(value.then);
 }
@@ -1674,7 +1695,7 @@ function registerTest(testObject) {
         }
     }
     catch (e) {
-        throwError("Unexpected error encountered during test registration.\n      Test Object: ".concat(JSON.stringify(testObject), ".\n      Error: ").concat(e, "."));
+        throw new Error("Unexpected error encountered during test registration.\n      Test Object: ".concat(JSON.stringify(testObject), ".\n      Error: ").concat(e, "."));
     }
 }
 
@@ -1701,7 +1722,7 @@ function useTestAtCursor(newTestObject) {
         useSetTestAtCursor(nextTest_1);
         return nextTest_1;
     }
-    if (shouldPurgePrevTest(prevTest, newTestObject)) {
+    if (testReorderDetected(prevTest, newTestObject)) {
         throwTestOrderError(prevTest, newTestObject);
         removeAllNextTestsInIsolate();
         // Need to see if this has any effect at all.
@@ -1738,14 +1759,14 @@ function useGetTestAtCursor(tests) {
     var cursorPath = usePath();
     return valueAtPath(tests, cursorPath);
 }
-function shouldPurgePrevTest(prevTest, newTest) {
+function testReorderDetected(prevTest, newTest) {
     return isNotEmpty(prevTest) && !isSameProfileTest(prevTest, newTest);
 }
 function throwTestOrderError(prevTest, newTestObject) {
     if (shouldAllowReorder()) {
         return;
     }
-    throwErrorDeferred("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."));
+    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);
@@ -1759,12 +1780,13 @@ function handleKeyTest(key, newTestObject) {
 
 // eslint-disable-next-line max-statements
 function registerPrevRunTest(testObject) {
-    var prevRunTest = useTestAtCursor(testObject);
     if (shouldSkipBasedOnMode(testObject)) {
-        moveForward();
         testObject.skip();
+        useTestAtCursor(testObject);
+        moveForward();
         return testObject;
     }
+    var prevRunTest = useTestAtCursor(testObject);
     if (isOmitted()) {
         prevRunTest.omit();
         moveForward();
@@ -1830,12 +1852,8 @@ function testBase(fieldName) {
         args[_i - 1] = arguments[_i];
     }
     var _a = (isFunction(args[1]) ? args : __spreadArray([undefined], args, true)), message = _a[0], testFn = _a[1], key = _a[2];
-    if (isNotString(fieldName)) {
-        throwIncompatibleParamsError('fieldName', 'string');
-    }
-    if (!isFunction(testFn)) {
-        throwIncompatibleParamsError('Test callback', 'function');
-    }
+    invariant(isStringValue(fieldName), incompatibleParamsError('fieldName', 'string'));
+    invariant(isFunction(testFn), incompatibleParamsError('Test callback', 'function'));
     var context$1 = context.useX();
     var testObject = new VestTest(fieldName, testFn, {
         message: message,
@@ -1856,8 +1874,8 @@ function testBase(fieldName) {
 var test = assign(testBase, {
     memo: bindTestMemo(testBase)
 });
-function throwIncompatibleParamsError(name, expected) {
-    throwError("Incompatible params passed to test function. ".concat(name, " must be a ").concat(expected));
+function incompatibleParamsError(name, expected) {
+    return "Incompatible params passed to test function. ".concat(name, " must be a ").concat(expected);
 }
 
 var ERROR_OUTSIDE_OF_TEST = "warn hook called outside of a test callback. It won't have an effect."
@@ -1867,12 +1885,10 @@ 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);
-    if (!ctx.currentTest) {
-        throwError(ERROR_OUTSIDE_OF_TEST);
-    }
+    invariant(ctx.currentTest, ERROR_OUTSIDE_OF_TEST);
     ctx.currentTest.warn();
 }
 
-var VERSION = "4.2.1";
+var VERSION = "4.3.0";
 
 export { VERSION, context, create, each, eager, group, include, omitWhen, only, optional, skip, skipWhen, test, warn };