@ckeditor/ckeditor5-utils 34.1.0 → 35.0.1

package/src/emittermixin.js

@@ -2,23 +2,19 @@
  * @license Copyright (c) 2003-2022, CKSource Holding sp. z o.o. All rights reserved.
  * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
  */
-
 /**
  * @module utils/emittermixin
  */
-
 import EventInfo from './eventinfo';
 import uid from './uid';
 import priorities from './priorities';
 import insertToPriorityArray from './inserttopriorityarray';
-
 // To check if component is loaded more than once.
 import './version';
 import CKEditorError from './ckeditorerror';
-
-const _listeningTo = Symbol( 'listeningTo' );
-const _emitterId = Symbol( 'emitterId' );
-
+const _listeningTo = Symbol('listeningTo');
+const _emitterId = Symbol('emitterId');
+const _delegations = Symbol('delegations');
 /**
  * Mixin that injects the {@link ~Emitter events API} into its host.
  *
@@ -31,634 +27,406 @@ const _emitterId = Symbol( 'emitterId' );
  * @implements module:utils/emittermixin~Emitter
  */
 const EmitterMixin = {
-	/**
-	 * @inheritDoc
-	 */
-	on( event, callback, options = {} ) {
-		this.listenTo( this, event, callback, options );
-	},
-
-	/**
-	 * @inheritDoc
-	 */
-	once( event, callback, options ) {
-		let wasFired = false;
-
-		const onceCallback = function( event, ...args ) {
-			// Ensure the callback is called only once even if the callback itself leads to re-firing the event
-			// (which would call the callback again).
-			if ( !wasFired ) {
-				wasFired = true;
-
-				// Go off() at the first call.
-				event.off();
-
-				// Go with the original callback.
-				callback.call( this, event, ...args );
-			}
-		};
-
-		// Make a similar on() call, simply replacing the callback.
-		this.listenTo( this, event, onceCallback, options );
-	},
-
-	/**
-	 * @inheritDoc
-	 */
-	off( event, callback ) {
-		this.stopListening( this, event, callback );
-	},
-
-	/**
-	 * @inheritDoc
-	 */
-	listenTo( emitter, event, callback, options = {} ) {
-		let emitterInfo, eventCallbacks;
-
-		// _listeningTo contains a list of emitters that this object is listening to.
-		// This list has the following format:
-		//
-		// _listeningTo: {
-		//     emitterId: {
-		//         emitter: emitter,
-		//         callbacks: {
-		//             event1: [ callback1, callback2, ... ]
-		//             ....
-		//         }
-		//     },
-		//     ...
-		// }
-
-		if ( !this[ _listeningTo ] ) {
-			this[ _listeningTo ] = {};
-		}
-
-		const emitters = this[ _listeningTo ];
-
-		if ( !_getEmitterId( emitter ) ) {
-			_setEmitterId( emitter );
-		}
-
-		const emitterId = _getEmitterId( emitter );
-
-		if ( !( emitterInfo = emitters[ emitterId ] ) ) {
-			emitterInfo = emitters[ emitterId ] = {
-				emitter,
-				callbacks: {}
-			};
-		}
-
-		if ( !( eventCallbacks = emitterInfo.callbacks[ event ] ) ) {
-			eventCallbacks = emitterInfo.callbacks[ event ] = [];
-		}
-
-		eventCallbacks.push( callback );
-
-		// Finally register the callback to the event.
-		addEventListener( this, emitter, event, callback, options );
-	},
-
-	/**
-	 * @inheritDoc
-	 */
-	stopListening( emitter, event, callback ) {
-		const emitters = this[ _listeningTo ];
-		let emitterId = emitter && _getEmitterId( emitter );
-		const emitterInfo = emitters && emitterId && emitters[ emitterId ];
-		const eventCallbacks = emitterInfo && event && emitterInfo.callbacks[ event ];
-
-		// Stop if nothing has been listened.
-		if ( !emitters || ( emitter && !emitterInfo ) || ( event && !eventCallbacks ) ) {
-			return;
-		}
-
-		// All params provided. off() that single callback.
-		if ( callback ) {
-			removeEventListener( this, emitter, event, callback );
-
-			// We must remove callbacks as well in order to prevent memory leaks.
-			// See https://github.com/ckeditor/ckeditor5/pull/8480
-			const index = eventCallbacks.indexOf( callback );
-
-			if ( index !== -1 ) {
-				if ( eventCallbacks.length === 1 ) {
-					delete emitterInfo.callbacks[ event ];
-				} else {
-					removeEventListener( this, emitter, event, callback );
-				}
-			}
-		}
-		// Only `emitter` and `event` provided. off() all callbacks for that event.
-		else if ( eventCallbacks ) {
-			while ( ( callback = eventCallbacks.pop() ) ) {
-				removeEventListener( this, emitter, event, callback );
-			}
-
-			delete emitterInfo.callbacks[ event ];
-		}
-		// Only `emitter` provided. off() all events for that emitter.
-		else if ( emitterInfo ) {
-			for ( event in emitterInfo.callbacks ) {
-				this.stopListening( emitter, event );
-			}
-			delete emitters[ emitterId ];
-		}
-		// No params provided. off() all emitters.
-		else {
-			for ( emitterId in emitters ) {
-				this.stopListening( emitters[ emitterId ].emitter );
-			}
-			delete this[ _listeningTo ];
-		}
-	},
-
-	/**
-	 * @inheritDoc
-	 */
-	fire( eventOrInfo, ...args ) {
-		try {
-			const eventInfo = eventOrInfo instanceof EventInfo ? eventOrInfo : new EventInfo( this, eventOrInfo );
-			const event = eventInfo.name;
-			let callbacks = getCallbacksForEvent( this, event );
-
-			// Record that the event passed this emitter on its path.
-			eventInfo.path.push( this );
-
-			// Handle event listener callbacks first.
-			if ( callbacks ) {
-				// Arguments passed to each callback.
-				const callbackArgs = [ eventInfo, ...args ];
-
-				// Copying callbacks array is the easiest and most secure way of preventing infinite loops, when event callbacks
-				// are added while processing other callbacks. Previous solution involved adding counters (unique ids) but
-				// failed if callbacks were added to the queue before currently processed callback.
-				// If this proves to be too inefficient, another method is to change `.on()` so callbacks are stored if same
-				// event is currently processed. Then, `.fire()` at the end, would have to add all stored events.
-				callbacks = Array.from( callbacks );
-
-				for ( let i = 0; i < callbacks.length; i++ ) {
-					callbacks[ i ].callback.apply( this, callbackArgs );
-
-					// Remove the callback from future requests if off() has been called.
-					if ( eventInfo.off.called ) {
-						// Remove the called mark for the next calls.
-						delete eventInfo.off.called;
-
-						this._removeEventListener( event, callbacks[ i ].callback );
-					}
-
-					// Do not execute next callbacks if stop() was called.
-					if ( eventInfo.stop.called ) {
-						break;
-					}
-				}
-			}
-
-			// Delegate event to other emitters if needed.
-			if ( this._delegations ) {
-				const destinations = this._delegations.get( event );
-				const passAllDestinations = this._delegations.get( '*' );
-
-				if ( destinations ) {
-					fireDelegatedEvents( destinations, eventInfo, args );
-				}
-
-				if ( passAllDestinations ) {
-					fireDelegatedEvents( passAllDestinations, eventInfo, args );
-				}
-			}
-
-			return eventInfo.return;
-		} catch ( err ) {
-			// @if CK_DEBUG // throw err;
-			/* istanbul ignore next */
-			CKEditorError.rethrowUnexpectedError( err, this );
-		}
-	},
-
-	/**
-	 * @inheritDoc
-	 */
-	delegate( ...events ) {
-		return {
-			to: ( emitter, nameOrFunction ) => {
-				if ( !this._delegations ) {
-					this._delegations = new Map();
-				}
-
-				// Originally there was a for..of loop which unfortunately caused an error in Babel that didn't allow
-				// build an application. See: https://github.com/ckeditor/ckeditor5-react/issues/40.
-				events.forEach( eventName => {
-					const destinations = this._delegations.get( eventName );
-
-					if ( !destinations ) {
-						this._delegations.set( eventName, new Map( [ [ emitter, nameOrFunction ] ] ) );
-					} else {
-						destinations.set( emitter, nameOrFunction );
-					}
-				} );
-			}
-		};
-	},
-
-	/**
-	 * @inheritDoc
-	 */
-	stopDelegating( event, emitter ) {
-		if ( !this._delegations ) {
-			return;
-		}
-
-		if ( !event ) {
-			this._delegations.clear();
-		} else if ( !emitter ) {
-			this._delegations.delete( event );
-		} else {
-			const destinations = this._delegations.get( event );
-
-			if ( destinations ) {
-				destinations.delete( emitter );
-			}
-		}
-	},
-
-	/**
-	 * @inheritDoc
-	 */
-	_addEventListener( event, callback, options ) {
-		createEventNamespace( this, event );
-
-		const lists = getCallbacksListsForNamespace( this, event );
-		const priority = priorities.get( options.priority );
-
-		const callbackDefinition = {
-			callback,
-			priority
-		};
-
-		// Add the callback to all callbacks list.
-		for ( const callbacks of lists ) {
-			// Add the callback to the list in the right priority position.
-			insertToPriorityArray( callbacks, callbackDefinition );
-		}
-	},
-
-	/**
-	 * @inheritDoc
-	 */
-	_removeEventListener( event, callback ) {
-		const lists = getCallbacksListsForNamespace( this, event );
-
-		for ( const callbacks of lists ) {
-			for ( let i = 0; i < callbacks.length; i++ ) {
-				if ( callbacks[ i ].callback == callback ) {
-					// Remove the callback from the list (fixing the next index).
-					callbacks.splice( i, 1 );
-					i--;
-				}
-			}
-		}
-	}
+    /**
+     * @inheritDoc
+     */
+    on(event, callback, options = {}) {
+        this.listenTo(this, event, callback, options);
+    },
+    /**
+     * @inheritDoc
+     */
+    once(event, callback, options) {
+        let wasFired = false;
+        const onceCallback = (event, ...args) => {
+            // Ensure the callback is called only once even if the callback itself leads to re-firing the event
+            // (which would call the callback again).
+            if (!wasFired) {
+                wasFired = true;
+                // Go off() at the first call.
+                event.off();
+                // Go with the original callback.
+                callback.call(this, event, ...args);
+            }
+        };
+        // Make a similar on() call, simply replacing the callback.
+        this.listenTo(this, event, onceCallback, options);
+    },
+    /**
+     * @inheritDoc
+     */
+    off(event, callback) {
+        this.stopListening(this, event, callback);
+    },
+    /**
+     * @inheritDoc
+     */
+    listenTo(emitter, event, callback, options = {}) {
+        let emitterInfo, eventCallbacks;
+        // _listeningTo contains a list of emitters that this object is listening to.
+        // This list has the following format:
+        //
+        // _listeningTo: {
+        //     emitterId: {
+        //         emitter: emitter,
+        //         callbacks: {
+        //             event1: [ callback1, callback2, ... ]
+        //             ....
+        //         }
+        //     },
+        //     ...
+        // }
+        if (!this[_listeningTo]) {
+            this[_listeningTo] = {};
+        }
+        const emitters = this[_listeningTo];
+        if (!_getEmitterId(emitter)) {
+            _setEmitterId(emitter);
+        }
+        const emitterId = _getEmitterId(emitter);
+        if (!(emitterInfo = emitters[emitterId])) {
+            emitterInfo = emitters[emitterId] = {
+                emitter,
+                callbacks: {}
+            };
+        }
+        if (!(eventCallbacks = emitterInfo.callbacks[event])) {
+            eventCallbacks = emitterInfo.callbacks[event] = [];
+        }
+        eventCallbacks.push(callback);
+        // Finally register the callback to the event.
+        addEventListener(this, emitter, event, callback, options);
+    },
+    /**
+     * @inheritDoc
+     */
+    stopListening(emitter, event, callback) {
+        const emitters = this[_listeningTo];
+        let emitterId = emitter && _getEmitterId(emitter);
+        const emitterInfo = (emitters && emitterId) ? emitters[emitterId] : undefined;
+        const eventCallbacks = (emitterInfo && event) ? emitterInfo.callbacks[event] : undefined;
+        // Stop if nothing has been listened.
+        if (!emitters || (emitter && !emitterInfo) || (event && !eventCallbacks)) {
+            return;
+        }
+        // All params provided. off() that single callback.
+        if (callback) {
+            removeEventListener(this, emitter, event, callback);
+            // We must remove callbacks as well in order to prevent memory leaks.
+            // See https://github.com/ckeditor/ckeditor5/pull/8480
+            const index = eventCallbacks.indexOf(callback);
+            if (index !== -1) {
+                if (eventCallbacks.length === 1) {
+                    delete emitterInfo.callbacks[event];
+                }
+                else {
+                    removeEventListener(this, emitter, event, callback);
+                }
+            }
+        }
+        // Only `emitter` and `event` provided. off() all callbacks for that event.
+        else if (eventCallbacks) {
+            while ((callback = eventCallbacks.pop())) {
+                removeEventListener(this, emitter, event, callback);
+            }
+            delete emitterInfo.callbacks[event];
+        }
+        // Only `emitter` provided. off() all events for that emitter.
+        else if (emitterInfo) {
+            for (event in emitterInfo.callbacks) {
+                this.stopListening(emitter, event);
+            }
+            delete emitters[emitterId];
+        }
+        // No params provided. off() all emitters.
+        else {
+            for (emitterId in emitters) {
+                this.stopListening(emitters[emitterId].emitter);
+            }
+            delete this[_listeningTo];
+        }
+    },
+    /**
+     * @inheritDoc
+     */
+    fire(eventOrInfo, ...args) {
+        try {
+            const eventInfo = eventOrInfo instanceof EventInfo ? eventOrInfo : new EventInfo(this, eventOrInfo);
+            const event = eventInfo.name;
+            let callbacks = getCallbacksForEvent(this, event);
+            // Record that the event passed this emitter on its path.
+            eventInfo.path.push(this);
+            // Handle event listener callbacks first.
+            if (callbacks) {
+                // Arguments passed to each callback.
+                const callbackArgs = [eventInfo, ...args];
+                // Copying callbacks array is the easiest and most secure way of preventing infinite loops, when event callbacks
+                // are added while processing other callbacks. Previous solution involved adding counters (unique ids) but
+                // failed if callbacks were added to the queue before currently processed callback.
+                // If this proves to be too inefficient, another method is to change `.on()` so callbacks are stored if same
+                // event is currently processed. Then, `.fire()` at the end, would have to add all stored events.
+                callbacks = Array.from(callbacks);
+                for (let i = 0; i < callbacks.length; i++) {
+                    callbacks[i].callback.apply(this, callbackArgs);
+                    // Remove the callback from future requests if off() has been called.
+                    if (eventInfo.off.called) {
+                        // Remove the called mark for the next calls.
+                        delete eventInfo.off.called;
+                        this._removeEventListener(event, callbacks[i].callback);
+                    }
+                    // Do not execute next callbacks if stop() was called.
+                    if (eventInfo.stop.called) {
+                        break;
+                    }
+                }
+            }
+            // Delegate event to other emitters if needed.
+            const delegations = this[_delegations];
+            if (delegations) {
+                const destinations = delegations.get(event);
+                const passAllDestinations = delegations.get('*');
+                if (destinations) {
+                    fireDelegatedEvents(destinations, eventInfo, args);
+                }
+                if (passAllDestinations) {
+                    fireDelegatedEvents(passAllDestinations, eventInfo, args);
+                }
+            }
+            return eventInfo.return;
+        }
+        catch (err) {
+            // @if CK_DEBUG // throw err;
+            /* istanbul ignore next */
+            CKEditorError.rethrowUnexpectedError(err, this);
+        }
+    },
+    /**
+     * @inheritDoc
+     */
+    delegate(...events) {
+        return {
+            to: (emitter, nameOrFunction) => {
+                if (!this[_delegations]) {
+                    this[_delegations] = new Map();
+                }
+                // Originally there was a for..of loop which unfortunately caused an error in Babel that didn't allow
+                // build an application. See: https://github.com/ckeditor/ckeditor5-react/issues/40.
+                events.forEach(eventName => {
+                    const destinations = this[_delegations].get(eventName);
+                    if (!destinations) {
+                        this[_delegations].set(eventName, new Map([[emitter, nameOrFunction]]));
+                    }
+                    else {
+                        destinations.set(emitter, nameOrFunction);
+                    }
+                });
+            }
+        };
+    },
+    /**
+     * @inheritDoc
+     */
+    stopDelegating(event, emitter) {
+        if (!this[_delegations]) {
+            return;
+        }
+        if (!event) {
+            this[_delegations].clear();
+        }
+        else if (!emitter) {
+            this[_delegations].delete(event);
+        }
+        else {
+            const destinations = this[_delegations].get(event);
+            if (destinations) {
+                destinations.delete(emitter);
+            }
+        }
+    },
+    /**
+     * @inheritDoc
+     */
+    _addEventListener(event, callback, options) {
+        createEventNamespace(this, event);
+        const lists = getCallbacksListsForNamespace(this, event);
+        const priority = priorities.get(options.priority);
+        const callbackDefinition = {
+            callback,
+            priority
+        };
+        // Add the callback to all callbacks list.
+        for (const callbacks of lists) {
+            // Add the callback to the list in the right priority position.
+            insertToPriorityArray(callbacks, callbackDefinition);
+        }
+    },
+    /**
+     * @inheritDoc
+     */
+    _removeEventListener(event, callback) {
+        const lists = getCallbacksListsForNamespace(this, event);
+        for (const callbacks of lists) {
+            for (let i = 0; i < callbacks.length; i++) {
+                if (callbacks[i].callback == callback) {
+                    // Remove the callback from the list (fixing the next index).
+                    callbacks.splice(i, 1);
+                    i--;
+                }
+            }
+        }
+    }
 };
