jnpf-web-vue3/node_modules/@wendellhu/redi/dist/redi.js

(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
    typeof define === 'function' && define.amd ? define(['exports'], factory) :
    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["@wendellhu/redi"] = {}));
})(this, (function (exports) { 'use strict';

    var IdentifierDecoratorSymbol = Symbol('$$IDENTIFIER_DECORATOR');
    function isIdentifierDecorator(thing) {
        return thing && thing[IdentifierDecoratorSymbol] === true;
    }

    function isCtor(thing) {
        return typeof thing === 'function';
    }
    function isClassDependencyItem(thing) {
        if (thing && typeof thing.useClass !== 'undefined') {
            return true;
        }
        return false;
    }
    function isFactoryDependencyItem(thing) {
        if (thing && typeof thing.useFactory !== 'undefined') {
            return true;
        }
        return false;
    }
    function isValueDependencyItem(thing) {
        if (thing && typeof thing.useValue !== 'undefined') {
            return true;
        }
        return false;
    }
    function isExistingDependencyItem(thing) {
        if (thing && typeof thing.useExisting !== 'undefined') {
            return true;
        }
        return false;
    }
    function isAsyncDependencyItem(thing) {
        if (thing && typeof thing.useAsync !== 'undefined') {
            return true;
        }
        return false;
    }
    var AsyncHookSymbol = Symbol('AsyncHook');
    function isAsyncHook(thing) {
        if (thing && thing['__symbol'] === AsyncHookSymbol) {
            // FIXME@wzhudev: should not be undefined but a symbol here
            return true;
        }
        return false;
    }
    function prettyPrintIdentifier(id) {
        if (typeof id === 'undefined') {
            return 'undefined';
        }
        return isCtor(id) && !id[IdentifierDecoratorSymbol]
            ? id.name
            : id.toString();
    }

    exports.Quantity = void 0;
    (function (Quantity) {
        Quantity["MANY"] = "many";
        Quantity["OPTIONAL"] = "optional";
        Quantity["REQUIRED"] = "required";
    })(exports.Quantity || (exports.Quantity = {}));
    exports.LookUp = void 0;
    (function (LookUp) {
        LookUp["SELF"] = "self";
        LookUp["SKIP_SELF"] = "skipSelf";
    })(exports.LookUp || (exports.LookUp = {}));

    var __extends$4 = (undefined && undefined.__extends) || (function () {
        var extendStatics = function (d, b) {
            extendStatics = Object.setPrototypeOf ||
                ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
                function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
            return extendStatics(d, b);
        };
        return function (d, b) {
            if (typeof b !== "function" && b !== null)
                throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
            extendStatics(d, b);
            function __() { this.constructor = d; }
            d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
        };
    })();
    var RediError = /** @class */ (function (_super) {
        __extends$4(RediError, _super);
        function RediError(message) {
            return _super.call(this, "[redi]: ".concat(message)) || this;
        }
        return RediError;
    }(Error));

    var __extends$3 = (undefined && undefined.__extends) || (function () {
        var extendStatics = function (d, b) {
            extendStatics = Object.setPrototypeOf ||
                ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
                function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
            return extendStatics(d, b);
        };
        return function (d, b) {
            if (typeof b !== "function" && b !== null)
                throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
            extendStatics(d, b);
            function __() { this.constructor = d; }
            d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
        };
    })();
    var TARGET = Symbol('$$TARGET');
    var DEPENDENCIES = Symbol('$$DEPENDENCIES');
    var DependencyDescriptorNotFoundError = /** @class */ (function (_super) {
        __extends$3(DependencyDescriptorNotFoundError, _super);
        function DependencyDescriptorNotFoundError(index, target) {
            var msg = "Could not find dependency registered on the ".concat(index, " (indexed) parameter of the constructor of \"").concat(prettyPrintIdentifier(target), "\".");
            return _super.call(this, msg) || this;
        }
        return DependencyDescriptorNotFoundError;
    }(RediError));
    var IdentifierUndefinedError = /** @class */ (function (_super) {
        __extends$3(IdentifierUndefinedError, _super);
        function IdentifierUndefinedError(target, index) {
            var msg = "It seems that you register \"undefined\" as dependency on the ".concat(index + 1, " parameter of \"").concat(prettyPrintIdentifier(target), "\". Please make sure that there is not cyclic dependency among your TypeScript files, or consider using \"forwardRef\". For more info please visit our website https://redi.wendell.fun/docs/debug#could-not-find-dependency-registered-on");
            return _super.call(this, msg) || this;
        }
        return IdentifierUndefinedError;
    }(RediError));
    /**
     * @internal
     */
    function getDependencies(registerTarget) {
        var target = registerTarget;
        return target[DEPENDENCIES] || [];
    }
    /**
     * @internal
     */
    function getDependencyByIndex(registerTarget, index) {
        var allDependencies = getDependencies(registerTarget);
        var dep = allDependencies.find(function (descriptor) { return descriptor.paramIndex === index; });
        if (!dep) {
            throw new DependencyDescriptorNotFoundError(index, registerTarget);
        }
        return dep;
    }
    /**
     * @internal
     */
    function setDependency(registerTarget, identifier, paramIndex, quantity, lookUp) {
        if (quantity === void 0) { quantity = exports.Quantity.REQUIRED; }
        var descriptor = {
            paramIndex: paramIndex,
            identifier: identifier,
            quantity: quantity,
            lookUp: lookUp,
            withNew: false,
        };
        // sometimes identifier could be 'undefined' if user meant to pass in an ES class
        // this is related to how classes are transpiled
        if (typeof identifier === 'undefined') {
            throw new IdentifierUndefinedError(registerTarget, paramIndex);
        }
        var target = registerTarget;
        // deal with inheritance, subclass need to declare dependencies on its on
        if (target[TARGET] === target) {
            target[DEPENDENCIES].push(descriptor);
        }
        else {
            target[DEPENDENCIES] = [descriptor];
            target[TARGET] = target;
        }
    }
    var knownIdentifiers = new Set();
    /**
     * Create a dependency identifier
     *
     * @param id name of the identifier
     * @returns Identifier that could also be used as a decorator
     */
    function createIdentifier(id) {
        if (knownIdentifiers.has(id)) {
            throw new RediError("Identifier \"".concat(id, "\" already exists."));
        }
        else {
            knownIdentifiers.add(id);
        }
        var decorator = (function (registerTarget, _key, index) {
            setDependency(registerTarget, decorator, index);
        }); // decorator as an identifier
        // TODO: @wzhudev should assign a name to the function so it would be easy to debug in inspect tools
        // decorator.name = `[redi]: ${id}`;
        decorator.toString = function () { return id; };
        decorator[IdentifierDecoratorSymbol] = true;
        return decorator;
    }
    /**
     * @internal
     */
    /* istanbul ignore next */
    function TEST_ONLY_clearKnownIdentifiers() {
        knownIdentifiers.clear();
    }

    var __extends$2 = (undefined && undefined.__extends) || (function () {
        var extendStatics = function (d, b) {
            extendStatics = Object.setPrototypeOf ||
                ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
                function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
            return extendStatics(d, b);
        };
        return function (d, b) {
            if (typeof b !== "function" && b !== null)
                throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
            extendStatics(d, b);
            function __() { this.constructor = d; }
            d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
        };
    })();
    var QuantityCheckError = /** @class */ (function (_super) {
        __extends$2(QuantityCheckError, _super);
        function QuantityCheckError(id, quantity, actual) {
            var msg = "Expect \"".concat(quantity, "\" dependency items for id \"").concat(prettyPrintIdentifier(id), "\" but get ").concat(actual, ".");
            return _super.call(this, msg) || this;
        }
        return QuantityCheckError;
    }(RediError));
    function checkQuantity(id, quantity, length) {
        if ((quantity === exports.Quantity.OPTIONAL && length > 1) ||
            (quantity === exports.Quantity.REQUIRED && length !== 1)) {
            throw new QuantityCheckError(id, quantity, length);
        }
    }
    function retrieveQuantity(quantity, arr) {
        if (quantity === exports.Quantity.MANY) {
            return arr;
        }
        else {
            return arr[0];
        }
    }
    function changeQuantity(target, index, quantity) {
        var descriptor = getDependencyByIndex(target, index);
        descriptor.quantity = quantity;
    }
    function quantifyDecoratorFactoryProducer(quantity) {
        return function decoratorFactory(id) {
            if (this instanceof decoratorFactory) {
                return this;
            }
            return function (registerTarget, _key, index) {
                if (id) {
                    setDependency(registerTarget, id, index, quantity);
                }
                else {
                    if (quantity === exports.Quantity.REQUIRED) {
                        throw new IdentifierUndefinedError(registerTarget, index);
                    }
                    changeQuantity(registerTarget, index, quantity);
                }
            };
        };
    }
    var Many = quantifyDecoratorFactoryProducer(exports.Quantity.MANY);
    var Optional = quantifyDecoratorFactoryProducer(exports.Quantity.OPTIONAL);
    var Inject = quantifyDecoratorFactoryProducer(exports.Quantity.REQUIRED);

    function forwardRef(wrapper) {
        return {
            unwrap: wrapper,
        };
    }
    function isForwardRef(thing) {
        return !!thing && typeof thing.unwrap === 'function';
    }
    function normalizeForwardRef(id) {
        if (isForwardRef(id)) {
            return id.unwrap();
        }
        return id;
    }

    function isDisposable(thing) {
        return !!thing && typeof thing.dispose === 'function';
    }

    var __extends$1 = (undefined && undefined.__extends) || (function () {
        var extendStatics = function (d, b) {
            extendStatics = Object.setPrototypeOf ||
                ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
                function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
            return extendStatics(d, b);
        };
        return function (d, b) {
            if (typeof b !== "function" && b !== null)
                throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
            extendStatics(d, b);
            function __() { this.constructor = d; }
            d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
        };
    })();
    function isBareClassDependency(thing) {
        return thing.length === 1;
    }
    var ResolvingStack = [];
    function pushResolvingStack(id) {
        ResolvingStack.push(id);
    }
    function popupResolvingStack() {
        ResolvingStack.pop();
    }
    function clearResolvingStack() {
        ResolvingStack.length = 0;
    }
    var DependencyNotFoundForModuleError = /** @class */ (function (_super) {
        __extends$1(DependencyNotFoundForModuleError, _super);
        function DependencyNotFoundForModuleError(toInstantiate, id, index) {
            var _this = this;
            var msg = "Cannot find \"".concat(prettyPrintIdentifier(id), "\" registered by any injector. It is the ").concat(index, "th param of \"").concat(isIdentifierDecorator(toInstantiate)
                ? prettyPrintIdentifier(toInstantiate)
                : toInstantiate.name, "\". The stack of dependencies is: \"").concat(ResolvingStack.map(function (id) { return prettyPrintIdentifier(id); }).join(' -> '), "\".");
            _this = _super.call(this, msg) || this;
            clearResolvingStack();
            return _this;
        }
        return DependencyNotFoundForModuleError;
    }(RediError));
    var DependencyNotFoundError = /** @class */ (function (_super) {
        __extends$1(DependencyNotFoundError, _super);
        function DependencyNotFoundError(id) {
            var msg = "Cannot find \"".concat(prettyPrintIdentifier(id), "\" registered by any injector. The stack of dependencies is: \"").concat(ResolvingStack.map(function (id) { return prettyPrintIdentifier(id); }).join(' -> '), "\".");
            return _super.call(this, msg) || this;
        }
        return DependencyNotFoundError;
    }(RediError));
    /**
     * Store unresolved dependencies in an injector.
     *
     * @internal
     */
    var DependencyCollection = /** @class */ (function () {
        function DependencyCollection(dependencies) {
            var _this = this;
            this.dependencyMap = new Map();
            this.normalizeDependencies(dependencies).map(function (pair) {
                return _this.add(pair[0], pair[1]);
            });
        }
        DependencyCollection.prototype.add = function (ctorOrId, val) {
            if (typeof val === 'undefined') {
                val = { useClass: ctorOrId, lazy: false };
            }
            var arr = this.dependencyMap.get(ctorOrId);
            if (typeof arr === 'undefined') {
                arr = [];
                this.dependencyMap.set(ctorOrId, arr);
            }
            arr.push(val);
        };
        DependencyCollection.prototype.delete = function (id) {
            this.dependencyMap.delete(id);
        };
        DependencyCollection.prototype.get = function (id, quantity) {
            if (quantity === void 0) { quantity = exports.Quantity.REQUIRED; }
            var ret = this.dependencyMap.get(id);
            checkQuantity(id, quantity, ret.length);
            return retrieveQuantity(quantity, ret);
        };
        DependencyCollection.prototype.has = function (id) {
            return this.dependencyMap.has(id);
        };
        DependencyCollection.prototype.append = function (dependencies) {
            var _this = this;
            this.normalizeDependencies(dependencies).forEach(function (pair) {
                return _this.add(pair[0], pair[1]);
            });
        };
        DependencyCollection.prototype.dispose = function () {
            this.dependencyMap.clear();
        };
        /**
         * normalize dependencies to `DependencyItem`
         */
        DependencyCollection.prototype.normalizeDependencies = function (dependencies) {
            return dependencies.map(function (dependency) {
                var id = dependency[0];
                var val;
                if (isBareClassDependency(dependency)) {
                    val = {
                        useClass: dependency[0],
                        lazy: false,
                    };
                }
                else {
                    val = dependency[1];
                }
                return [id, val];
            });
        };
        return DependencyCollection;
    }());
    /**
     * Store resolved dependencies.
     *
     * @internal
     */
    var ResolvedDependencyCollection = /** @class */ (function () {
        function ResolvedDependencyCollection() {
            this.resolvedDependencies = new Map();
        }
        ResolvedDependencyCollection.prototype.add = function (id, val) {
            var arr = this.resolvedDependencies.get(id);
            if (typeof arr === 'undefined') {
                arr = [];
                this.resolvedDependencies.set(id, arr);
            }
            arr.push(val);
        };
        ResolvedDependencyCollection.prototype.has = function (id) {
            return this.resolvedDependencies.has(id);
        };
        ResolvedDependencyCollection.prototype.delete = function (id) {
            if (this.resolvedDependencies.has(id)) {
                var things = this.resolvedDependencies.get(id);
                things.forEach(function (t) { return (isDisposable(t) ? t.dispose() : void 0); });
                this.resolvedDependencies.delete(id);
            }
        };
        ResolvedDependencyCollection.prototype.get = function (id, quantity) {
            if (quantity === void 0) { quantity = exports.Quantity.REQUIRED; }
            var ret = this.resolvedDependencies.get(id);
            if (!ret) {
                throw new DependencyNotFoundError(id);
            }
            checkQuantity(id, quantity, ret.length);
            if (quantity === exports.Quantity.MANY) {
                return ret;
            }
            else {
                return ret[0];
            }
        };
        ResolvedDependencyCollection.prototype.dispose = function () {
            Array.from(this.resolvedDependencies.values()).forEach(function (items) {
                items.forEach(function (item) { return (isDisposable(item) ? item.dispose() : void 0); });
            });
            this.resolvedDependencies.clear();
        };
        return ResolvedDependencyCollection;
    }());

    function changeLookup(target, index, lookUp) {
        var descriptor = getDependencyByIndex(target, index);
        descriptor.lookUp = lookUp;
    }
    function lookupDecoratorFactoryProducer(lookUp) {
        return function DecoratorFactory() {
            if (this instanceof DecoratorFactory) {
                return this;
            }
            return function (target, _key, index) {
                changeLookup(target, index, lookUp);
            };
        };
    }
    /**
     * when resolving this dependency, skip the current injector
     */
    var SkipSelf = lookupDecoratorFactoryProducer(exports.LookUp.SKIP_SELF);
    /**
     * when resolving this dependency, only search the current injector
     */
    var Self = lookupDecoratorFactoryProducer(exports.LookUp.SELF);

    function changeToSelf(target, index, withNew) {
        var descriptor = getDependencyByIndex(target, index);
        descriptor.withNew = withNew;
    }
    function withNewDecoratorFactoryProducer(withNew) {
        return function DecoratorFactory() {
            if (this instanceof DecoratorFactory) {
                return this;
            }
            return function (target, _key, index) {
                changeToSelf(target, index, withNew);
            };
        };
    }
    /**
     * Always initialize a new instance of that dependency instead of getting the cached instance from the injector.
     */
    var WithNew = withNewDecoratorFactoryProducer(true);

    function normalizeFactoryDeps(deps) {
        if (!deps) {
            return [];
        }
        return deps.map(function (dep, index) {
            if (!Array.isArray(dep)) {
                return {
                    paramIndex: index,
                    identifier: dep,
                    quantity: exports.Quantity.REQUIRED,
                    withNew: false,
                };
            }
            var modifiers = dep.slice(0, dep.length - 1);
            var identifier = dep[dep.length - 1];
            var lookUp = undefined;
            var quantity = exports.Quantity.REQUIRED;
            var withNew = false;
            modifiers.forEach(function (modifier) {
                if (modifier instanceof Self) {
                    lookUp = exports.LookUp.SELF;
                }
                else if (modifier instanceof SkipSelf) {
                    lookUp = exports.LookUp.SKIP_SELF;
                }
                else if (modifier instanceof Optional) {
                    quantity = exports.Quantity.OPTIONAL;
                }
                else if (modifier instanceof Many) {
                    quantity = exports.Quantity.MANY;
                }
                else if (modifier instanceof WithNew) {
                    withNew = true;
                }
                else {
                    throw new RediError("unknown dep modifier ".concat(modifier, "."));
                }
            });
            return {
                paramIndex: index,
                identifier: identifier,
                quantity: quantity,
                lookUp: lookUp,
                withNew: withNew,
            };
        });
    }

    /**
     * this run the callback when CPU is idle. Will fallback to setTimeout if
     * the browser doesn't support requestIdleCallback
     */
    var runWhenIdle;
    (function () {
        if (typeof requestIdleCallback !== 'undefined' &&
            typeof cancelIdleCallback !== 'undefined') {
            // use native requestIdleCallback
            runWhenIdle = function (runner, timeout) {
                var handle = requestIdleCallback(runner, typeof timeout === 'number' ? { timeout: timeout } : undefined);
                var disposed = false;
                return function () {
                    if (disposed) {
                        return;
                    }
                    disposed = true;
                    cancelIdleCallback(handle);
                };
            };
        }
        else {
            // use setTimeout as hack
            var dummyIdle_1 = Object.freeze({
                didTimeout: true,
                timeRemaining: function () {
                    return 15;
                },
            });
            runWhenIdle = function (runner) {
                var handle = setTimeout(function () { return runner(dummyIdle_1); });
                var disposed = false;
                return function () {
                    if (disposed) {
                        return;
                    }
                    disposed = true;
                    clearTimeout(handle);
                };
            };
        }
    })();
    /**
     * a wrapper of a executor so it can be evaluated when it's necessary or the CPU is idle
     *
     * the type of the returned value of the executor would be T
     */
    var IdleValue = /** @class */ (function () {
        function IdleValue(executor) {
            var _this = this;
            this.didRun = false;
            this.selfExecutor = function () {
                try {
                    _this.value = executor();
                }
                catch (err) {
                    _this.error = err;
                }
                finally {
                    _this.didRun = true;
                }
            };
            this.disposeCallback = runWhenIdle(function () { return _this.selfExecutor(); });
        }
        IdleValue.prototype.hasRun = function () {
            return this.didRun;
        };
        IdleValue.prototype.dispose = function () {
            this.disposeCallback();
        };
        IdleValue.prototype.getValue = function () {
            if (!this.didRun) {
                this.dispose();
                this.selfExecutor();
            }
            if (this.error) {
                throw this.error;
            }
            return this.value;
        };
        return IdleValue;
    }());

    var __extends = (undefined && undefined.__extends) || (function () {
        var extendStatics = function (d, b) {
            extendStatics = Object.setPrototypeOf ||
                ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
                function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
            return extendStatics(d, b);
        };
        return function (d, b) {
            if (typeof b !== "function" && b !== null)
                throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
            extendStatics(d, b);
            function __() { this.constructor = d; }
            d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
        };
    })();
    var __assign = (undefined && undefined.__assign) || function () {
        __assign = Object.assign || function(t) {
            for (var s, i = 1, n = arguments.length; i < n; i++) {
                s = arguments[i];
                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                    t[p] = s[p];
            }
            return t;
        };
        return __assign.apply(this, arguments);
    };
    var __spreadArray = (undefined && undefined.__spreadArray) || function (to, from, pack) {
        if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
            if (ar || !(i in from)) {
                if (!ar) ar = Array.prototype.slice.call(from, 0, i);
                ar[i] = from[i];
            }
        }
        return to.concat(ar || Array.prototype.slice.call(from));
    };
    var MAX_RESOLUTIONS_QUEUED = 300;
    var NotInstantiatedSymbol = Symbol('$$NOT_INSTANTIATED_SYMBOL');
    var CircularDependencyError = /** @class */ (function (_super) {
        __extends(CircularDependencyError, _super);
        function CircularDependencyError(id) {
            return _super.call(this, "Detecting cyclic dependency. The last identifier is \"".concat(prettyPrintIdentifier(id), "\".")) || this;
        }
        return CircularDependencyError;
    }(RediError));
    var InjectorAlreadyDisposedError = /** @class */ (function (_super) {
        __extends(InjectorAlreadyDisposedError, _super);
        function InjectorAlreadyDisposedError() {
            return _super.call(this, 'Injector cannot be accessed after it was disposed.') || this;
        }
        return InjectorAlreadyDisposedError;
    }(RediError));
    var AsyncItemReturnAsyncItemError = /** @class */ (function (_super) {
        __extends(AsyncItemReturnAsyncItemError, _super);
        function AsyncItemReturnAsyncItemError(id) {
            return _super.call(this, "Async item \"".concat(prettyPrintIdentifier(id), "\" returns another async item.")) || this;
        }
        return AsyncItemReturnAsyncItemError;
    }(RediError));
    var GetAsyncItemFromSyncApiError = /** @class */ (function (_super) {
        __extends(GetAsyncItemFromSyncApiError, _super);
        function GetAsyncItemFromSyncApiError(id) {
            return _super.call(this, "Cannot get async item \"".concat(prettyPrintIdentifier(id), "\" from sync api.")) || this;
        }
        return GetAsyncItemFromSyncApiError;
    }(RediError));
    var AddDependencyAfterResolutionError = /** @class */ (function (_super) {
        __extends(AddDependencyAfterResolutionError, _super);
        function AddDependencyAfterResolutionError(id) {
            return _super.call(this, "Cannot add dependency \"".concat(prettyPrintIdentifier(id), "\" after it is already resolved.")) || this;
        }
        return AddDependencyAfterResolutionError;
    }(RediError));
    var DeleteDependencyAfterResolutionError = /** @class */ (function (_super) {
        __extends(DeleteDependencyAfterResolutionError, _super);
        function DeleteDependencyAfterResolutionError(id) {
            return _super.call(this, "Cannot dependency dependency \"".concat(prettyPrintIdentifier(id), "\" after it is already resolved.")) || this;
        }
        return DeleteDependencyAfterResolutionError;
    }(RediError));
    /**
     *
     */
    var Injector = /** @class */ (function () {
        /**
         * Create a new `Injector` instance
         * @param dependencies Dependencies that should be resolved by this injector instance.
         * @param parent Optional parent injector.
         */
        function Injector(dependencies, parent) {
            if (parent === void 0) { parent = null; }
            this.parent = parent;
            this.children = [];
            this.resolutionOngoing = 0;
            this.disposed = false;
            this.dependencyCollection = new DependencyCollection(dependencies || []);
            this.resolvedDependencyCollection = new ResolvedDependencyCollection();
            if (parent) {
                parent.children.push(this);
            }
        }
        /**
         * Create a child inject with a set of dependencies.
         * @param dependencies Dependencies that should be resolved by the newly created child injector.
         * @returns The child injector.
         */
        Injector.prototype.createChild = function (dependencies) {
            this._ensureInjectorNotDisposed();
            return new Injector(dependencies, this);
        };
        /**
         * Dispose the injector and all dependencies held by this injector. Note that its child injectors will dispose first.
         */
        Injector.prototype.dispose = function () {
            // Dispose child injectors first.
            this.children.forEach(function (c) { return c.dispose(); });
            this.children.length = 0;
            // Call `dispose` method on each instantiated dependencies if they are `IDisposable` and clear collections.
            this.dependencyCollection.dispose();
            this.resolvedDependencyCollection.dispose();
            this.deleteSelfFromParent();
            this.disposed = true;
        };
        Injector.prototype.deleteSelfFromParent = function () {
            if (this.parent) {
                var index = this.parent.children.indexOf(this);
                if (index > -1) {
                    this.parent.children.splice(index, 1);
                }
            }
        };
        /**
         * Add a dependency or its instance into injector. It would throw an error if the dependency
         * has already been instantiated.
         *
         * @param dependency The dependency or an instance that would be add in the injector.
         */
        Injector.prototype.add = function (dependency) {
            this._ensureInjectorNotDisposed();
            var identifierOrCtor = dependency[0];
            var item = dependency[1];
            if (this.resolvedDependencyCollection.has(identifierOrCtor)) {
                throw new AddDependencyAfterResolutionError(identifierOrCtor);
            }
            if (typeof item === 'undefined') {
                // Add dependency
                this.dependencyCollection.add(identifierOrCtor);
            }
            else if (isAsyncDependencyItem(item) ||
                isClassDependencyItem(item) ||
                isValueDependencyItem(item) ||
                isFactoryDependencyItem(item)) {
                // Add dependency
                this.dependencyCollection.add(identifierOrCtor, item);
            }
            else {
                // Add instance
                this.resolvedDependencyCollection.add(identifierOrCtor, item);
            }
        };
        /**
         * Replace an injection mapping for interface-based injection. It would throw an error if the dependency
         * has already been instantiated.
         *
         * @param dependency The dependency that will replace the already existed dependency.
         */
        Injector.prototype.replace = function (dependency) {
            this._ensureInjectorNotDisposed();
            var identifier = dependency[0];
            if (this.resolvedDependencyCollection.has(identifier)) {
                throw new AddDependencyAfterResolutionError(identifier);
            }
            this.dependencyCollection.delete(identifier);
            if (dependency.length === 1) {
                this.dependencyCollection.add(identifier);
            }
            else {
                this.dependencyCollection.add(identifier, dependency[1]);
            }
        };
        /**
         * Delete a dependency from an injector. It would throw an error when the deleted dependency
         * has already been instantiated.
         *
         * @param identifier The identifier of the dependency that is supposed to be deleted.
         */
        Injector.prototype.delete = function (identifier) {
            this._ensureInjectorNotDisposed();
            if (this.resolvedDependencyCollection.has(identifier)) {
                throw new DeleteDependencyAfterResolutionError(identifier);
            }
            this.dependencyCollection.delete(identifier);
        };
        /**
         * Invoke a function with dependencies injected. The function could only get dependency from the injector
         * and other methods are not accessible for the function.
         *
         * @param cb the function to be executed
         * @param args arguments to be passed into the function
         * @returns the return value of the function
         */
        Injector.prototype.invoke = function (cb) {
            var _this = this;
            var args = [];
            for (var _i = 1; _i < arguments.length; _i++) {
                args[_i - 1] = arguments[_i];
            }
            this._ensureInjectorNotDisposed();
            var accessor = {
                get: function (id, quantityOrLookup, lookUp) {
                    return _this._get(id, quantityOrLookup, lookUp);
                },
            };
            return cb.apply(void 0, __spreadArray([accessor], args, false));
        };
        /**
         * Check if the injector could initialize a dependency.
         *
         * @param id Identifier of the dependency
         */
        Injector.prototype.has = function (id) {
            var _a;
            return this.dependencyCollection.has(id) || ((_a = this.parent) === null || _a === void 0 ? void 0 : _a.has(id)) || false;
        };
        /**
         * Get dependency instance(s).
         *
         * @param id Identifier of the dependency
         * @param quantityOrLookup @link{Quantity} or @link{LookUp}
         * @param lookUp @link{LookUp}
         */
        Injector.prototype.get = function (id, quantityOrLookup, lookUp) {
            this._ensureInjectorNotDisposed();
            try {
                var newResult = this._get(id, quantityOrLookup, lookUp);
                if ((Array.isArray(newResult) && newResult.some(function (r) { return isAsyncHook(r); })) || isAsyncHook(newResult)) {
                    throw new GetAsyncItemFromSyncApiError(id);
                }
                return newResult;
            }
            catch (e) {
                if (e instanceof DependencyNotFoundError) {
                    clearResolvingStack();
                }
                throw e;
            }
        };
        Injector.prototype._get = function (id, quantityOrLookup, lookUp, toSelf) {
            var quantity = exports.Quantity.REQUIRED;
            if (quantityOrLookup === exports.Quantity.REQUIRED ||
                quantityOrLookup === exports.Quantity.OPTIONAL ||
                quantityOrLookup === exports.Quantity.MANY) {
                quantity = quantityOrLookup;
            }
            else {
                lookUp = quantityOrLookup;
            }
            if (!toSelf) {
                // see if the dependency is already resolved, return it and check quantity
                var cachedResult = this.getValue(id, quantity, lookUp);
                if (cachedResult !== NotInstantiatedSymbol) {
                    return cachedResult;
                }
            }
            // see if the dependency can be instantiated by itself or its parent
            return this.createDependency(id, quantity, lookUp, !toSelf);
        };
        /**
         * Get a dependency in the async way.
         */
        Injector.prototype.getAsync = function (id) {
            this._ensureInjectorNotDisposed();
            var cachedResult = this.getValue(id, exports.Quantity.REQUIRED);
            if (cachedResult !== NotInstantiatedSymbol) {
                return Promise.resolve(cachedResult);
            }
            var newResult = this.createDependency(id, exports.Quantity.REQUIRED);
            if (!isAsyncHook(newResult)) {
                return Promise.resolve(newResult);
            }
            return newResult.whenReady();
        };
        /**
         * Instantiate a class. The created instance would not be held by the injector.
         */
        Injector.prototype.createInstance = function (ctor) {
            var customArgs = [];
            for (var _i = 1; _i < arguments.length; _i++) {
                customArgs[_i - 1] = arguments[_i];
            }
            this._ensureInjectorNotDisposed();
            return this._resolveClassImpl.apply(this, __spreadArray([ctor], customArgs, false));
        };
        Injector.prototype._resolveDependency = function (id, item, shouldCache) {
            if (shouldCache === void 0) { shouldCache = true; }
            var result;
            pushResolvingStack(id);
            try {
                if (isValueDependencyItem(item)) {
                    result = this._resolveValueDependency(id, item);
                }
                else if (isFactoryDependencyItem(item)) {
                    result = this._resolveFactory(id, item, shouldCache);
                }
                else if (isClassDependencyItem(item)) {
                    result = this._resolveClass(id, item, shouldCache);
                }
                else if (isExistingDependencyItem(item)) {
                    result = this._resolveExisting(id, item);
                }
                else {
                    result = this._resolveAsync(id, item);
                }
                popupResolvingStack();
            }
            catch (e) {
                popupResolvingStack();
                throw e;
            }
            return result;
        };
        Injector.prototype._resolveExisting = function (id, item) {
            var thing = this.get(item.useExisting);
            this.resolvedDependencyCollection.add(id, thing);
            return thing;
        };
        Injector.prototype._resolveValueDependency = function (id, item) {
            var thing = item.useValue;
            this.resolvedDependencyCollection.add(id, thing);
            return thing;
        };
        Injector.prototype._resolveClass = function (id, item, shouldCache) {
            var _this = this;
            if (shouldCache === void 0) { shouldCache = true; }
            var ctor = item.useClass;
            var thing;
            if (item.lazy) {
                var idle_1 = new IdleValue(function () {
                    _this._ensureInjectorNotDisposed();
                    return _this._resolveClassImpl(ctor);
                });
                thing = new Proxy(Object.create(null), {
                    get: function (target, key) {
                        var _a;
                        if (key in target) {
                            return target[key]; // such as toString
                        }
                        // hack checking if it's a async loader
                        if (key === 'whenReady') {
                            return undefined;
                        }
                        var hasInstantiated = idle_1.hasRun();
                        var thing = idle_1.getValue();
                        if (!hasInstantiated) {
                            (_a = item.onInstantiation) === null || _a === void 0 ? void 0 : _a.call(item, thing);
                        }
                        var property = thing[key];
                        if (typeof property !== 'function') {
                            return property;
                        }
                        property = property.bind(thing);
                        target[key] = property;
                        return property;
                    },
                    set: function (_target, key, value) {
                        ;
                        idle_1.getValue()[key] = value;
                        return true;
                    },
                });
            }
            else {
                thing = this._resolveClassImpl(ctor);
            }
            if (id && shouldCache) {
                this.resolvedDependencyCollection.add(id, thing);
            }
            return thing;
        };
        Injector.prototype._resolveClassImpl = function (ctor) {
            var extraParams = [];
            for (var _i = 1; _i < arguments.length; _i++) {
                extraParams[_i - 1] = arguments[_i];
            }
            this.markNewResolution(ctor);
            var declaredDependencies = getDependencies(ctor)
                .sort(function (a, b) { return a.paramIndex - b.paramIndex; })
                .map(function (descriptor) { return (__assign(__assign({}, descriptor), { identifier: normalizeForwardRef(descriptor.identifier) })); });
            var resolvedArgs = [];
            for (var _a = 0, declaredDependencies_1 = declaredDependencies; _a < declaredDependencies_1.length; _a++) {
                var dep = declaredDependencies_1[_a];
                // recursive happens here
                try {
                    var thing_1 = this._get(dep.identifier, dep.quantity, dep.lookUp, dep.withNew);
                    resolvedArgs.push(thing_1);
                }
                catch (error) {
                    if (error instanceof DependencyNotFoundError) {
                        throw new DependencyNotFoundForModuleError(ctor, dep.identifier, dep.paramIndex);
                    }
                    throw error;
                }
            }
            var args = __spreadArray([], extraParams, true);
            var firstDependencyArgIndex = declaredDependencies.length > 0
                ? declaredDependencies[0].paramIndex
                : args.length;
            if (args.length !== firstDependencyArgIndex) {
                console.warn("[redi]: Expect ".concat(firstDependencyArgIndex, " custom parameter(s) of ").concat(ctor.toString(), " but get ").concat(args.length, "."));
                var delta = firstDependencyArgIndex - args.length;
                if (delta > 0) {
                    args = __spreadArray(__spreadArray([], args, true), new Array(delta).fill(undefined), true);
                }
                else {
                    args = args.slice(0, firstDependencyArgIndex);
                }
            }
            var thing = new (ctor.bind.apply(ctor, __spreadArray(__spreadArray([void 0], args, false), resolvedArgs, false)))();
            this.markResolutionCompleted();
            return thing;
        };
        Injector.prototype._resolveFactory = function (id, item, shouldCache) {
            var _a;
            this.markNewResolution(id);
            var declaredDependencies = normalizeFactoryDeps(item.deps);
            var resolvedArgs = [];
            for (var _i = 0, declaredDependencies_2 = declaredDependencies; _i < declaredDependencies_2.length; _i++) {
                var dep = declaredDependencies_2[_i];
                try {
                    var thing_2 = this._get(dep.identifier, dep.quantity, dep.lookUp, dep.withNew);
                    resolvedArgs.push(thing_2);
                }
                catch (error) {
                    if (error instanceof DependencyNotFoundError) {
                        throw new DependencyNotFoundForModuleError(id, dep.identifier, dep.paramIndex);
                    }
                    throw error;
                }
            }
            var thing = item.useFactory.apply(null, resolvedArgs);
            if (shouldCache) {
                this.resolvedDependencyCollection.add(id, thing);
            }
            this.markResolutionCompleted();
            (_a = item === null || item === void 0 ? void 0 : item.onInstantiation) === null || _a === void 0 ? void 0 : _a.call(item, thing);
            return thing;
        };
        Injector.prototype._resolveAsync = function (id, item) {
            var _this = this;
            var asyncLoader = {
                __symbol: AsyncHookSymbol,
                whenReady: function () { return _this._resolveAsyncImpl(id, item); },
            };
            return asyncLoader;
        };
        Injector.prototype._resolveAsyncImpl = function (id, item) {
            var _this = this;
            return item.useAsync().then(function (thing) {
                // check if another promise has been resolved,
                // do not resolve the async item twice
                var resolvedCheck = _this.getValue(id);
                if (resolvedCheck !== NotInstantiatedSymbol) {
                    return resolvedCheck;
                }
                var ret;
                if (Array.isArray(thing)) {
                    var item_1 = thing[1];
                    if (isAsyncDependencyItem(item_1)) {
                        throw new AsyncItemReturnAsyncItemError(id);
                    }
                    else {
                        ret = _this._resolveDependency(id, item_1);
                    }
                }
                else if (isCtor(thing)) {
                    ret = _this._resolveClassImpl(thing);
                }
                else {
                    ret = thing;
                }
                _this.resolvedDependencyCollection.add(id, ret);
                return ret;
            });
        };
        Injector.prototype.getValue = function (id, quantity, lookUp) {
            var _this = this;
            if (quantity === void 0) { quantity = exports.Quantity.REQUIRED; }
            var onSelf = function () {
                if (_this.dependencyCollection.has(id) &&
                    !_this.resolvedDependencyCollection.has(id)) {
                    return NotInstantiatedSymbol;
                }
                return _this.resolvedDependencyCollection.get(id, quantity);
            };
            var onParent = function () {
                if (_this.parent) {
                    return _this.parent.getValue(id, quantity);
                }
                else {
                    return NotInstantiatedSymbol;
                }
            };
            if (lookUp === exports.LookUp.SKIP_SELF) {
                return onParent();
            }
            if (lookUp === exports.LookUp.SELF) {
                return onSelf();
            }
            if (this.resolvedDependencyCollection.has(id) ||
                this.dependencyCollection.has(id)) {
                return onSelf();
            }
            return onParent();
        };
        Injector.prototype.createDependency = function (id, quantity, lookUp, shouldCache) {
            var _this = this;
            if (quantity === void 0) { quantity = exports.Quantity.REQUIRED; }
            if (shouldCache === void 0) { shouldCache = true; }
            var onSelf = function () {
                var registrations = _this.dependencyCollection.get(id, quantity);
                var ret = null;
                if (Array.isArray(registrations)) {
                    ret = registrations.map(function (dependencyItem) { return _this._resolveDependency(id, dependencyItem, shouldCache); });
                }
                else if (registrations) {
                    ret = _this._resolveDependency(id, registrations, shouldCache);
                }
                return ret;
            };
            var onParent = function () {
                if (_this.parent) {
                    return _this.parent.createDependency(id, quantity, undefined, shouldCache);
                }
                else {
                    if (quantity === exports.Quantity.OPTIONAL) {
                        return null;
                    }
                    pushResolvingStack(id);
                    throw new DependencyNotFoundError(id);
                }
            };
            if (lookUp === exports.LookUp.SKIP_SELF) {
                return onParent();
            }
            if (id === Injector) {
                return this;
            }
            if (this.dependencyCollection.has(id)) {
                return onSelf();
            }
            return onParent();
        };
        Injector.prototype.markNewResolution = function (id) {
            this.resolutionOngoing += 1;
            if (this.resolutionOngoing >= MAX_RESOLUTIONS_QUEUED) {
                throw new CircularDependencyError(id);
            }
        };
        Injector.prototype.markResolutionCompleted = function () {
            this.resolutionOngoing -= 1;
        };
        Injector.prototype._ensureInjectorNotDisposed = function () {
            if (this.disposed) {
                throw new InjectorAlreadyDisposedError();
            }
        };
        return Injector;
    }());

    /**
     * Register dependencies on a class.
     *
     * @param registerTarget The target constructor
     * @param deps Dependencies
     */
    function setDependencies(registerTarget, deps) {
        var normalizedDescriptors = normalizeFactoryDeps(deps);
        normalizedDescriptors.forEach(function (descriptor) {
            setDependency(registerTarget, descriptor.identifier, descriptor.paramIndex, descriptor.quantity, descriptor.lookUp);
        });
    }

    var globalObject = (typeof globalThis !== 'undefined' && globalThis) ||
        (typeof window !== 'undefined' && window) ||
        (typeof global !== 'undefined' && global);
    var __REDI_GLOBAL_LOCK__ = 'REDI_GLOBAL_LOCK';
    var isNode = typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
    if (globalObject[__REDI_GLOBAL_LOCK__]) {
        if (!isNode) {
            console.error("[redi]: You are loading scripts of redi more than once! This may cause undesired behavior in your application.\nMaybe your dependencies added redi as its dependency and bundled redi to its dist files. Or you import different versions of redi.\nFor more info please visit our website: https://redi.wendell.fun/en-US/docs/debug#import-scripts-of-redi-more-than-once");
        }
    }
    else {
        globalObject[__REDI_GLOBAL_LOCK__] = true;
    }

    exports.Inject = Inject;
    exports.Injector = Injector;
    exports.Many = Many;
    exports.Optional = Optional;
    exports.RediError = RediError;
    exports.Self = Self;
    exports.SkipSelf = SkipSelf;
    exports.WithNew = WithNew;
    exports.createIdentifier = createIdentifier;
    exports.forwardRef = forwardRef;
    exports.isAsyncDependencyItem = isAsyncDependencyItem;
    exports.isAsyncHook = isAsyncHook;
    exports.isClassDependencyItem = isClassDependencyItem;
    exports.isCtor = isCtor;
    exports.isDisposable = isDisposable;
    exports.isFactoryDependencyItem = isFactoryDependencyItem;
    exports.isValueDependencyItem = isValueDependencyItem;
    exports.setDependencies = setDependencies;

    Object.defineProperty(exports, '__esModule', { value: true });

}));
//# sourceMappingURL=redi.js.map