@lakutata/core 1.0.60 → 3.0.0-beta.0

package/dist/esm/lib/base/internal/EventEmitter2.js

@@ -0,0 +1,711 @@
+/**
+ * Derived from lib/eventemitter2.js of eventemitter2 6.4.9 (MIT, see THIRD_PARTY_NOTICES.md): the event emitter of
+ * 2.x, with its wildcards (the parts of the namespaces of the events separated by the delimiter, "*" for a part and
+ * "**" for any parts). The API the framework uses is ported (listenTo, waitFor and the cancelable promises are not).
+ * The nodes of the listener tree have no prototype (an event named like a property of Object.prototype, such as
+ * "constructor", used the property in the upstream), and a listener both promisified and called in the next tick is
+ * called (the upstream only resolved its promise)
+ */
+const ownKeys = Reflect.ownKeys;
+function node() {
+    return Object.create(null);
+}
+export class EventEmitter2 {
+    /**
+     * The number of the listeners of an event above which a possible memory leak is warned of, for the emitters not
+     * given one (10; 0 for no warning)
+     */
+    static get defaultMaxListeners() {
+        return EventEmitter2.prototype._maxListeners;
+    }
+    static set defaultMaxListeners(n) {
+        if (typeof n !== 'number' || n < 0 || Number.isNaN(n))
+            throw TypeError('n must be a non-negative number');
+        EventEmitter2.prototype._maxListeners = n;
+    }
+    static {
+        //Like upstream: the default of the emitters not given a number of listeners, on the prototype
+        EventEmitter2.prototype._maxListeners = 10;
+    }
+    constructor(conf) {
+        this.delimiter = '.';
+        /**
+         * The event of the listener being called
+         */
+        this.event = '';
+        this.verboseMemoryLeak = false;
+        this._newListener = false;
+        this._removeListener = false;
+        this._events = {};
+        this.configure(conf);
+    }
+    init() {
+        this._events = {};
+        if (this._conf)
+            this.configure(this._conf);
+    }
+    configure(conf) {
+        if (!conf)
+            return;
+        this._conf = conf;
+        if (conf.delimiter)
+            this.delimiter = conf.delimiter;
+        if (conf.maxListeners !== undefined)
+            this._maxListeners = conf.maxListeners;
+        if (conf.wildcard)
+            this.wildcard = conf.wildcard;
+        if (conf.newListener)
+            this._newListener = conf.newListener;
+        if (conf.removeListener)
+            this._removeListener = conf.removeListener;
+        if (conf.verboseMemoryLeak)
+            this.verboseMemoryLeak = conf.verboseMemoryLeak;
+        if (conf.ignoreErrors)
+            this.ignoreErrors = conf.ignoreErrors;
+        if (this.wildcard)
+            this.listenerTree = node();
+    }
+    logPossibleMemoryLeak(count, eventName) {
+        let errorMsg = `(node) warning: possible EventEmitter memory leak detected. ${count} listeners added. Use emitter.setMaxListeners() to increase limit.`;
+        if (this.verboseMemoryLeak)
+            errorMsg += ` Event name: ${String(eventName)}.`;
+        const warning = new Error(errorMsg);
+        warning.name = 'MaxListenersExceededWarning';
+        warning.emitter = this;
+        warning.count = count;
+        process.emitWarning(warning);
+    }
+    /**
+     * The parts of an event
+     * @param type
+     */
+    split(type) {
+        if (typeof type !== 'string')
+            return type;
+        const parts = [];
+        let start = 0;
+        let index;
+        while ((index = type.indexOf(this.delimiter, start)) !== -1) {
+            parts.push(type.slice(start, index));
+            start = index + this.delimiter.length;
+        }
+        parts.push(type.slice(start));
+        return parts;
+    }
+    /**
+     * Collect the listeners of the tree matching an event (with the wildcards of the event and of the tree), and the
+     * nodes holding them
+     * @param handlers
+     * @param type
+     * @param tree
+     * @param i
+     * @param typeLength
+     */
+    searchListenerTree(handlers, type, tree, i, typeLength) {
+        if (!tree)
+            return null;
+        if (i === 0) {
+            const kind = typeof type;
+            if (kind === 'string') {
+                const parts = this.split(type);
+                typeLength = parts.length;
+                //Like upstream: the parts of a namespace in an array of 5 items at least, its length is the length of the
+                //event when the search starts again from a "**" (the events longer than their parts do not match there)
+                type = parts.length > 1 && parts.length < 5 ? Object.assign(new Array(5), parts) : parts;
+            }
+            else if (kind === 'object') {
+                typeLength = type.length;
+            }
+            else {
+                type = [type];
+                typeLength = 1;
+            }
+        }
+        let listeners = null;
+        let found;
+        const currentType = type[i];
+        const nextType = type[i + 1];
+        const add = (more) => {
+            if (!more)
+                return;
+            if (listeners)
+                listeners.push(...more);
+            else
+                listeners = more;
+        };
+        if (i === typeLength) {
+            //At the end of the event: the listeners of the node
+            if (tree._listeners) {
+                if (typeof tree._listeners === 'function')
+                    handlers?.push(tree._listeners);
+                else
+                    handlers?.push(...tree._listeners);
+                listeners = [tree];
+            }
+        }
+        else if (currentType === '*') {
+            //A part "*" of the event: any branch
+            const branches = ownKeys(tree);
+            let n = branches.length;
+            while (n-- > 0) {
+                const branch = branches[n];
+                if (branch !== '_listeners')
+                    add(this.searchListenerTree(handlers, type, tree[branch], i + 1, typeLength));
+            }
+            return listeners;
+        }
+        else if (currentType === '**') {
+            //A part "**" of the event: any parts
+            const endReached = i + 1 === typeLength || (i + 2 === typeLength && nextType === '*');
+            if (endReached && tree._listeners)
+                listeners = this.searchListenerTree(handlers, type, tree, typeLength, typeLength);
+            const branches = ownKeys(tree);
+            let n = branches.length;
+            while (n-- > 0) {
+                const branch = branches[n];
+                if (branch === '_listeners')
+                    continue;
+                if (branch === '*' || branch === '**') {
+                    if (tree[branch]._listeners && !endReached)
+                        add(this.searchListenerTree(handlers, type, tree[branch], typeLength, typeLength));
+                    found = this.searchListenerTree(handlers, type, tree[branch], i, typeLength);
+                }
+                else if (branch === nextType) {
+                    found = this.searchListenerTree(handlers, type, tree[branch], i + 2, typeLength);
+                }
+                else {
+                    //No match: deeper in the tree, at the same part of the event
+                    found = this.searchListenerTree(handlers, type, tree[branch], i, typeLength);
+                }
+                add(found);
+            }
+            return listeners;
+        }
+        else if (tree[currentType]) {
+            listeners = this.searchListenerTree(handlers, type, tree[currentType], i + 1, typeLength);
+        }
+        //A branch "*" of the tree matches any part
+        const xTree = tree['*'];
+        if (xTree)
+            this.searchListenerTree(handlers, type, xTree, i + 1, typeLength);
+        //A branch "**" of the tree matches any parts
+        const xxTree = tree['**'];
+        if (xxTree) {
+            if (i < typeLength) {
+                if (xxTree._listeners)
+                    this.searchListenerTree(handlers, type, xxTree, typeLength, typeLength);
+                const branches = ownKeys(xxTree);
+                let n = branches.length;
+                while (n-- > 0) {
+                    const branch = branches[n];
+                    if (branch === '_listeners')
+                        continue;
+                    if (branch === nextType) {
+                        //The next part matches: two parts further
+                        this.searchListenerTree(handlers, type, xxTree[branch], i + 2, typeLength);
+                    }
+                    else if (branch === currentType) {
+                        this.searchListenerTree(handlers, type, xxTree[branch], i + 1, typeLength);
+                    }
+                    else {
+                        const isolatedBranch = node();
+                        isolatedBranch[branch] = xxTree[branch];
+                        const isolatedTree = node();
+                        isolatedTree['**'] = isolatedBranch;
+                        this.searchListenerTree(handlers, type, isolatedTree, i + 1, typeLength);
+                    }
+                }
+            }
+            else if (xxTree._listeners) {
+                //The end of the event, still on a "**"
+                this.searchListenerTree(handlers, type, xxTree, typeLength, typeLength);
+            }
+            else if (xxTree['*'] && xxTree['*']._listeners) {
+                this.searchListenerTree(handlers, type, xxTree['*'], typeLength, typeLength);
+            }
+        }
+        return listeners;
+    }
+    growListenerTree(type, listener, prepend) {
+        const ns = typeof type === 'string' ? this.split(type) : type;
+        const len = ns.length;
+        //Two consecutive "**": the listener is not added
+        if (len > 1) {
+            for (let i = 0; i + 1 < len; i++)
+                if (ns[i] === '**' && ns[i + 1] === '**')
+                    return;
+        }
+        let tree = this.listenerTree;
+        for (let i = 0; i < len; i++) {
+            const name = ns[i];
+            tree = tree[name] || (tree[name] = node());
+            if (i === len - 1) {
+                if (!tree._listeners) {
+                    tree._listeners = listener;
+                }
+                else {
+                    if (typeof tree._listeners === 'function')
+                        tree._listeners = [tree._listeners];
+                    const listeners = tree._listeners;
+                    if (prepend)
+                        listeners.unshift(listener);
+                    else
+                        listeners.push(listener);
+                    if (!listeners.warned && this._maxListeners > 0 && listeners.length > this._maxListeners) {
+                        listeners.warned = true;
+                        this.logPossibleMemoryLeak(listeners.length, name);
+                    }
+                }
+                return true;
+            }
+        }
+        return true;
+    }
+    /**
+     * The events having listeners in a tree (the branches of a node having listeners count as events too, as upstream)
+     * @param tree
+     * @param events
+     * @param root
+     * @param asArray
+     */
+    collectTreeEvents(tree, events, root, asArray) {
+        const branches = ownKeys(tree);
+        let i = branches.length;
+        const hasListeners = tree._listeners;
+        while (i-- > 0) {
+            const branchName = branches[i];
+            const branch = tree[branchName];
+            const path = branchName === '_listeners' ? root : (root ? root.concat(branchName) : [branchName]);
+            const isArrayPath = !!asArray || typeof branchName === 'symbol';
+            if (hasListeners)
+                events.push(isArrayPath ? path : path.join(this.delimiter));
+            //Like upstream: the listeners removed by removeAllListeners() are null, the collecting throws on them
+            if (typeof branch === 'object')
+                this.collectTreeEvents(branch, events, path, isArrayPath);
+        }
+        return events;
+    }
+    /**
+     * Remove the branches without listeners: whether the node has a branch or listeners
+     * @param root
+     */
+    recursivelyGarbageCollect(root) {
+        const keys = ownKeys(root);
+        let i = keys.length;
+        let flag;
+        while (i-- > 0) {
+            const key = keys[i];
+            const obj = root[key];
+            if (obj) {
+                flag = true;
+                if (key !== '_listeners' && !this.recursivelyGarbageCollect(obj))
+                    delete root[key];
+            }
+        }
+        return flag;
+    }
+    /**
+     * The listener calling a listener asynchronously
+     * @param listener
+     * @param options
+     */
+    setupListener(listener, options) {
+        let async;
+        let promisify;
+        let nextTick;
+        if (options === true) {
+            promisify = true;
+        }
+        else if (options === false) {
+            async = true;
+        }
+        else {
+            if (!options || typeof options !== 'object')
+                throw TypeError('options should be an object or true');
+            async = options.async;
+            promisify = options.promisify;
+            nextTick = options.nextTick;
+        }
+        if (async || nextTick || promisify) {
+            const original = listener;
+            const origin = listener._origin || listener;
+            if (promisify === undefined)
+                promisify = listener.constructor.name === 'AsyncFunction';
+            async = true;
+            listener = function (...args) {
+                //The event of the call, the emitter calls the other listeners meanwhile
+                const context = this;
+                const event = this.event;
+                if (promisify) {
+                    return (nextTick ? Promise.resolve() : new Promise((resolve) => setImmediate(resolve))).then(() => {
+                        context.event = event;
+                        return original.apply(context, args);
+                    });
+                }
+                const call = () => {
+                    context.event = event;
+                    original.apply(context, args);
+                };
+                //Like upstream: the result of the scheduling
+                return nextTick ? process.nextTick(call) : setImmediate(call);
+            };
+            listener._async = async;
+            listener._origin = origin;
+        }
+        return listener;
+    }
+    setMaxListeners(n) {
+        if (n === undefined)
+            return;
+        this._maxListeners = n;
+        if (!this._conf)
+            this._conf = {};
+        this._conf.maxListeners = n;
+    }
+    getMaxListeners() {
+        return this._maxListeners;
+    }
+    once(event, fn, options) {
+        return this._many(event, 1, fn, false, options);
+    }
+    prependOnceListener(event, fn, options) {
+        return this._many(event, 1, fn, true, options);
+    }
+    many(event, ttl, fn, options) {
+        return this._many(event, ttl, fn, false, options);
+    }
+    prependMany(event, ttl, fn, options) {
+        return this._many(event, ttl, fn, true, options);
+    }
+    _many(event, ttl, fn, prepend, options) {
+        if (typeof fn !== 'function')
+            throw new Error('many only accepts instances of Function');
+        const self = this;
+        const listener = function (...args) {
+            if (--ttl === 0)
+                self.off(event, listener);
+            return fn.apply(this, args);
+        };
+        listener._origin = fn;
+        return this._on(event, listener, prepend, options);
+    }
+    /**
+     * The event of the emitting and of the listeners: the parts of a namespace joined, unless one is a symbol
+     * @param type
+     */
+    eventOf(type) {
+        if (!this.wildcard || type === 'newListener' || type === 'removeListener' || typeof type !== 'object')
+            return type;
+        return type.some((part) => typeof part === 'symbol') ? type : type.join(this.delimiter);
+    }
+    emit(type, ...values) {
+        if (!this._events && !this._all)
+            return false;
+        if (!this._events)
+            this.init();
+        if (type === 'newListener' && !this._newListener && !this._events.newListener)
+            return false;
+        const ns = type;
+        type = this.eventOf(type);
+        if (this._all && this._all.length) {
+            for (const listener of this._all.slice()) {
+                this.event = type;
+                //Like upstream: with three values or more, the event as given (not joined)
+                listener.call(this, values.length >= 3 ? ns : type, ...values);
+            }
+        }
+        let handlers;
+        if (this.wildcard) {
+            handlers = [];
+            this.searchListenerTree(handlers, ns, this.listenerTree, 0);
+        }
+        else {
+            handlers = this._events[type];
+            if (typeof handlers === 'function') {
+                this.event = type;
+                handlers.apply(this, values);
+                return true;
+            }
+            if (handlers)
+                handlers = handlers.slice();
+        }
+        if (handlers && handlers.length) {
+            for (const handler of handlers) {
+                this.event = type;
+                handler.apply(this, values);
+            }
+            return true;
+        }
+        if (!this.ignoreErrors && !this._all && type === 'error') {
+            if (values[0] instanceof Error)
+                throw values[0];
+            throw new Error('Uncaught, unspecified \'error\' event.');
+        }
+        return !!this._all;
+    }
+    emitAsync(type, ...values) {
+        if (!this._events && !this._all)
+            return false;
+        if (!this._events)
+            this.init();
+        if (type === 'newListener' && !this._newListener && !this._events.newListener)
+            return Promise.resolve([false]);
+        const ns = type;
+        type = this.eventOf(type);
+        const promises = [];
+        if (this._all) {
+            for (const listener of this._all) {
+                this.event = type;
+                promises.push(listener.call(this, values.length >= 3 ? ns : type, ...values));
+            }
+        }
+        let handlers;
+        if (this.wildcard) {
+            handlers = [];
+            this.searchListenerTree(handlers, ns, this.listenerTree, 0);
+        }
+        else {
+            handlers = this._events[type];
+        }
+        if (typeof handlers === 'function') {
+            this.event = type;
+            promises.push(handlers.apply(this, values));
+        }
+        else if (handlers && handlers.length) {
+            for (const handler of handlers.slice()) {
+                this.event = type;
+                promises.push(handler.apply(this, values));
+            }
+        }
+        else if (!this.ignoreErrors && !this._all && type === 'error') {
+            return Promise.reject(values[0] instanceof Error ? values[0] : 'Uncaught, unspecified \'error\' event.');
+        }
+        return Promise.all(promises);
+    }
+    on(type, listener, options) {
+        return this._on(type, listener, false, options);
+    }
+    prependListener(type, listener, options) {
+        return this._on(type, listener, true, options);
+    }
+    addListener(type, listener, options) {
+        return this._on(type, listener, false, options);
+    }
+    onAny(fn) {
+        return this._onAny(fn, false);
+    }
+    prependAny(fn) {
+        return this._onAny(fn, true);
+    }
+    _onAny(fn, prepend) {
+        if (typeof fn !== 'function')
+            throw new Error('onAny only accepts instances of Function');
+        if (!this._all)
+            this._all = [];
+        if (prepend)
+            this._all.unshift(fn);
+        else
+            this._all.push(fn);
+        return this;
+    }
+    _on(type, listener, prepend, options) {
+        //A function as the event: a listener of any event
+        if (typeof type === 'function') {
+            this._onAny(type, !!listener);
+            return this;
+        }
+        if (typeof listener !== 'function')
+            throw new Error('on only accepts instances of Function');
+        if (!this._events)
+            this.init();
+        if (options !== undefined)
+            listener = this.setupListener(listener, options);
+        //Emitted before the listener is added (no recursion for newListener)
+        if (this._newListener)
+            this.emit('newListener', type, listener);
+        if (this.wildcard) {
+            this.growListenerTree(type, listener, prepend);
+            return this;
+        }
+        const events = this._events;
+        const key = type;
+        const existing = events[key];
+        if (!existing) {
+            events[key] = listener;
+            return this;
+        }
+        const listeners = typeof existing === 'function' ? [existing] : existing;
+        events[key] = listeners;
+        if (prepend)
+            listeners.unshift(listener);
+        else
+            listeners.push(listener);
+        if (!listeners.warned && this._maxListeners > 0 && listeners.length > this._maxListeners) {
+            listeners.warned = true;
+            this.logPossibleMemoryLeak(listeners.length, key);
+        }
+        return this;
+    }
+    /**
+     * Whether a listener is the one given or one of its wrappers
+     * @param handler
+     * @param listener
+     */
+    isListener(handler, listener) {
+        return handler === listener || (!!handler.listener && handler.listener === listener) || (!!handler._origin && handler._origin === listener);
+    }
+    off(type, listener) {
+        if (typeof listener !== 'function')
+            throw new Error('removeListener only takes instances of Function');
+        let leafs = [];
+        if (this.wildcard) {
+            const ns = typeof type === 'string' ? type.split(this.delimiter) : type.slice();
+            const found = this.searchListenerTree(null, ns, this.listenerTree, 0);
+            if (!found)
+                return this;
+            leafs = found;
+        }
+        else {
+            if (!this._events[type])
+                return this;
+            leafs.push({ _listeners: this._events[type] });
+        }
+        for (const leaf of leafs) {
+            const handlers = leaf._listeners;
+            if (Array.isArray(handlers)) {
+                const position = handlers.findIndex((handler) => this.isListener(handler, listener));
+                if (position < 0)
+                    continue;
+                if (this.wildcard)
+                    leaf._listeners.splice(position, 1);
+                else
+                    this._events[type].splice(position, 1);
+                if (handlers.length === 0) {
+                    if (this.wildcard)
+                        delete leaf._listeners;
+                    else
+                        delete this._events[type];
+                }
+                if (this._removeListener)
+                    this.emit('removeListener', type, listener);
+                return this;
+            }
+            if (handlers && this.isListener(handlers, listener)) {
+                if (this.wildcard)
+                    delete leaf._listeners;
+                else
+                    delete this._events[type];
+                if (this._removeListener)
+                    this.emit('removeListener', type, listener);
+            }
+        }
+        if (this.listenerTree)
+            this.recursivelyGarbageCollect(this.listenerTree);
+        return this;
+    }
+    removeListener(type, listener) {
+        return this.off(type, listener);
+    }
+    offAny(fn) {
+        if (fn && this._all && this._all.length > 0) {
+            const index = this._all.indexOf(fn);
+            if (index >= 0) {
+                this._all.splice(index, 1);
+                if (this._removeListener)
+                    this.emit('removeListenerAny', fn);
+            }
+            return this;
+        }
+        if (this._removeListener)
+            for (const listener of this._all)
+                this.emit('removeListenerAny', listener);
+        this._all = [];
+        return this;
+    }
+    removeAllListeners(type) {
+        if (type === undefined) {
+            if (this._events)
+                this.init();
+            return this;
+        }
+        if (this.wildcard) {
+            const leafs = this.searchListenerTree(null, type, this.listenerTree, 0);
+            if (!leafs)
+                return this;
+            for (const leaf of leafs)
+                leaf._listeners = null;
+            if (this.listenerTree)
+                this.recursivelyGarbageCollect(this.listenerTree);
+        }
+        else if (this._events) {
+            this._events[type] = null;
+        }
+        return this;
+    }
+    listeners(type) {
+        const events = this._events;
+        if (type === undefined) {
+            if (this.wildcard)
+                throw Error('event name required for wildcard emitter');
+            if (!events)
+                return [];
+            const all = [];
+            const keys = ownKeys(events);
+            let i = keys.length;
+            while (i-- > 0) {
+                const listeners = events[keys[i]];
+                if (typeof listeners === 'function')
+                    all.push(listeners);
+                else
+                    all.push(...listeners);
+            }
+            return all;
+        }
+        if (this.wildcard) {
+            if (!this.listenerTree)
+                return [];
+            const handlers = [];
+            const ns = typeof type === 'string' ? type.split(this.delimiter) : type.slice();
+            this.searchListenerTree(handlers, ns, this.listenerTree, 0);
+            return handlers;
+        }
+        if (!events)
+            return [];
+        const listeners = events[type];
+        if (!listeners)
+            return [];
+        return typeof listeners === 'function' ? [listeners] : listeners;
+    }
+    eventNames(nsAsArray) {
+        if (this.wildcard)
+            return this.collectTreeEvents(this.listenerTree, [], null, nsAsArray);
+        return this._events ? ownKeys(this._events) : [];
+    }
+    listenerCount(type) {
+        return this.listeners(type).length;
+    }
+    hasListeners(type) {
+        if (this.wildcard) {
+            const handlers = [];
+            const ns = typeof type === 'string' ? type.split(this.delimiter) : type.slice();
+            this.searchListenerTree(handlers, ns, this.listenerTree, 0);
+            return handlers.length > 0;
+        }
+        const events = this._events;
+        const all = this._all;
+        return !!((all && all.length) || (events && (type === undefined ? ownKeys(events).length : events[type])));
+    }
+    listenersAny() {
+        return this._all ? this._all : [];
+    }
+    /**
+     * Not in the upstream: the number of the listeners of every event (the listeners of any event excluded)
+     */
+    countAllListeners() {
+        const count = (listeners) => !listeners ? 0 : typeof listeners === 'function' ? 1 : listeners.length;
+        if (!this.wildcard)
+            return this._events ? ownKeys(this._events).reduce((total, key) => total + count(this._events[key]), 0) : 0;
+        const countTree = (tree) => ownKeys(tree).reduce((total, key) => key === '_listeners' ? total + count(tree._listeners) : total + countTree(tree[key]), 0);
+        return this.listenerTree ? countTree(this.listenerTree) : 0;
+    }
+}