-
 export default EmitterMixin;
-
-/**
- * Emitter/listener interface.
- *
- * Can be easily implemented by a class by mixing the {@link module:utils/emittermixin~EmitterMixin} mixin.
- *
- * Read more about the usage of this interface in the:
- * * {@glink framework/guides/architecture/core-editor-architecture#event-system-and-observables Event system and observables}
- * section of the {@glink framework/guides/architecture/core-editor-architecture Core editor architecture} guide.
- * * {@glink framework/guides/deep-dive/event-system Event system} deep dive guide.
- *
- * @interface Emitter
- */
-
-/**
- * Registers a callback function to be executed when an event is fired.
- *
- * Shorthand for {@link #listenTo `this.listenTo( this, event, callback, options )`} (it makes the emitter
- * listen on itself).
- *
- * @method #on
- * @param {String} event The name of the event.
- * @param {Function} callback The function to be called on event.
- * @param {Object} [options={}] Additional options.
- * @param {module:utils/priorities~PriorityString|Number} [options.priority='normal'] The priority of this event callback. The higher
- * the priority value the sooner the callback will be fired. Events having the same priority are called in the
- * order they were added.
- */
-
-/**
- * Registers a callback function to be executed on the next time the event is fired only. This is similar to
- * calling {@link #on} followed by {@link #off} in the callback.
- *
- * @method #once
- * @param {String} event The name of the event.
- * @param {Function} callback The function to be called on event.
- * @param {Object} [options={}] Additional options.
- * @param {module:utils/priorities~PriorityString|Number} [options.priority='normal'] The priority of this event callback. The higher
- * the priority value the sooner the callback will be fired. Events having the same priority are called in the
- * order they were added.
- */
-
-/**
- * Stops executing the callback on the given event.
- * Shorthand for {@link #stopListening `this.stopListening( this, event, callback )`}.
- *
- * @method #off
- * @param {String} event The name of the event.
- * @param {Function} callback The function to stop being called.
- */
-
-/**
- * Registers a callback function to be executed when an event is fired in a specific (emitter) object.
- *
- * Events can be grouped in namespaces using `:`.
- * When namespaced event is fired, it additionally fires all callbacks for that namespace.
- *
- *		// myEmitter.on( ... ) is a shorthand for myEmitter.listenTo( myEmitter, ... ).
- *		myEmitter.on( 'myGroup', genericCallback );
- *		myEmitter.on( 'myGroup:myEvent', specificCallback );
- *
- *		// genericCallback is fired.
- *		myEmitter.fire( 'myGroup' );
- *		// both genericCallback and specificCallback are fired.
- *		myEmitter.fire( 'myGroup:myEvent' );
- *		// genericCallback is fired even though there are no callbacks for "foo".
- *		myEmitter.fire( 'myGroup:foo' );
- *
- * An event callback can {@link module:utils/eventinfo~EventInfo#stop stop the event} and
- * set the {@link module:utils/eventinfo~EventInfo#return return value} of the {@link #fire} method.
- *
- * @method #listenTo
- * @param {module:utils/emittermixin~Emitter} emitter The object that fires the event.
- * @param {String} event The name of the event.
- * @param {Function} callback The function to be called on event.
- * @param {Object} [options={}] Additional options.
- * @param {module:utils/priorities~PriorityString|Number} [options.priority='normal'] The priority of this event callback. The higher
- * the priority value the sooner the callback will be fired. Events having the same priority are called in the
- * order they were added.
- */
-
-/**
- * Stops listening for events. It can be used at different levels:
- *
- * * To stop listening to a specific callback.
- * * To stop listening to a specific event.
- * * To stop listening to all events fired by a specific object.
- * * To stop listening to all events fired by all objects.
- *
- * @method #stopListening
- * @param {module:utils/emittermixin~Emitter} [emitter] The object to stop listening to. If omitted, stops it for all objects.
- * @param {String} [event] (Requires the `emitter`) The name of the event to stop listening to. If omitted, stops it
- * for all events from `emitter`.
- * @param {Function} [callback] (Requires the `event`) The function to be removed from the call list for the given
- * `event`.
- */
-
-/**
- * Fires an event, executing all callbacks registered for it.
- *
- * The first parameter passed to callbacks is an {@link module:utils/eventinfo~EventInfo} object,
- * followed by the optional `args` provided in the `fire()` method call.
- *
- * @method #fire
- * @param {String|module:utils/eventinfo~EventInfo} eventOrInfo The name of the event or `EventInfo` object if event is delegated.
- * @param {...*} [args] Additional arguments to be passed to the callbacks.
- * @returns {*} By default the method returns `undefined`. However, the return value can be changed by listeners
- * through modification of the {@link module:utils/eventinfo~EventInfo#return `evt.return`}'s property (the event info
- * is the first param of every callback).
- */
-
-/**
- * Delegates selected events to another {@link module:utils/emittermixin~Emitter}. For instance:
- *
- *		emitterA.delegate( 'eventX' ).to( emitterB );
- *		emitterA.delegate( 'eventX', 'eventY' ).to( emitterC );
- *
- * then `eventX` is delegated (fired by) `emitterB` and `emitterC` along with `data`:
- *
- *		emitterA.fire( 'eventX', data );
- *
- * and `eventY` is delegated (fired by) `emitterC` along with `data`:
- *
- *		emitterA.fire( 'eventY', data );
- *
- * @method #delegate
- * @param {...String} events Event names that will be delegated to another emitter.
- * @returns {module:utils/emittermixin~EmitterMixinDelegateChain}
- */
-
-/**
- * Stops delegating events. It can be used at different levels:
- *
- * * To stop delegating all events.
- * * To stop delegating a specific event to all emitters.
- * * To stop delegating a specific event to a specific emitter.
- *
- * @method #stopDelegating
- * @param {String} [event] The name of the event to stop delegating. If omitted, stops it all delegations.
- * @param {module:utils/emittermixin~Emitter} [emitter] (requires `event`) The object to stop delegating a particular event to.
- * If omitted, stops delegation of `event` to all emitters.
- */
-
-/**
- * Adds callback to emitter for given event.
- *
- * @protected
- * @method #_addEventListener
- * @param {String} event The name of the event.
- * @param {Function} callback The function to be called on event.
- * @param {Object} [options={}] Additional options.
- * @param {module:utils/priorities~PriorityString|Number} [options.priority='normal'] The priority of this event callback. The higher
- * the priority value the sooner the callback will be fired. Events having the same priority are called in the
- * order they were added.
- */
-
-/**
- * Removes callback from emitter for given event.
- *
- * @protected
- * @method #_removeEventListener
- * @param {String} event The name of the event.
- * @param {Function} callback The function to stop being called.
- */
-
 /**
  * Checks if `listeningEmitter` listens to an emitter with given `listenedToEmitterId` and if so, returns that emitter.
  * If not, returns `null`.
  *
+ * @internal
  * @protected
  * @param {module:utils/emittermixin~Emitter} listeningEmitter An emitter that listens.
  * @param {String} listenedToEmitterId Unique emitter id of emitter listened to.
  * @returns {module:utils/emittermixin~Emitter|null}
  */
