source: frontend/node_modules/emittery/index.js

'use strict';

const anyMap = new WeakMap();
const eventsMap = new WeakMap();
const producersMap = new WeakMap();
const anyProducer = Symbol('anyProducer');
const resolvedPromise = Promise.resolve();

const listenerAdded = Symbol('listenerAdded');
const listenerRemoved = Symbol('listenerRemoved');

function assertEventName(eventName) {
        if (typeof eventName !== 'string' && typeof eventName !== 'symbol') {
                throw new TypeError('eventName must be a string or a symbol');
        }
}

function assertListener(listener) {
        if (typeof listener !== 'function') {
                throw new TypeError('listener must be a function');
        }
}

function getListeners(instance, eventName) {
        const events = eventsMap.get(instance);
        if (!events.has(eventName)) {
                events.set(eventName, new Set());
        }

        return events.get(eventName);
}

function getEventProducers(instance, eventName) {
        const key = typeof eventName === 'string' || typeof eventName === 'symbol' ? eventName : anyProducer;
        const producers = producersMap.get(instance);
        if (!producers.has(key)) {
                producers.set(key, new Set());
        }

        return producers.get(key);
}

function enqueueProducers(instance, eventName, eventData) {
        const producers = producersMap.get(instance);
        if (producers.has(eventName)) {
                for (const producer of producers.get(eventName)) {
                        producer.enqueue(eventData);
                }
        }

        if (producers.has(anyProducer)) {
                const item = Promise.all([eventName, eventData]);
                for (const producer of producers.get(anyProducer)) {
                        producer.enqueue(item);
                }
        }
}

function iterator(instance, eventNames) {
        eventNames = Array.isArray(eventNames) ? eventNames : [eventNames];

        let isFinished = false;
        let flush = () => {};
        let queue = [];

        const producer = {
                enqueue(item) {
                        queue.push(item);
                        flush();
                },
                finish() {
                        isFinished = true;
                        flush();
                }
        };

        for (const eventName of eventNames) {
                getEventProducers(instance, eventName).add(producer);
        }

        return {
                async next() {
                        if (!queue) {
                                return {done: true};
                        }

                        if (queue.length === 0) {
                                if (isFinished) {
                                        queue = undefined;
                                        return this.next();
                                }

                                await new Promise(resolve => {
                                        flush = resolve;
                                });

                                return this.next();
                        }

                        return {
                                done: false,
                                value: await queue.shift()
                        };
                },

                async return(value) {
                        queue = undefined;

                        for (const eventName of eventNames) {
                                getEventProducers(instance, eventName).delete(producer);
                        }

                        flush();

                        return arguments.length > 0 ?
                                {done: true, value: await value} :
                                {done: true};
                },

                [Symbol.asyncIterator]() {
                        return this;
                }
        };
}

function defaultMethodNamesOrAssert(methodNames) {
        if (methodNames === undefined) {
                return allEmitteryMethods;
        }

        if (!Array.isArray(methodNames)) {
                throw new TypeError('`methodNames` must be an array of strings');
        }

        for (const methodName of methodNames) {
                if (!allEmitteryMethods.includes(methodName)) {
                        if (typeof methodName !== 'string') {
                                throw new TypeError('`methodNames` element must be a string');
                        }

                        throw new Error(`${methodName} is not Emittery method`);
                }
        }

        return methodNames;
}

const isListenerSymbol = symbol => symbol === listenerAdded || symbol === listenerRemoved;

class Emittery {
        static mixin(emitteryPropertyName, methodNames) {
                methodNames = defaultMethodNamesOrAssert(methodNames);
                return target => {
                        if (typeof target !== 'function') {
                                throw new TypeError('`target` must be function');
                        }

                        for (const methodName of methodNames) {
                                if (target.prototype[methodName] !== undefined) {
                                        throw new Error(`The property \`${methodName}\` already exists on \`target\``);
                                }
                        }

                        function getEmitteryProperty() {
                                Object.defineProperty(this, emitteryPropertyName, {
                                        enumerable: false,
                                        value: new Emittery()
                                });
                                return this[emitteryPropertyName];
                        }

                        Object.defineProperty(target.prototype, emitteryPropertyName, {
                                enumerable: false,
                                get: getEmitteryProperty
                        });

                        const emitteryMethodCaller = methodName => function (...args) {
                                return this[emitteryPropertyName][methodName](...args);
                        };

                        for (const methodName of methodNames) {
                                Object.defineProperty(target.prototype, methodName, {
                                        enumerable: false,
                                        value: emitteryMethodCaller(methodName)
                                });
                        }

                        return target;
                };
        }

        constructor() {
                anyMap.set(this, new Set());
                eventsMap.set(this, new Map());
                producersMap.set(this, new Map());
        }

        on(eventNames, listener) {
                assertListener(listener);

                eventNames = Array.isArray(eventNames) ? eventNames : [eventNames];
                for (const eventName of eventNames) {
                        assertEventName(eventName);
                        getListeners(this, eventName).add(listener);

                        if (!isListenerSymbol(eventName)) {
                                this.emit(listenerAdded, {eventName, listener});
                        }
                }

                return this.off.bind(this, eventNames, listener);
        }

