nope-js-node/dist-nodejs/dispatcher/getDispatcher.js

NoPE Runtime for Nodejs. For Browser-Support please use nope-browser

"use strict";
/**
 * @author Martin Karkowski
 * @email m.karkowski@zema.de
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.getDispatcher = void 0;
const eventEmitter_1 = require("../eventEmitter");
const singletonMethod_1 = require("../helpers/singletonMethod");
const GenericWrapper_1 = require("../module/GenericWrapper");
const nopeObservable_1 = require("../observables/nopeObservable");
const baseServices_1 = require("./baseServices");
const nopeDispatcher_1 = require("./nopeDispatcher");
const index_1 = require("../decorators/index");
const index_browser_1 = require("../logger/index.browser");
const LOGGER = (0, index_browser_1.getNopeLogger)("getDispatcher");
/**
 * Helper to get a Dispatcher.
 *
 *
 * ```typescript
 * // Create a communication layer:
 * const communicator = getLayer("event");
 * // Now create the Dispatcher.
 * const dispatcher = getDispatcher({communicator});
 * ```
 *
 * @export
 * @param {INopeDispatcherOptions} dispatcherOptions The options, that will be used for the dispatcher.
 * @param {TAdditionalOptions} [options={}]  Options. You can provide a different Dispatcher-Class; Controll the scope (Singleton or not.) and define wehter the Base-Services should be added etc. see {@link TAdditionalOptions}
 * @returns {INopeDispatcher} The dispatcher.
 */
function getDispatcher(dispatcherOptions, options = {}) {
    if (options.dispatcherConstructorClass === null ||
        options.dispatcherConstructorClass === undefined) {
        options.dispatcherConstructorClass = nopeDispatcher_1.NopeDispatcher;
    }
    options = Object.assign({
        constructorClass: null,
        singleton: true,
        useBaseServices: true,
        useLinkedServices: true,
    }, options);
    const create = () => {
        const dispatcher = new options.dispatcherConstructorClass(dispatcherOptions, () => new eventEmitter_1.NopeEventEmitter(), () => new nopeObservable_1.NopeObservable());
        // Register a default instance generator:
        // Defaultly generate a NopeGenericModule
        dispatcher.instanceManager.registerInternalWrapperGenerator("*", async (core, description) => {
            const mod = new GenericWrapper_1.NopeGenericWrapper(core, () => new eventEmitter_1.NopeEventEmitter(), () => new nopeObservable_1.NopeObservable());
            await mod.fromDescription(description, "overwrite");
            // await mod.init();
            return mod;
        });
        if (options.useBaseServices) {
            // Store the services
            (0, baseServices_1.addAllBaseServices)(dispatcher).then((services) => {
                dispatcher["services"] = services;
            });
        }
        if (options.useLinkedServices) {
            // Define a Container, which contains all functions.
            const container = (0, index_1.getCentralDecoratedContainer)();
            // If the Dispatcher has been connected, register all functions.
            dispatcher.ready.waitFor().then(() => {
                if (dispatcher.ready.getContent()) {
                    // Iterate over the Functions
                    for (const [uri, settings] of container.services.entries()) {
                        dispatcher.rpcManager
                            .registerService(settings.callback, {
                            ...settings.options,
                            id: uri,
                        })
                            .catch((e) => {
                            LOGGER.error(`Failed to add service ${uri}.`);
                            LOGGER.error(e);
                        });
                    }
                }
                else {
                    // Failed to Setup the Container.
                }
            });
        }
        // Return the Dispathcer
        return dispatcher;
    };
    if (options.singleton) {
        // Create a singaleton if required.
        // use the container to receive the
        // singleton object
        const container = (0, singletonMethod_1.getSingleton)("nopeBackendDispatcher.instance", create);
        return container.instance;
    }
    // No singleton is required =>
    // create a new instance.
    return create();
}
exports.getDispatcher = getDispatcher;