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

package/dist/es/vest.development.js

@@ -1,42 +1,12 @@
 export { enforce } from 'n4s';
+import { isUndefined, isStringValue, assign, optionalFunctionValue, nestedArray, asArray, genId, isFunction, isNullish, deferThrow, invariant, bindNot, either, isEmpty, isNotEmpty, isPositive, hasOwnProperty, isArray, callEach, bus, defaultTo, isPromise, isNull } from 'vest-utils';
 import { createContext } from '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);
@@ -97,119 +67,6 @@ function createCache(maxSize) {
     }
 }
 
-// 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(callback, defaultValue) {
-    var _a;
-    return (_a = optionalFunctionValue(callback)) !== null && _a !== void 0 ? _a : 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;
-}
-
-function createCursor() {
-    var storage = {
-        cursor: []
-    };
-    function addLevel() {
-        storage.cursor.push(0);
-    }
-    function removeLevel() {
-        storage.cursor.pop();
-    }
-    function cursorAt() {
-        return last(storage.cursor);
-    }
-    function getCursor() {
-        return asArray(storage.cursor);
-    }
-    function next() {
-        storage.cursor[storage.cursor.length - 1]++;
-        return last(storage.cursor);
-    }
-    function reset() {
-        storage.cursor = [0];
-    }
-    reset();
-    return {
-        addLevel: addLevel,
-        cursorAt: cursorAt,
-        getCursor: getCursor,
-        next: next,
-        removeLevel: removeLevel,
-        reset: reset
-    };
-}
-
 var IsolateTypes;
 (function (IsolateTypes) {
     IsolateTypes[IsolateTypes["DEFAULT"] = 0] = "DEFAULT";
@@ -226,6 +83,41 @@ var Modes;
     Modes[Modes["EAGER"] = 1] = "EAGER";
 })(Modes || (Modes = {}));
 
+function createIsolateCursor() {
+    var cursor = {
+        value: 0
+    };
+    return {
+        current: current,
+        next: next
+    };
+    /**
+     * @returns {number} The current value of the cursor
+     */
+    function current() {
+        return cursor.value;
+    }
+    /**
+     * Moves the isolate cursor forward by 1
+     */
+    function next() {
+        cursor.value++;
+    }
+}
+
+function generateIsolate(type, path) {
+    if (path === void 0) { path = []; }
+    return {
+        cursor: createIsolateCursor(),
+        keys: {
+            current: {},
+            prev: {}
+        },
+        path: path,
+        type: type
+    };
+}
+
 var context = createContext(function (ctxRef, parentContext) {
     return parentContext
         ? null
@@ -235,15 +127,8 @@ var context = createContext(function (ctxRef, parentContext) {
                 groups: {}
             },
             inclusion: {},
-            isolate: {
-                type: IsolateTypes.DEFAULT,
-                keys: {
-                    current: {},
-                    prev: {}
-                }
-            },
-            mode: [Modes.ALL],
-            testCursor: createCursor()
+            isolate: generateIsolate(IsolateTypes.DEFAULT),
+            mode: [Modes.ALL]
         }, ctxRef);
 });
 
