@akala/core/dist/module.js

"use strict";
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
    result["default"] = mod;
    return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const di = __importStar(require("./global-injector"));
const orchestrator_1 = __importDefault(require("orchestrator"));
const events_1 = require("events");
const injector_1 = require("./injector");
process.hrtime = process.hrtime || require('browser-process-hrtime');
class ExtendableEvent {
    constructor() {
        this.promises = [];
    }
    waitUntil(p) {
        this.promises.push(p);
    }
    complete() {
        const done = () => {
            this._done = true;
        };
        return Promise.all(this.promises).then(done, done);
    }
    get done() { return this._done; }
}
exports.ExtendableEvent = ExtendableEvent;
class Module extends injector_1.Injector {
    constructor(name, dep) {
        super(moduleInjector);
        this.name = name;
        this.dep = dep;
        this.emitter = new events_1.EventEmitter();
        this.activateEvent = new ExtendableEvent();
        this.readyEvent = new ExtendableEvent();
        var existingModule = moduleInjector.resolve(name);
        if (existingModule && typeof (existingModule.dep) != 'undefined' && existingModule.dep.length && typeof (dep) != 'undefined' && dep.length)
            throw new Error('the module ' + existingModule.name + ' can be registered only once with dependencies');
        if (existingModule) {
            if (typeof (dep) != 'undefined') {
                delete Module.o.tasks[name + '#activate'];
                delete Module.o.tasks[name + '#ready'];
                delete Module.o.tasks[name];
                existingModule.dep = dep;
                moduleInjector.unregister(name);
                Module.registerModule(existingModule);
            }
            return existingModule;
        }
        Module.registerModule(this);
        this.emitter.setMaxListeners(0);
    }
    static registerModule(m) {
        var emitter = m.emitter;
        if (typeof m.dep == 'undefined')
            m.dep = [];
        Module.o.add(m.name + '#activate', m.dep.map(dep => dep.name + '#activate'), function () {
            emitter.emit('activate', m.activateEvent);
            return m.activateEvent.complete();
        });
        Module.o.add(m.name + '#ready', [m.name + '#activate'].concat(m.dep.map(dep => dep.name + '#ready')), function () {
            emitter.emit('ready', m.readyEvent);
            return m.readyEvent.complete();
        });
        Module.o.add(m.name, [m.name + '#ready'], function () { });
        moduleInjector.register(m.name, m);
    }
    ready(toInject, f) {
        if (!f)
            return (f) => this.ready(toInject, f);
        if (this.readyEvent.done)
            this.injectWithName(toInject, f)();
        else
            this.emitter.on('ready', this.injectWithName(toInject, f));
        return this;
    }
    readyAsync(toInject, f) {
        if (!f)
            return (f) => this.readyAsync(toInject, f);
        if (this.readyEvent.done)
            return this.injectWithNameAsync(toInject, f.bind(this.readyEvent));
        else
            this.emitter.on('ready', (ev) => { this.injectWithNameAsync(toInject, f.bind(ev)); });
        return this;
    }
    activate(toInject, f) {
        if (!f)
            return (f) => this.activate(toInject, f);
        if (this.activateEvent.done)
            this.injectWithName(toInject, f)();
        else
            this.emitter.on('activate', this.injectWithName(toInject, f));
        return this;
    }
    activateAsync(toInject, f) {
        if (!f)
            return (f) => this.activateAsync(toInject, f);
        if (this.readyEvent.done)
            return this.injectWithNameAsync(toInject, f.bind(this.readyEvent));
        else
            this.emitter.on('activate', (ev) => { this.injectWithNameAsync(toInject, f.bind(ev)); });
        return this;
    }
    activateNew(...toInject) {
        return (ctor) => {
            return this.activate(toInject, function (...args) {
                return new ctor(...args);
            });
        };
    }
    activateNewAsync(...toInject) {
        return function (ctor) {
            return this.activateAsync(toInject, function (...args) {
                return new ctor(...args);
            });
        };
    }
    readyNew(...toInject) {
        return (ctor) => {
            return this.ready(toInject, function (...args) {
                return new ctor(...args);
            });
        };
    }
    readyNewAsync(...toInject) {
        return function (ctor) {
            return this.readyAsync(toInject, function (...args) {
                return new ctor(...args);
            });
        };
    }
    start(toInject, f) {
        if (arguments.length > 0)
            Module.o.on('stop', this.injectWithName(toInject, f));
        else
            Module.o.start(this.name);
    }
}
exports.Module = Module;
Module.o = new orchestrator_1.default();
var moduleInjector = di.resolve('$modules');
if (!moduleInjector) {
    moduleInjector = new injector_1.Injector();
    di.register('$modules', moduleInjector);
}
//# sourceMappingURL=module.js.map