@launchtray/tsyringe-async/dist/esm5/decorators/initializer.js

Lightweight dependency injection container for JavaScript/TypeScript, with asynchronous resolution

import { __awaiter, __generator, __values } from "tslib";
import { resolveParams } from "../resolve-params";
var initializersKey = Symbol("initializers");
var initializationPromiseKey = Symbol("initializationPromise");
function initializer() {
    return function (target, propertyKey, descriptor) {
        var originalMethod = descriptor.value;
        if (target[initializersKey] == null) {
            target[initializersKey] = [];
        }
        target[initializersKey].push(function (container, object) {
            return __awaiter(this, void 0, void 0, function () {
                var args;
                return __generator(this, function (_a) {
                    switch (_a.label) {
                        case 0: return [4, resolveParams(container, target, propertyKey)];
                        case 1:
                            args = _a.sent();
                            return [4, originalMethod.apply(object, args)];
                        case 2:
                            _a.sent();
                            return [2];
                    }
                });
            });
        });
    };
}
function createInitializationPromise(container, object) {
    return __awaiter(this, void 0, void 0, function () {
        var initializers, initializers_1, initializers_1_1, initializer_1, e_1_1;
        var e_1, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    initializers = object.constructor.prototype[initializersKey];
                    if (!(initializers != null)) return [3, 8];
                    _b.label = 1;
                case 1:
                    _b.trys.push([1, 6, 7, 8]);
                    initializers_1 = __values(initializers), initializers_1_1 = initializers_1.next();
                    _b.label = 2;
                case 2:
                    if (!!initializers_1_1.done) return [3, 5];
                    initializer_1 = initializers_1_1.value;
                    return [4, initializer_1(container, object)];
                case 3:
                    _b.sent();
                    _b.label = 4;
                case 4:
                    initializers_1_1 = initializers_1.next();
                    return [3, 2];
                case 5: return [3, 8];
                case 6:
                    e_1_1 = _b.sent();
                    e_1 = { error: e_1_1 };
                    return [3, 8];
                case 7:
                    try {
                        if (initializers_1_1 && !initializers_1_1.done && (_a = initializers_1.return)) _a.call(initializers_1);
                    }
                    finally { if (e_1) throw e_1.error; }
                    return [7];
                case 8: return [2];
            }
        });
    });
}
export function callInitializers(container, object) {
    return __awaiter(this, void 0, void 0, function () {
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    if (!(object != null &&
                        object.constructor != null &&
                        object.constructor.prototype != null &&
                        object.constructor.prototype[initializersKey] != null)) return [3, 2];
                    if (object[initializationPromiseKey] == null) {
                        object[initializationPromiseKey] = createInitializationPromise(container, object);
                    }
                    return [4, object[initializationPromiseKey]];
                case 1:
                    _a.sent();
                    _a.label = 2;
                case 2: return [2];
            }
        });
    });
}
export default initializer;