constructor()

in modularity/object-remoting-host-router.js [19:96]


    constructor(remote, localRouter) {
        /**
         * @private
         * @type {Array.<Donuts.Remote.IObjectRemotingProxy>}
         */
        this.proxies = [];

        /**
         * @private
         * @type {Donuts.Remote.ICommunicationHost}
         */
        this.remote = remote;

        /**
         * @private
         * @type {Donuts.Modularity.IObjectRemotingRouter}
         */
        this.local = localRouter;

        /**
         * @param {Donuts.Remote.IObjectRemotingProxy} requestor
         * @param {string} name
         * @param {...*} extraArgs
         * @returns {Promise<*>}
         */
        this.onResolve = async (requestor, name, ...extraArgs) => {
            /** @type {*} */
            let resolvedResult = await this.local.requestAsync(name, ...extraArgs);

            if (resolvedResult !== undefined) {
                return resolvedResult;
            }

            for (const proxy of this.proxies) {
                if (proxy === requestor) {
                    continue;
                }

                resolvedResult = await proxy.requestAsync(name, ...extraArgs);

                if (resolvedResult !== undefined) {
                    return resolvedResult;
                }
            }

            return undefined;
        };

        /**
         * @private
         * @param {Donuts.Remote.ICommunicationHost} host
         * @param {Donuts.Remote.ICommunicator} communicator
         * @returns {void}
         */
        this.onProxyConnection = (host, communicator) => {
            const proxy = new ObjectRemotingProxy(communicator, null, true);

            communicator.on("close", () => {
                if (!Array.isArray(this.proxies)) {
                    return;
                }

                const proxyIndex = this.proxies.findIndex((itemProxy) => itemProxy === proxy);

                if (proxyIndex < 0) {
                    return;
                }

                this.proxies.splice(proxyIndex, 1);
                proxy.disposeAsync();
            });

            proxy.resolver = this.onResolve;
            this.proxies.push(proxy);
        };

        this.remote.on("connection", this.onProxyConnection);
    }