@dereekb/util 12.7.0 → 13.0.1

package/test/index.esm.js

@@ -0,0 +1,1434 @@
+import { promiseReference, forwardFunction, mapObjectMap, isPromise, build } from '@dereekb/util';
+import { BaseError } from 'make-error';
+
+function _assert_this_initialized$4(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$2(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _call_super$4(_this, derived, args) {
+    derived = _get_prototype_of$4(derived);
+    return _possible_constructor_return$4(_this, _is_native_reflect_construct$4() ? Reflect.construct(derived, [], _get_prototype_of$4(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check$4(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property$2(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _get_prototype_of$4(o) {
+    _get_prototype_of$4 = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of$4(o);
+}
+function _inherits$4(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of$4(subClass, superClass);
+}
+function _possible_constructor_return$4(self, call) {
+    if (call && (_type_of$4(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized$4(self);
+}
+function _set_prototype_of$4(o, p) {
+    _set_prototype_of$4 = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of$4(o, p);
+}
+function _type_of$4(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct$4() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct$4 = function() {
+        return !!result;
+    })();
+}
+function _ts_generator$2(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+/**
+ * Passes the error to the TestDoneCallback.
+ * @param done
+ * @param e
+ */ function failWithTestDoneCallback(done) {
+    var e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : new Error('failed test');
+    if (done.fail != null) {
+        done.fail(e);
+    } else {
+        done(e);
+    }
+}
+/**
+ * Creates a new TestDoneCallbackRef.
+ *
+ * Used to create a promise reference that can be used to assert that a test function was called.
+ */ function testDoneCallbackRef() {
+    var _promise = promiseReference();
+    var done = function done(e) {
+        if (e) {
+            _promise.reject(e);
+        } else {
+            _promise.resolve();
+        }
+    };
+    done.fail = done;
+    return {
+        _promise: _promise,
+        done: done
+    };
+}
+/**
+ * Wraps a callback-based test (using done) for Vitest compatibility.
+ * Converts the callback pattern to a Promise-based pattern.
+ *
+ * This also supports calling the input test with async, but still only returns when done is called.
+ *
+ * @example
+ *
+ * // Before (Jasmine/Jest style):
+ * it('test name', (done) => {
+ *   // async test code
+ *   done();
+ * });
+ *
+ * // After (Vitest compatible):
+ * it('test name', callbackTest((done) => {
+ *   // async test code
+ *   done();
+ * }));
+ */ function callbackTest(testFn) {
+    return function() {
+        return _async_to_generator$2(function() {
+            var done;
+            return _ts_generator$2(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        done = testDoneCallbackRef();
+                        return [
+                            4,
+                            testFn(done.done)
+                        ];
+                    case 1:
+                        _state.sent();
+                        return [
+                            2,
+                            done._promise.promise
+                        ];
+                }
+            });
+        })();
+    };
+}
+/**
+ * Abstract TestContextFixture instance.
+ */ var AbstractTestContextFixture = /*#__PURE__*/ function() {
+    function AbstractTestContextFixture() {
+        _class_call_check$4(this, AbstractTestContextFixture);
+        _define_property$2(this, "_instance", void 0);
+    }
+    _create_class(AbstractTestContextFixture, [
+        {
+            key: "instance",
+            get: function get() {
+                return this._instance;
+            }
+        },
+        {
+            key: "setInstance",
+            value: function setInstance(instance) {
+                var _this = this;
+                if (this._instance != null) {
+                    throw new Error("The testing fixture is locked. Don't call setInstance() directly.");
+                }
+                this._instance = instance;
+                return function() {
+                    delete _this._instance;
+                };
+            }
+        }
+    ]);
+    return AbstractTestContextFixture;
+}();
+/**
+ * Abstract TestContextFixture instance with a parent.
+ */ var AbstractChildTestContextFixture = /*#__PURE__*/ function(AbstractTestContextFixture) {
+    _inherits$4(AbstractChildTestContextFixture, AbstractTestContextFixture);
+    function AbstractChildTestContextFixture(parent) {
+        _class_call_check$4(this, AbstractChildTestContextFixture);
+        var _this;
+        _this = _call_super$4(this, AbstractChildTestContextFixture), _define_property$2(_this, "parent", void 0);
+        _this.parent = parent;
+        return _this;
+    }
+    return AbstractChildTestContextFixture;
+}(AbstractTestContextFixture);
+/**
+ * Creates a TestContextBuilderFunction given the input builder.
+ *
+ * @param builder
+ * @returns
+ */ function testContextBuilder(builder) {
+    return function(inputConfig) {
+        var config = builder.buildConfig(inputConfig);
+        return function(buildTests) {
+            var fixture = builder.buildFixture(config);
+            // add before each
+            if (builder.beforeEach != null) {
+                beforeEach(builder.beforeEach);
+            }
+            // add tests
+            useTestContextFixture({
+                fixture: fixture,
+                /**
+                 * Build tests by passing the fixture to the testing functions.
+                 *
+                 * This will inject all tests and sub lifecycle items.
+                 */ buildTests: buildTests,
+                initInstance: function initInstance() {
+                    return builder.setupInstance(config);
+                },
+                destroyInstance: function destroyInstance(instance) {
+                    return builder.teardownInstance(instance, config);
+                }
+            });
+            // add after each
+            if (builder.afterEach != null) {
+                afterEach(builder.afterEach);
+            }
+        };
+    };
+}
+/**
+ * Creates a test context and configurations that will initialize an instance
+ */ function useTestContextFixture(config) {
+    var buildTests = config.buildTests, fixture = config.fixture, initInstance = config.initInstance, destroyInstance = config.destroyInstance;
+    var clearInstance;
+    var instance;
+    // Create an instance
+    beforeEach(function() {
+        return _async_to_generator$2(function() {
+            var e;
+            return _ts_generator$2(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        _state.trys.push([
+                            0,
+                            2,
+                            ,
+                            3
+                        ]);
+                        return [
+                            4,
+                            initInstance()
+                        ];
+                    case 1:
+                        instance = _state.sent();
+                        clearInstance = fixture.setInstance(instance);
+                        return [
+                            3,
+                            3
+                        ];
+                    case 2:
+                        e = _state.sent();
+                        console.error('Failed building a test instance due to an error in buildInstance(). Error: ', e);
+                        if (clearInstance) {
+                            clearInstance();
+                        }
+                        throw e;
+                    case 3:
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    // Declare tests
+    buildTests(fixture);
+    // Cleanup
+    afterEach(function() {
+        return _async_to_generator$2(function() {
+            var e;
+            return _ts_generator$2(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        if (clearInstance) {
+                            clearInstance();
+                        }
+                        if (fixture.instance != null) {
+                            console.warn('Expected instance to be set on fixture for cleanup but was set to something else.');
+                        }
+                        if (!destroyInstance) return [
+                            3,
+                            4
+                        ];
+                        _state.label = 1;
+                    case 1:
+                        _state.trys.push([
+                            1,
+                            3,
+                            ,
+                            4
+                        ]);
+                        return [
+                            4,
+                            destroyInstance(instance)
+                        ];
+                    case 2:
+                        _state.sent();
+                        instance = undefined;
+                        return [
+                            3,
+                            4
+                        ];
+                    case 3:
+                        e = _state.sent();
+                        console.error('Failed due to error in destroyInstance()');
+                        throw e;
+                    case 4:
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+}
+
+function _assert_this_initialized$3(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$1(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _call_super$3(_this, derived, args) {
+    derived = _get_prototype_of$3(derived);
+    return _possible_constructor_return$3(_this, _is_native_reflect_construct$3() ? Reflect.construct(derived, [], _get_prototype_of$3(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check$3(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _define_property$1(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _get_prototype_of$3(o) {
+    _get_prototype_of$3 = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of$3(o);
+}
+function _inherits$3(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of$3(subClass, superClass);
+}
+function _possible_constructor_return$3(self, call) {
+    if (call && (_type_of$3(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized$3(self);
+}
+function _set_prototype_of$3(o, p) {
+    _set_prototype_of$3 = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of$3(o, p);
+}
+function _type_of$3(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct$3() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct$3 = function() {
+        return !!result;
+    })();
+}
+function _ts_generator$1(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var AbstractWrappedFixture = function AbstractWrappedFixture(fixture) {
+    _class_call_check$3(this, AbstractWrappedFixture);
+    _define_property$1(this, "fixture", void 0);
+    this.fixture = fixture;
+};
+var AbstractWrappedFixtureWithInstance = /*#__PURE__*/ function(AbstractTestContextFixture) {
+    _inherits$3(AbstractWrappedFixtureWithInstance, AbstractTestContextFixture);
+    function AbstractWrappedFixtureWithInstance(parent) {
+        _class_call_check$3(this, AbstractWrappedFixtureWithInstance);
+        var _this;
+        _this = _call_super$3(this, AbstractWrappedFixtureWithInstance), _define_property$1(_this, "parent", void 0);
+        _this.parent = parent;
+        return _this;
+    }
+    return AbstractWrappedFixtureWithInstance;
+}(AbstractTestContextFixture);
+/**
+ * Wraps the input TestContextFactory to emit another type of Fixture for tests.
+ *
+ * @returns
+ */ function wrapTestContextFactory(config) {
+    return function(factory) {
+        return function(buildTests) {
+            factory(function(inputFixture) {
+                var wrap = config.wrapFixture(inputFixture);
+                var effect;
+                // add before each
+                if (config.setupWrap != null) {
+                    beforeEach(function() {
+                        return _async_to_generator$1(function() {
+                            return _ts_generator$1(this, function(_state) {
+                                switch(_state.label){
+                                    case 0:
+                                        return [
+                                            4,
+                                            config.setupWrap(wrap)
+                                        ];
+                                    case 1:
+                                        effect = _state.sent();
+                                        return [
+                                            2
+                                        ];
+                                }
+                            });
+                        })();
+                    });
+                }
+                // add tests
+                buildTests(wrap);
+                // add after each
+                if (config.teardownWrap != null) {
+                    afterEach(function() {
+                        return _async_to_generator$1(function() {
+                            return _ts_generator$1(this, function(_state) {
+                                switch(_state.label){
+                                    case 0:
+                                        return [
+                                            4,
+                                            config.teardownWrap(wrap, effect)
+                                        ];
+                                    case 1:
+                                        _state.sent();
+                                        return [
+                                            2
+                                        ];
+                                }
+                            });
+                        })();
+                    });
+                }
+            });
+        };
+    };
+}
+function instanceWrapTestContextFactory(config) {
+    return wrapTestContextFactory({
+        wrapFixture: config.wrapFixture,
+        setupWrap: function setupWrap(wrap) {
+            return _async_to_generator$1(function() {
+                var instance, effect;
+                return _ts_generator$1(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                config.makeInstance(wrap)
+                            ];
+                        case 1:
+                            instance = _state.sent();
+                            effect = wrap.setInstance(instance);
+                            if (!config.setupInstance) return [
+                                3,
+                                3
+                            ];
+                            return [
+                                4,
+                                config.setupInstance(instance, wrap)
+                            ];
+                        case 2:
+                            _state.sent();
+                            _state.label = 3;
+                        case 3:
+                            return [
+                                2,
+                                effect
+                            ];
+                    }
+                });
+            })();
+        },
+        teardownWrap: function teardownWrap(wrap, deleteInstanceEffect) {
+            return _async_to_generator$1(function() {
+                return _ts_generator$1(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            deleteInstanceEffect === null || deleteInstanceEffect === void 0 ? void 0 : deleteInstanceEffect();
+                            if (!config.teardownInstance) return [
+                                3,
+                                2
+                            ];
+                            return [
+                                4,
+                                config.teardownInstance(wrap.instance)
+                            ];
+                        case 1:
+                            _state.sent();
+                            _state.label = 2;
+                        case 2:
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        }
+    });
+}
+
+/**
+ * Creates a test context and configurations that provides a function to build tests based on the configuration.
+ */ function useTestFunctionFixture(config, buildTests) {
+    var fn = config.fn;
+    var forward = forwardFunction(fn);
+    buildTests(forward);
+}
+/**
+ * Creates a test context and configurations that provides a function to build tests based on the configuration.
+ */ function useTestFunctionMapFixture(config, buildTests) {
+    var forwardedFunctions = mapObjectMap(config.fns, function(fn) {
+        return forwardFunction(fn);
+    });
+    buildTests(forwardedFunctions);
+}
+
+function _assert_this_initialized$2(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _call_super$2(_this, derived, args) {
+    derived = _get_prototype_of$2(derived);
+    return _possible_constructor_return$2(_this, _is_native_reflect_construct$2() ? Reflect.construct(derived, args || [], _get_prototype_of$2(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check$2(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _get_prototype_of$2(o) {
+    _get_prototype_of$2 = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of$2(o);
+}
+function _inherits$2(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of$2(subClass, superClass);
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _possible_constructor_return$2(self, call) {
+    if (call && (_type_of$2(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized$2(self);
+}
+function _set_prototype_of$2(o, p) {
+    _set_prototype_of$2 = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of$2(o, p);
+}
+function _type_of$2(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct$2() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct$2 = function() {
+        return !!result;
+    })();
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+// MARK: Errors
+/**
+ * Error thrown by fail() and used by expectError()
+ */ var ExpectedFailError = /*#__PURE__*/ function(BaseError) {
+    _inherits$2(ExpectedFailError, BaseError);
+    function ExpectedFailError() {
+        _class_call_check$2(this, ExpectedFailError);
+        return _call_super$2(this, ExpectedFailError, arguments);
+    }
+    return ExpectedFailError;
+}(BaseError);
+function failSuccessfullyError(message) {
+    return new ExpectedFailError(message);
+}
+function failSuccessfully(message) {
+    throw failSuccessfullyError(message);
+}
+/**
+ * Error thrown when success occurs when it should not have.
+ */ var UnexpectedSuccessFailureError = /*#__PURE__*/ function(BaseError) {
+    _inherits$2(UnexpectedSuccessFailureError, BaseError);
+    function UnexpectedSuccessFailureError() {
+        _class_call_check$2(this, UnexpectedSuccessFailureError);
+        return _call_super$2(this, UnexpectedSuccessFailureError, arguments);
+    }
+    return UnexpectedSuccessFailureError;
+}(BaseError);
+function failDueToSuccessError(message) {
+    return new UnexpectedSuccessFailureError(message !== null && message !== void 0 ? message : 'expected an error to occur but was successful instead');
+}
+/**
+ * Error thrown when the error type was different than the expected type.
+ */ var ExpectedErrorOfSpecificTypeError = /*#__PURE__*/ function(BaseError) {
+    _inherits$2(ExpectedErrorOfSpecificTypeError, BaseError);
+    function ExpectedErrorOfSpecificTypeError(encounteredType, expectedType) {
+        _class_call_check$2(this, ExpectedErrorOfSpecificTypeError);
+        var _this;
+        _this = _call_super$2(this, ExpectedErrorOfSpecificTypeError, [
+            "The error encountered was not of the expected type. Expected: ".concat(expectedType !== null && expectedType !== void 0 ? expectedType : 'n/a', ", but encountered: ").concat(encounteredType, " ")
+        ]), _define_property(_this, "encounteredType", void 0), _define_property(_this, "expectedType", void 0);
+        _this.encounteredType = encounteredType;
+        _this.expectedType = expectedType;
+        return _this;
+    }
+    return ExpectedErrorOfSpecificTypeError;
+}(BaseError);
+function failTest(message) {
+    throw failDueToSuccessError(message);
+}
+function failDueToSuccess() {
+    throw failDueToSuccessError();
+}
+function EXPECT_ERROR_DEFAULT_HANDLER(e) {
+    if (_instanceof(e, ExpectedFailError)) ; else {
+        throw e;
+    }
+}
+/**
+ * Creates an ExpectFailAssertionFunction that asserts the encountered error is of the expected type using the instanceof keyword.
+ *
+ * Throws an ExpectedErrorOfSpecificTypeError on failures.
+ *
+ * @param expectedType
+ * @returns
+ */ function expectFailAssertErrorType(expectedType) {
+    return function(error) {
+        if (!_instanceof(error, expectedType)) {
+            throw new ExpectedErrorOfSpecificTypeError(error, expectedType);
+        }
+    };
+}
+function expectFail(errorFn, assertFailType) {
+    function handleError(e) {
+        if (_instanceof(e, UnexpectedSuccessFailureError)) {
+            throw e;
+        } else {
+            var assertionResult = assertFailType === null || assertFailType === void 0 ? void 0 : assertFailType(e);
+            if (assertionResult === false) {
+                throw new ExpectedErrorOfSpecificTypeError(e);
+            }
+            failSuccessfully();
+        }
+    }
+    try {
+        var result = errorFn();
+        if (isPromise(result)) {
+            return result.then(failDueToSuccess).catch(handleError);
+        } else {
+            failDueToSuccess();
+        }
+    } catch (e) {
+        handleError(e);
+    }
+}
+function expectSuccessfulFail(errorFn) {
+    var handleError = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : EXPECT_ERROR_DEFAULT_HANDLER;
+    try {
+        var result = errorFn();
+        if (isPromise(result)) {
+            return result.then(failDueToSuccess).catch(handleError);
+        } else {
+            failDueToSuccess();
+        }
+    } catch (e) {
+        handleError(e);
+    }
+}
+/**
+ * Used to wrap a testing function and watch for ExpectedFailError errors in order to pass the test. Other exceptions are treated normally as failures.
+ *
+ * This is typically used in conjunction with failSuccessfully(), expectSuccessfulFail(), or expectFail().
+ *
+ * @param fn
+ * @param strict
+ * @returns
+ */ function shouldFail(fn) {
+    var usesDoneCallback = fn.length > 0;
+    // Return a function that checks arguments at runtime to avoid done callback deprecation warning
+    return function() {
+        return _async_to_generator(function() {
+            var _testDoneCallbackRef, done, _promise, result;
+            function handleError(e) {
+                if (!_instanceof(e, ExpectedFailError)) {
+                    failWithTestDoneCallback(done, e);
+                } else {
+                    done();
+                }
+            }
+            return _ts_generator(this, function(_state) {
+                _testDoneCallbackRef = testDoneCallbackRef(), done = _testDoneCallbackRef.done, _promise = _testDoneCallbackRef._promise;
+                try {
+                    result = expectSuccessfulFail(function() {
+                        var result;
+                        if (usesDoneCallback) {
+                            var fakeDone = build({
+                                base: fakeDoneHandler(),
+                                build: function build(x) {
+                                    x.failSuccessfully = function() {
+                                        fakeDone(failSuccessfullyError());
+                                    };
+                                }
+                            });
+                            var callbackWithDoneResult = fn(fakeDone);
+                            if (isPromise(callbackWithDoneResult)) {
+                                fakeDone.reject(new Error('Configured to use "done" value while returning a promise. Configure your test to use one or the other.'));
+                            }
+                            // return the fake done promise. Done/fail will resolve as a promise.
+                            result = fakeDone._ref.promise;
+                        } else {
+                            result = fn();
+                        }
+                        return result;
+                    }, handleError);
+                    // If expectSuccessfulFail returns a promise, handle it
+                    if (isPromise(result)) {
+                        result.catch(handleError);
+                    }
+                } catch (e) {
+                    // Handle synchronous errors
+                    handleError(e);
+                }
+                return [
+                    2,
+                    _promise.promise
+                ];
+            });
+        })();
+    };
+}
+function itShouldFail(describeOrFn, fn) {
+    var description;
+    if (typeof describeOrFn === 'string') {
+        description = "should fail ".concat(describeOrFn);
+    } else {
+        fn = describeOrFn;
+        description = 'should fail';
+    }
+    it(description, shouldFail(fn));
+}
+function fakeDoneHandler() {
+    var promiseRef = promiseReference();
+    var doneHandler = promiseRef.resolve;
+    var failHandler = function failHandler(e) {
+        promiseRef.reject(e);
+    };
+    var fakeDone = function fakeDone(error) {
+        if (error) {
+            failHandler(error);
+        } else {
+            doneHandler(0);
+        }
+    };
+    fakeDone.fail = function(error) {
+        failHandler(error);
+    };
+    fakeDone._ref = promiseRef;
+    fakeDone.promise = promiseRef.promise;
+    fakeDone.resolve = promiseRef.resolve;
+    fakeDone.reject = promiseRef.reject;
+    return fakeDone;
+}
+
+function _assert_this_initialized$1(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super$1(_this, derived, args) {
+    derived = _get_prototype_of$1(derived);
+    return _possible_constructor_return$1(_this, _is_native_reflect_construct$1() ? Reflect.construct(derived, args || [], _get_prototype_of$1(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check$1(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _get_prototype_of$1(o) {
+    _get_prototype_of$1 = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of$1(o);
+}
+function _inherits$1(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of$1(subClass, superClass);
+}
+function _possible_constructor_return$1(self, call) {
+    if (call && (_type_of$1(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized$1(self);
+}
+function _set_prototype_of$1(o, p) {
+    _set_prototype_of$1 = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of$1(o, p);
+}
+function _type_of$1(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct$1() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct$1 = function() {
+        return !!result;
+    })();
+}
+/**
+ * @deprecated Use AbstractTestContextFixture from shared instead. This is kept for backwards compatibility.
+ */ var AbstractJestTestContextFixture = /*#__PURE__*/ function(AbstractTestContextFixture) {
+    _inherits$1(AbstractJestTestContextFixture, AbstractTestContextFixture);
+    function AbstractJestTestContextFixture() {
+        _class_call_check$1(this, AbstractJestTestContextFixture);
+        return _call_super$1(this, AbstractJestTestContextFixture, arguments);
+    }
+    return AbstractJestTestContextFixture;
+}(AbstractTestContextFixture);
+/**
+ * @deprecated Use AbstractChildTestContextFixture from shared instead. This is kept for backwards compatibility.
+ */ var AbstractChildJestTestContextFixture = /*#__PURE__*/ function(AbstractChildTestContextFixture) {
+    _inherits$1(AbstractChildJestTestContextFixture, AbstractChildTestContextFixture);
+    function AbstractChildJestTestContextFixture() {
+        _class_call_check$1(this, AbstractChildJestTestContextFixture);
+        return _call_super$1(this, AbstractChildJestTestContextFixture, arguments);
+    }
+    return AbstractChildJestTestContextFixture;
+}(AbstractChildTestContextFixture);
+/**
+ * @deprecated Use testContextBuilder from shared instead. This is kept for backwards compatibility.
+ */ var jestTestContextBuilder = testContextBuilder;
+/**
+ * @deprecated Use useContextFixture from shared instead. This is kept for backwards compatibility.
+ */ var useJestContextFixture = useTestContextFixture;
+
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+/**
+ * @deprecated Use failWithTestDoneCallback from shared instead. This is kept for backwards compatibility.
+ */ var failWithJestDoneCallback = failWithTestDoneCallback;
+// MARK: Errors
+/**
+ * @deprecated Use ExpectedFailError from shared instead. This is kept for backwards compatibility.
+ */ var JestExpectedFailError = /*#__PURE__*/ function(ExpectedFailError) {
+    _inherits(JestExpectedFailError, ExpectedFailError);
+    function JestExpectedFailError() {
+        _class_call_check(this, JestExpectedFailError);
+        return _call_super(this, JestExpectedFailError, arguments);
+    }
+    return JestExpectedFailError;
+}(ExpectedFailError);
+/**
+ * @deprecated Use UnexpectedSuccessFailureError from shared instead. This is kept for backwards compatibility.
+ */ var JestUnexpectedSuccessFailureError = /*#__PURE__*/ function(UnexpectedSuccessFailureError) {
+    _inherits(JestUnexpectedSuccessFailureError, UnexpectedSuccessFailureError);
+    function JestUnexpectedSuccessFailureError() {
+        _class_call_check(this, JestUnexpectedSuccessFailureError);
+        return _call_super(this, JestUnexpectedSuccessFailureError, arguments);
+    }
+    return JestUnexpectedSuccessFailureError;
+}(UnexpectedSuccessFailureError);
+/**
+ * @deprecated Use ExpectedErrorOfSpecificTypeError from shared instead. This is kept for backwards compatibility.
+ */ var JestExpectedErrorOfSpecificTypeError = /*#__PURE__*/ function(ExpectedErrorOfSpecificTypeError) {
+    _inherits(JestExpectedErrorOfSpecificTypeError, ExpectedErrorOfSpecificTypeError);
+    function JestExpectedErrorOfSpecificTypeError() {
+        _class_call_check(this, JestExpectedErrorOfSpecificTypeError);
+        return _call_super(this, JestExpectedErrorOfSpecificTypeError, arguments);
+    }
+    return JestExpectedErrorOfSpecificTypeError;
+}(ExpectedErrorOfSpecificTypeError);
+/**
+ * @deprecated Use failWithTestDoneCallback with failDueToSuccessError from shared instead. This is kept for backwards compatibility.
+ */ function failWithDoneDueToSuccess(done) {
+    failWithTestDoneCallback(done, failDueToSuccessError());
+}
+/**
+ * @deprecated Use expectFailAssertErrorType from shared instead. This is kept for backwards compatibility.
+ */ var jestExpectFailAssertErrorType = expectFailAssertErrorType;
+
+/**
+ * Wraps the input JestTestContextFactory to emit another type of Fixture for tests.
+ *
+ * @deprecated Use wrapTestContextFactory from shared instead. This is kept for backwards compatibility.
+ * @returns
+ */ var wrapJestTestContextFactory = wrapTestContextFactory;
+/**
+ * @deprecated Use instanceWrapTestContextFactory from shared instead. This is kept for backwards compatibility.
+ */ var instanceWrapJestTestContextFactory = instanceWrapTestContextFactory;
+
+/**
+ * @deprecated Use useTestFunctionFixture from shared instead. This is kept for backwards compatibility.
+ */ var useJestFunctionFixture = useTestFunctionFixture;
+/**
+ * @deprecated Use useTestFunctionMapFixture from shared instead. This is kept for backwards compatibility.
+ */ var useJestFunctionMapFixture = useTestFunctionMapFixture;
+
+export { AbstractChildJestTestContextFixture, AbstractChildTestContextFixture, AbstractJestTestContextFixture, AbstractTestContextFixture, AbstractWrappedFixture, AbstractWrappedFixtureWithInstance, EXPECT_ERROR_DEFAULT_HANDLER, ExpectedErrorOfSpecificTypeError, ExpectedFailError, JestExpectedErrorOfSpecificTypeError, JestExpectedFailError, JestUnexpectedSuccessFailureError, UnexpectedSuccessFailureError, callbackTest, expectFail, expectFailAssertErrorType, expectSuccessfulFail, failDueToSuccess, failDueToSuccessError, failSuccessfully, failSuccessfullyError, failTest, failWithDoneDueToSuccess, failWithJestDoneCallback, failWithTestDoneCallback, fakeDoneHandler, instanceWrapJestTestContextFactory, instanceWrapTestContextFactory, itShouldFail, jestExpectFailAssertErrorType, jestTestContextBuilder, shouldFail, testContextBuilder, testDoneCallbackRef, useJestContextFixture, useJestFunctionFixture, useJestFunctionMapFixture, useTestContextFixture, useTestFunctionFixture, useTestFunctionMapFixture, wrapJestTestContextFactory, wrapTestContextFactory };