        off(eventNames, listener) {
                assertListener(listener);

                eventNames = Array.isArray(eventNames) ? eventNames : [eventNames];
                for (const eventName of eventNames) {
                        assertEventName(eventName);
                        getListeners(this, eventName).delete(listener);

                        if (!isListenerSymbol(eventName)) {
                                this.emit(listenerRemoved, {eventName, listener});
                        }
                }
        }

        once(eventNames) {
                return new Promise(resolve => {
                        const off = this.on(eventNames, data => {
                                off();
                                resolve(data);
                        });
                });
        }

        events(eventNames) {
                eventNames = Array.isArray(eventNames) ? eventNames : [eventNames];
                for (const eventName of eventNames) {
                        assertEventName(eventName);
                }

                return iterator(this, eventNames);
        }

        async emit(eventName, eventData) {
                assertEventName(eventName);

                enqueueProducers(this, eventName, eventData);

                const listeners = getListeners(this, eventName);
                const anyListeners = anyMap.get(this);
                const staticListeners = [...listeners];
                const staticAnyListeners = isListenerSymbol(eventName) ? [] : [...anyListeners];

                await resolvedPromise;
                await Promise.all([
                        ...staticListeners.map(async listener => {
                                if (listeners.has(listener)) {
                                        return listener(eventData);
                                }
                        }),
                        ...staticAnyListeners.map(async listener => {
                                if (anyListeners.has(listener)) {
                                        return listener(eventName, eventData);
                                }
                        })
                ]);
        }

        async emitSerial(eventName, eventData) {
                assertEventName(eventName);

                const listeners = getListeners(this, eventName);
                const anyListeners = anyMap.get(this);
                const staticListeners = [...listeners];
                const staticAnyListeners = [...anyListeners];

                await resolvedPromise;
                /* eslint-disable no-await-in-loop */
                for (const listener of staticListeners) {
                        if (listeners.has(listener)) {
                                await listener(eventData);
                        }
                }

                for (const listener of staticAnyListeners) {
                        if (anyListeners.has(listener)) {
                                await listener(eventName, eventData);
                        }
                }
                /* eslint-enable no-await-in-loop */
        }

        onAny(listener) {
                assertListener(listener);
                anyMap.get(this).add(listener);
                this.emit(listenerAdded, {listener});
                return this.offAny.bind(this, listener);
        }

        anyEvent() {
                return iterator(this);
        }

        offAny(listener) {
                assertListener(listener);
                this.emit(listenerRemoved, {listener});
                anyMap.get(this).delete(listener);
        }

        clearListeners(eventNames) {
                eventNames = Array.isArray(eventNames) ? eventNames : [eventNames];

                for (const eventName of eventNames) {
                        if (typeof eventName === 'string' || typeof eventName === 'symbol') {
                                getListeners(this, eventName).clear();

                                const producers = getEventProducers(this, eventName);

                                for (const producer of producers) {
                                        producer.finish();
                                }

                                producers.clear();
                        } else {
                                anyMap.get(this).clear();

                                for (const listeners of eventsMap.get(this).values()) {
                                        listeners.clear();
                                }

                                for (const producers of producersMap.get(this).values()) {
                                        for (const producer of producers) {
                                                producer.finish();
                                        }

                                        producers.clear();
                                }
                        }
                }
        }

        listenerCount(eventNames) {
                eventNames = Array.isArray(eventNames) ? eventNames : [eventNames];
                let count = 0;

                for (const eventName of eventNames) {
                        if (typeof eventName === 'string') {
                                count += anyMap.get(this).size + getListeners(this, eventName).size +
                                        getEventProducers(this, eventName).size + getEventProducers(this).size;
                                continue;
                        }

                        if (typeof eventName !== 'undefined') {
                                assertEventName(eventName);
                        }

                        count += anyMap.get(this).size;

                        for (const value of eventsMap.get(this).values()) {
                                count += value.size;
                        }

                        for (const value of producersMap.get(this).values()) {
                                count += value.size;
                        }
                }

                return count;
        }

        bindMethods(target, methodNames) {
                if (typeof target !== 'object' || target === null) {
                        throw new TypeError('`target` must be an object');
                }

                methodNames = defaultMethodNamesOrAssert(methodNames);

                for (const methodName of methodNames) {
                        if (target[methodName] !== undefined) {
                                throw new Error(`The property \`${methodName}\` already exists on \`target\``);
                        }

                        Object.defineProperty(target, methodName, {
                                enumerable: false,
                                value: this[methodName].bind(this)
                        });
                }
        }
}

const allEmitteryMethods = Object.getOwnPropertyNames(Emittery.prototype).filter(v => v !== 'constructor');

Object.defineProperty(Emittery, 'listenerAdded', {
        value: listenerAdded,
        writable: false,
        enumerable: true,
        configurable: false
});
Object.defineProperty(Emittery, 'listenerRemoved', {
        value: listenerRemoved,
        writable: false,
        enumerable: true,
        configurable: false
});

module.exports = Emittery;