nope-js-node/dist-nodejs/loader/generateNopeBasicPackage.js

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

"use strict";
/**
 * @author Martin Karkowski
 * @email m.karkowski@zema.de
 * @desc [description]
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.generateNopeBasicPackage = void 0;
const inversify_1 = require("inversify");
const getDispatcher_1 = require("../dispatcher/getDispatcher");
const nopeDispatcher_1 = require("../dispatcher/nopeDispatcher");
const eventEmitter_1 = require("../eventEmitter");
const BaseModule_1 = require("../module/BaseModule");
const nopeObservable_1 = require("../observables/nopeObservable");
const nopeObservable_injectable_1 = require("../observables/nopeObservable.injectable");
const identifiers_1 = require("../symbols/identifiers");
(0, inversify_1.decorate)((0, inversify_1.injectable)(), nopeDispatcher_1.NopeDispatcher);
(0, inversify_1.decorate)((0, inversify_1.injectable)(), nopeObservable_1.NopeObservable);
(0, inversify_1.decorate)((0, inversify_1.injectable)(), BaseModule_1.NopeBaseModule);
/**
 * Generates the Default Package, containing all relevant elements of the
 * nope-package. This package is used by the {@link NopePackageLoader} to
 * provided a basic package, which could be used for injecting different
 * nope-elements into other elements. (To make use of injection, checkout https://inversify.io/)
 *
 * @export
 * @param options ommunicationLayer The Layer, which should be used.
 * @param {boolean} singleton Enables a Single Dispatcher in a Process. Otherwise multiple Dispatchers are used.
 * @return {*}
 */
function generateNopeBasicPackage(options, singleton = false) {
    const TYPES = {
        dispatcher: identifiers_1.DISPATCHER_INSTANCE,
        observableFactory: identifiers_1.OBSERVABLE_FACTORY,
        emitterFactory: identifiers_1.EMITTER_FACTORY,
        observable: identifiers_1.OBSERVABLE_INSTANCE,
        emitter: identifiers_1.EMITTER_INSTANCE,
        communicationLayer: identifiers_1.COMMUNICATION_LAYER,
        dispatcherOptions: identifiers_1.DISPATCHER_OPTIONS,
    };
    const definedPackage = {
        activationHandlers: [],
        autostart: {},
        defaultInstances: [],
        nameOfPackage: "nopeBasicPackage",
        providedClasses: [
            {
                description: {
                    name: "nopeDispatcher",
                    selector: TYPES.dispatcher,
                    // We want to provide in this Situation allways the same dispatcher.
                    // type: !singleton ? InjectableNopeDispatcher : getDispatcher(options, null, singleton),
                    type: (0, getDispatcher_1.getDispatcher)(options, {
                        singleton,
                        useLinkedServices: true,
                    }),
                    options: {
                        // Shouldn't be required:
                        // scope: singleton ? "inSingletonScope" : undefined,
                        // toConstant: singleton ? true : undefined
                        toConstant: true,
                    },
                },
                settings: {
                    allowInstanceGeneration: false,
                },
            },
            {
                description: {
                    name: "dispatcherOptions",
                    selector: TYPES.dispatcherOptions,
                    type: options,
                    options: {
                        toConstant: true,
                    },
                },
                settings: {
                    allowInstanceGeneration: false,
                },
            },
            {
                description: {
                    name: "nopeEmitter",
                    selector: TYPES.emitter,
                    factorySelector: TYPES.emitterFactory,
                    type: eventEmitter_1.InjectableNopeEventEmitter,
                },
                settings: {
                    allowInstanceGeneration: false,
                },
            },
            {
                description: {
                    name: "nopeObservable",
                    selector: TYPES.observable,
                    factorySelector: TYPES.observableFactory,
                    type: nopeObservable_injectable_1.InjectableNopeObservable,
                },
                settings: {
                    allowInstanceGeneration: false,
                },
            },
        ],
        providedServices: [],
        requiredPackages: [],
        types: TYPES,
    };
    return definedPackage;
}
exports.generateNopeBasicPackage = generateNopeBasicPackage;