-export function _getEmitterListenedTo( listeningEmitter, listenedToEmitterId ) {
-	if ( listeningEmitter[ _listeningTo ] && listeningEmitter[ _listeningTo ][ listenedToEmitterId ] ) {
-		return listeningEmitter[ _listeningTo ][ listenedToEmitterId ].emitter;
-	}
-
-	return null;
+export function _getEmitterListenedTo(listeningEmitter, listenedToEmitterId) {
+    const listeningTo = listeningEmitter[_listeningTo];
+    if (listeningTo && listeningTo[listenedToEmitterId]) {
+        return listeningTo[listenedToEmitterId].emitter;
+    }
+    return null;
 }
-
 /**
  * Sets emitter's unique id.
  *
  * **Note:** `_emitterId` can be set only once.
  *
+ * @internal
  * @protected
  * @param {module:utils/emittermixin~Emitter} emitter An emitter for which id will be set.
  * @param {String} [id] Unique id to set. If not passed, random unique id will be set.
  */
-export function _setEmitterId( emitter, id ) {
-	if ( !emitter[ _emitterId ] ) {
-		emitter[ _emitterId ] = id || uid();
-	}
+export function _setEmitterId(emitter, id) {
+    if (!emitter[_emitterId]) {
+        emitter[_emitterId] = id || uid();
+    }
 }
-
 /**
  * Returns emitter's unique id.
  *
+ * @internal
  * @protected
  * @param {module:utils/emittermixin~Emitter} emitter An emitter which id will be returned.
+ * @returns {String|undefined}
  */
-export function _getEmitterId( emitter ) {
-	return emitter[ _emitterId ];
+export function _getEmitterId(emitter) {
+    return emitter[_emitterId];
 }
-
 // Gets the internal `_events` property of the given object.
 // `_events` property store all lists with callbacks for registered event names.
 // If there were no events registered on the object, empty `_events` object is created.
-function getEvents( source ) {
-	if ( !source._events ) {
-		Object.defineProperty( source, '_events', {
-			value: {}
-		} );
-	}
-
-	return source._events;
+function getEvents(source) {
+    if (!source._events) {
+        Object.defineProperty(source, '_events', {
+            value: {}
+        });
+    }
+    return source._events;
 }
-
 // Creates event node for generic-specific events relation architecture.
 function makeEventNode() {
-	return {
-		callbacks: [],
-		childEvents: []
-	};
+    return {
+        callbacks: [],
+        childEvents: []
+    };
 }
-
 // Creates an architecture for generic-specific events relation.
 // If needed, creates all events for given eventName, i.e. if the first registered event
 // is foo:bar:abc, it will create foo:bar:abc, foo:bar and foo event and tie them together.
 // It also copies callbacks from more generic events to more specific events when
 // specific events are created.
-function createEventNamespace( source, eventName ) {
-	const events = getEvents( source );
-
-	// First, check if the event we want to add to the structure already exists.
-	if ( events[ eventName ] ) {
-		// If it exists, we don't have to do anything.
-		return;
-	}
-
-	// In other case, we have to create the structure for the event.
-	// Note, that we might need to create intermediate events too.
-	// I.e. if foo:bar:abc is being registered and we only have foo in the structure,
-	// we need to also register foo:bar.
-
-	// Currently processed event name.
-	let name = eventName;
-	// Name of the event that is a child event for currently processed event.
-	let childEventName = null;
-
-	// Array containing all newly created specific events.
-	const newEventNodes = [];
-
-	// While loop can't check for ':' index because we have to handle generic events too.
-	// In each loop, we truncate event name, going from the most specific name to the generic one.
-	// I.e. foo:bar:abc -> foo:bar -> foo.
-	while ( name !== '' ) {
-		if ( events[ name ] ) {
-			// If the currently processed event name is already registered, we can be sure
-			// that it already has all the structure created, so we can break the loop here
-			// as no more events need to be registered.
-			break;
-		}
-
-		// If this event is not yet registered, create a new object for it.
-		events[ name ] = makeEventNode();
-		// Add it to the array with newly created events.
-		newEventNodes.push( events[ name ] );
-
-		// Add previously processed event name as a child of this event.
-		if ( childEventName ) {
-			events[ name ].childEvents.push( childEventName );
-		}
-
-		childEventName = name;
-		// If `.lastIndexOf()` returns -1, `.substr()` will return '' which will break the loop.
-		name = name.substr( 0, name.lastIndexOf( ':' ) );
-	}
-
-	if ( name !== '' ) {
-		// If name is not empty, we found an already registered event that was a parent of the
-		// event we wanted to register.
-
-		// Copy that event's callbacks to newly registered events.
-		for ( const node of newEventNodes ) {
-			node.callbacks = events[ name ].callbacks.slice();
-		}
-
-		// Add last newly created event to the already registered event.
-		events[ name ].childEvents.push( childEventName );
-	}
+function createEventNamespace(source, eventName) {
+    const events = getEvents(source);
+    // First, check if the event we want to add to the structure already exists.
+    if (events[eventName]) {
+        // If it exists, we don't have to do anything.
+        return;
+    }
+    // In other case, we have to create the structure for the event.
+    // Note, that we might need to create intermediate events too.
+    // I.e. if foo:bar:abc is being registered and we only have foo in the structure,
+    // we need to also register foo:bar.
+    // Currently processed event name.
+    let name = eventName;
+    // Name of the event that is a child event for currently processed event.
+    let childEventName = null;
+    // Array containing all newly created specific events.
+    const newEventNodes = [];
+    // While loop can't check for ':' index because we have to handle generic events too.
+    // In each loop, we truncate event name, going from the most specific name to the generic one.
+    // I.e. foo:bar:abc -> foo:bar -> foo.
+    while (name !== '') {
+        if (events[name]) {
+            // If the currently processed event name is already registered, we can be sure
+            // that it already has all the structure created, so we can break the loop here
+            // as no more events need to be registered.
+            break;
+        }
+        // If this event is not yet registered, create a new object for it.
+        events[name] = makeEventNode();
+        // Add it to the array with newly created events.
+        newEventNodes.push(events[name]);
+        // Add previously processed event name as a child of this event.
+        if (childEventName) {
+            events[name].childEvents.push(childEventName);
+        }
+        childEventName = name;
+        // If `.lastIndexOf()` returns -1, `.substr()` will return '' which will break the loop.
+        name = name.substr(0, name.lastIndexOf(':'));
+    }
+    if (name !== '') {
+        // If name is not empty, we found an already registered event that was a parent of the
+        // event we wanted to register.
+        // Copy that event's callbacks to newly registered events.
+        for (const node of newEventNodes) {
+            node.callbacks = events[name].callbacks.slice();
+        }
+        // Add last newly created event to the already registered event.
+        events[name].childEvents.push(childEventName);
+    }
 }
-
 // Gets an array containing callbacks list for a given event and it's more specific events.
 // I.e. if given event is foo:bar and there is also foo:bar:abc event registered, this will
 // return callback list of foo:bar and foo:bar:abc (but not foo).
-function getCallbacksListsForNamespace( source, eventName ) {
-	const eventNode = getEvents( source )[ eventName ];
-
-	if ( !eventNode ) {
-		return [];
-	}
-
-	let callbacksLists = [ eventNode.callbacks ];
-
-	for ( let i = 0; i < eventNode.childEvents.length; i++ ) {
-		const childCallbacksLists = getCallbacksListsForNamespace( source, eventNode.childEvents[ i ] );
-
-		callbacksLists = callbacksLists.concat( childCallbacksLists );
-	}
-
-	return callbacksLists;
+function getCallbacksListsForNamespace(source, eventName) {
+    const eventNode = getEvents(source)[eventName];
+    if (!eventNode) {
+        return [];
+    }
+    let callbacksLists = [eventNode.callbacks];
+    for (let i = 0; i < eventNode.childEvents.length; i++) {
+        const childCallbacksLists = getCallbacksListsForNamespace(source, eventNode.childEvents[i]);
+        callbacksLists = callbacksLists.concat(childCallbacksLists);
+    }
+    return callbacksLists;
 }
-
 // Get the list of callbacks for a given event, but only if there any callbacks have been registered.
 // If there are no callbacks registered for given event, it checks if this is a specific event and looks
 // for callbacks for it's more generic version.
-function getCallbacksForEvent( source, eventName ) {
-	let event;
-
-	if ( !source._events || !( event = source._events[ eventName ] ) || !event.callbacks.length ) {
-		// There are no callbacks registered for specified eventName.
-		// But this could be a specific-type event that is in a namespace.
-		if ( eventName.indexOf( ':' ) > -1 ) {
-			// If the eventName is specific, try to find callback lists for more generic event.
-			return getCallbacksForEvent( source, eventName.substr( 0, eventName.lastIndexOf( ':' ) ) );
-		} else {
-			// If this is a top-level generic event, return null;
-			return null;
-		}
-	}
-
-	return event.callbacks;
+function getCallbacksForEvent(source, eventName) {
+    let event;
+    if (!source._events || !(event = source._events[eventName]) || !event.callbacks.length) {
+        // There are no callbacks registered for specified eventName.
+        // But this could be a specific-type event that is in a namespace.
+        if (eventName.indexOf(':') > -1) {
+            // If the eventName is specific, try to find callback lists for more generic event.
+            return getCallbacksForEvent(source, eventName.substr(0, eventName.lastIndexOf(':')));
+        }
+        else {
+            // If this is a top-level generic event, return null;
+            return null;
+        }
+    }
+    return event.callbacks;
 }
-
 // Fires delegated events for given map of destinations.
 //
 // @private
@@ -666,54 +434,38 @@ function getCallbacksForEvent( source, eventName ) {
 // `[ {@link module:utils/emittermixin~Emitter}, "event name" ]` pair destinations.
 // * @param {utils.EventInfo} eventInfo The original event info object.
 // * @param {Array.<*>} fireArgs Arguments the original event was fired with.
-function fireDelegatedEvents( destinations, eventInfo, fireArgs ) {
-	for ( let [ emitter, name ] of destinations ) {
-		if ( !name ) {
-			name = eventInfo.name;
-		} else if ( typeof name == 'function' ) {
-			name = name( eventInfo.name );
-		}
-
-		const delegatedInfo = new EventInfo( eventInfo.source, name );
-
-		delegatedInfo.path = [ ...eventInfo.path ];
-
-		emitter.fire( delegatedInfo, ...fireArgs );
-	}
+function fireDelegatedEvents(destinations, eventInfo, fireArgs) {
+    for (let [emitter, name] of destinations) {
+        if (!name) {
+            name = eventInfo.name;
+        }
+        else if (typeof name == 'function') {
+            name = name(eventInfo.name);
+        }
+        const delegatedInfo = new EventInfo(eventInfo.source, name);
+        delegatedInfo.path = [...eventInfo.path];
+        emitter.fire(delegatedInfo, ...fireArgs);
+    }
 }
-
 // Helper for registering event callback on the emitter.
-function addEventListener( listener, emitter, event, callback, options ) {
-	if ( emitter._addEventListener ) {
-		emitter._addEventListener( event, callback, options );
-	} else {
-		// Allow listening on objects that do not implement Emitter interface.
-		// This is needed in some tests that are using mocks instead of the real objects with EmitterMixin mixed.
-		listener._addEventListener.call( emitter, event, callback, options );
-	}
+function addEventListener(listener, emitter, event, callback, options) {
+    if (emitter._addEventListener) {
+        emitter._addEventListener(event, callback, options);
+    }
+    else {
+        // Allow listening on objects that do not implement Emitter interface.
+        // This is needed in some tests that are using mocks instead of the real objects with EmitterMixin mixed.
+        listener._addEventListener.call(emitter, event, callback, options);
+    }
 }
-
 // Helper for removing event callback from the emitter.
-function removeEventListener( listener, emitter, event, callback ) {
-	if ( emitter._removeEventListener ) {
-		emitter._removeEventListener( event, callback );
-	} else {
-		// Allow listening on objects that do not implement Emitter interface.
-		// This is needed in some tests that are using mocks instead of the real objects with EmitterMixin mixed.
-		listener._removeEventListener.call( emitter, event, callback );
-	}
+function removeEventListener(listener, emitter, event, callback) {
+    if (emitter._removeEventListener) {
+        emitter._removeEventListener(event, callback);
+    }
+    else {
+        // Allow listening on objects that do not implement Emitter interface.
+        // This is needed in some tests that are using mocks instead of the real objects with EmitterMixin mixed.
+        listener._removeEventListener.call(emitter, event, callback);
+    }
 }
-
-/**
- * The return value of {@link ~EmitterMixin#delegate}.
- *
- * @interface module:utils/emittermixin~EmitterMixinDelegateChain
- */
-
-/**
- * Selects destination for {@link module:utils/emittermixin~EmitterMixin#delegate} events.
- *
- * @method #to
- * @param {module:utils/emittermixin~Emitter} emitter An `EmitterMixin` instance which is the destination for delegated events.
- * @param {String|Function} [nameOrFunction] A custom event name or function which converts the original name string.
- */