@@ -311,7 +196,7 @@ function useAllIncomplete() {
 var flatCache = createCache();
 function useTestsFlat() {
     var current = useTestObjects()[0].current;
-    return flatCache([current], function () { return flatten(current); });
+    return flatCache([current], function () { return nestedArray.flatten(current); });
 }
 function useEachTestObject(handler) {
     var testObjects = useTestsFlat();
@@ -462,20 +347,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 = {
@@ -559,40 +430,9 @@ function createStateRef(state, _a) {
     };
 }
 
-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();
-}
-function useCursorAt() {
-    var context$1 = context.useX();
-    return context$1.testCursor.cursorAt();
-}
-function moveForward() {
-    var context$1 = context.useX();
-    return context$1.testCursor.next();
-}
-function addLevel() {
-    var context$1 = context.useX();
-    context$1.testCursor.addLevel();
-}
-function removeLevel() {
-    var context$1 = context.useX();
-    context$1.testCursor.removeLevel();
-}
-
 function usePrevKeys() {
     var prev = useTestObjects()[0].prev;
-    return asArray(getCurrent(prev, usePath())).reduce(function (prevKeys, testObject) {
+    return asArray(nestedArray.getCurrent(prev, useCurrentPath())).reduce(function (prevKeys, testObject) {
         if (!(testObject instanceof VestTest)) {
             return prevKeys;
         }
@@ -604,12 +444,11 @@ function usePrevKeys() {
     }, {});
 }
 function usePrevTestByKey(key) {
-    var prev = context.useX().isolate.keys.prev;
+    var prev = useIsolate().keys.prev;
     return prev[key];
 }
 function useRetainTestKey(key, testObject) {
-    var context$1 = context.useX();
-    var current = context$1.isolate.keys.current;
+    var current = useIsolate().keys.current;
     if (isNullish(current[key])) {
         current[key] = testObject;
     }
@@ -621,23 +460,42 @@ function useRetainTestKey(key, testObject) {
 function isolate(_a, callback) {
     var _b = _a.type, type = _b === void 0 ? IsolateTypes.DEFAULT : _b;
     invariant(isFunction(callback));
-    var keys = {
-        current: {},
-        prev: {}
-    };
-    var path = usePath();
-    return context.run({ isolate: { type: type, keys: keys } }, function () {
-        addLevel();
-        keys.prev = usePrevKeys();
-        useSetTests(function (tests) { return setValueAtPath(tests, path, []); });
+    // Generate a new Isolate layer, with its own cursor
+    var isolate = generateIsolate(type, useCurrentPath());
+    var output = context.run({ isolate: isolate }, function () {
+        isolate.keys.prev = usePrevKeys();
+        useSetTests(function (tests) { return nestedArray.setValueAtPath(tests, isolate.path, []); });
         var res = callback();
-        removeLevel();
-        moveForward();
         return res;
     });
+    // Move the parent cursor forward once we're done
+    useCursor().next();
+    return output;
+}
+/**
+ * @returns {Isolate} The current isolate layer
+ */
+function useIsolate() {
+    return context.useX().isolate;
 }
+/**
+ * @returns {boolean} Whether or not the current isolate allows tests to be reordered
+ */
 function shouldAllowReorder() {
-    return context.useX().isolate.type === IsolateTypes.EACH;
+    return useIsolate().type === IsolateTypes.EACH;
+}
+/**
+ * @returns {number[]} The current cursor path of the isolate tree
+ */
+function useCurrentPath() {
+    var isolate = useIsolate();
+    return isolate.path.concat(isolate.cursor.current());
+}
+/**
+ * @returns {IsolateCursor} The cursor object for the current isolate
+ */
+function useCursor() {
+    return useIsolate().cursor;
 }
 
 var Severity;
@@ -656,34 +514,6 @@ function countKeyBySeverity(severity) {
         : SeverityCount.WARN_COUNT;
 }
 
-/**
- * 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 false;
-}
-var isNotEmpty = bindNot(isEmpty);
-
 function nonMatchingFieldName(testObject, fieldName) {
     return !!fieldName && !matchingFieldName(testObject, fieldName);
 }
@@ -696,10 +526,6 @@ 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
  */
@@ -923,10 +749,6 @@ function baseTestStats() {
     });
 }
 
-function isPositive(value) {
-    return greaterThan(value, 0);
-}
-
 // calls collectAll or getByFieldName depending on whether fieldName is provided
 function gatherFailures(testGroup, severityKey, fieldName) {
     return fieldName
@@ -1142,28 +964,6 @@ 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)) {
@@ -1171,7 +971,7 @@ function omitOptionalFields() {
     }
     var shouldOmit = {};
     useSetTests(function (tests) {
-        return transform(tests, function (testObject) {
+        return nestedArray.transform(tests, function (testObject) {
             var fieldName = testObject.fieldName;
             if (hasOwnProperty(shouldOmit, fieldName)) {
                 verifyAndOmit(testObject);
@@ -1202,14 +1002,10 @@ function omitOptionalFields() {
  */
 function removeTestFromState (testObject) {
     useSetTests(function (tests) {
-        return transform(tests, function (test) { return (testObject !== test ? test : null); });
+        return 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.
  */
@@ -1231,10 +1027,10 @@ function runDoneCallbacks() {
 
 // eslint-disable-next-line max-lines-per-function
 function initBus() {
-    var bus = createBus();
+    var vestBus = 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;
         }
@@ -1242,21 +1038,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();
@@ -1265,14 +1061,14 @@ 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();
@@ -1593,9 +1389,7 @@ function eager() {
     setMode(Modes.EAGER);
 }
 function shouldSkipBasedOnMode(testObject) {
-    if (isEager() && hasErrorsByTestObjects(testObject.fieldName))
-        return true;
-    return false;
+    return isEager() && hasErrorsByTestObjects(testObject.fieldName);
 }
 function isEager() {
     return isMode(Modes.EAGER);
@@ -1659,7 +1453,7 @@ function optional(optionals) {
     }
 }
 
-/*! *****************************************************************************
+/******************************************************************************
 Copyright (c) Microsoft Corporation.
 
 Permission to use, copy, modify, and/or distribute this software for any
@@ -1684,9 +1478,7 @@ function __spreadArray(to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 }
 
-function isPromise(value) {
-    return value && isFunction(value.then);
-}
+bindNot(isStringValue);
 
 function isSameProfileTest(testObject1, testObject2) {
     return (testObject1.fieldName === testObject2.fieldName &&
@@ -1802,31 +1594,24 @@ function useTestAtCursor(newTestObject) {
     return nextTest;
 }
 function removeAllNextTestsInIsolate() {
-    var _a = useTestObjects(), testObjects = _a[0], setTestObjects = _a[1];
-    var prevTests = testObjects.prev;
-    var current = getCurrent(prevTests, usePath());
-    var cursorAt = useCursorAt();
-    current.splice(cursorAt);
+    var cursorAt = useCursor().current();
     // We actually don't mind mutating the state directly (as can be seen above). There is no harm in it
     // since we're only touching the "prev" state. The reason we still use the setter function is
     // to prevent future headaches if we ever do need to rely on prev-state immutability.
-    setTestObjects(function (_a) {
-        var current = _a.current;
-        return ({
-            prev: prevTests,
-            current: current
-        });
+    useSetTests(function (current) {
+        current.splice(cursorAt);
+        return current;
     });
 }
 function useSetTestAtCursor(testObject) {
-    var cursorPath = usePath();
+    var cursorPath = useCurrentPath();
     useSetTests(function (tests) {
-        return setValueAtPath(tests, cursorPath, testObject);
+        return nestedArray.setValueAtPath(tests, cursorPath, testObject);
     });
 }
 function useGetTestAtCursor(tests) {
-    var cursorPath = usePath();
-    return valueAtPath(tests, cursorPath);
+    var cursorPath = useCurrentPath();
+    return nestedArray.valueAtPath(tests, cursorPath);
 }
 function testReorderDetected(prevTest, newTest) {
     return isNotEmpty(prevTest) && !isSameProfileTest(prevTest, newTest);
@@ -1849,16 +1634,17 @@ function handleKeyTest(key, newTestObject) {
 
 // eslint-disable-next-line max-statements
 function registerPrevRunTest(testObject) {
+    var cursor = useCursor();
     if (shouldSkipBasedOnMode(testObject)) {
         testObject.skip();
         useTestAtCursor(testObject);
-        moveForward();
+        cursor.next();
         return testObject;
     }
     var prevRunTest = useTestAtCursor(testObject);
     if (isOmitted()) {
         prevRunTest.omit();
-        moveForward();
+        cursor.next();
         return prevRunTest;
     }
     if (isExcluded(testObject)) {
@@ -1867,13 +1653,13 @@ function registerPrevRunTest(testObject) {
         // This mostly means that we're probably giving
         // up on this async test intentionally.
         prevRunTest.skip(isExcludedIndividually());
-        moveForward();
+        cursor.next();
         return prevRunTest;
     }
     cancelOverriddenPendingTest(prevRunTest, testObject);
     useSetTestAtCursor(testObject);
-    moveForward();
     registerTestObjectByTier(testObject);
+    cursor.next();
     return testObject;
 }
 function registerTestObjectByTier(testObject) {
@@ -1896,7 +1682,7 @@ function bindTestMemo(test) {
         for (var _i = 1; _i < arguments.length; _i++) {
             args[_i - 1] = arguments[_i];
         }
-        var cursorAt = useCursorAt();
+        var cursorAt = useCursor().current();
         var _a = args.reverse(), deps = _a[0], testFn = _a[1], msg = _a[2];
         // Implicit dependency for more specificity
         var dependencies = [useSuiteId(), fieldName, cursorAt].concat(deps);
@@ -1958,6 +1744,6 @@ function warn() {
     ctx.currentTest.warn();
 }
 
-var VERSION = "4.4.0-dev-08ec91";
+var VERSION = "4.4.2-dev-afe5de";
 
 export { VERSION, context, create, each, eager, group, include, omitWhen, only, optional, skip, skipWhen, test, warn };