stix/dist/Library/ServiceManager/ServiceManager.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Error_1 = require("../Error");
const InjectedServiceFactory_1 = require("./InjectedServiceFactory");
const decorators_1 = require("./decorators");
/**
 * @export
 * @class ServiceManager
 * @implements {ServiceManagerInterface}
 */
class ServiceManager {
    constructor(config) {
        this.services = new Map();
        this.factories = new Map();
        this.aliases = {};
        this.shared = new Map();
        this.sharedByDefault = true;
        this.creationContext = this;
        if (config) {
            this.configure(config);
        }
    }
    get(Service, forceTransient = false) {
        const resolvedName = this.resolveName(Service);
        if (!this.has(resolvedName)) {
            throw new Error_1.NotFoundError(`Unable to locate service "${typeof Service === 'string' ? Service : Service.name}".`);
        }
        if (forceTransient || !this.services.has(resolvedName)) {
            const service = this.factories.get(resolvedName)(this.creationContext);
            const shared = this.shared.has(resolvedName) ? this.shared.get(resolvedName) : this.sharedByDefault;
            // Apply any patches registered with the @patch decorator
            decorators_1.applyPatches(this.creationContext, service);
            // We just needed a new instance or we don't want our instances to be shared.. Return service.
            if (forceTransient || !shared) {
                return service;
            }
            this.services.set(resolvedName, service);
        }
        return this.services.get(resolvedName);
    }
    has(Service) {
        const resolvedName = this.resolveName(Service);
        return this.services.has(resolvedName) || this.factories.has(resolvedName);
    }
    registerFactory(key, value) {
        this.factories.set(key, value);
        return this;
    }
    registerFactories(factories) {
        factories.forEach((value, key) => {
            this.registerFactory(key, value);
        });
        return this;
    }
    registerService(key, service) {
        this.services.set(key, service);
        return this;
    }
    configure(config) {
        if (typeof config.sharedByDefault === 'boolean') {
            this.sharedByDefault = config.sharedByDefault;
        }
        if (config.shared instanceof Map) {
            config.shared.forEach((value, key) => this.shared.set(key, value));
        }
        if (config.services instanceof Map) {
            config.services.forEach((value, key) => this.services.set(key, value));
        }
        if (config.invokables instanceof Map) {
            config.invokables.forEach((value, key) => {
                this.registerInvokable(key, value);
            });
        }
        if (config.factories instanceof Map) {
            this.registerFactories(config.factories);
        }
        if (config.aliases) {
            Object.assign(this.aliases, config.aliases);
        }
        return this;
    }
    registerInvokable(key, value) {
        this.factories.set(key, InjectedServiceFactory_1.InjectedServiceFactory(value));
    }
    registerAliases(aliases) {
        Object.assign(this.aliases, aliases);
        return this;
    }
    registerAlias(alias, to) {
        this.aliases[alias] = to;
        return this;
    }
    resolveName(name) {
        if (typeof name !== 'string') {
            return name;
        }
        return this.aliases[name] || name;
    }
}
exports.ServiceManager = ServiceManager;
//# sourceMappingURL=ServiceManager.js.map