@ckeditor/ckeditor5-utils 35.0.1 → 35.2.0

package/src/emittermixin.js

@@ -5,6 +5,7 @@
 /**
  * @module utils/emittermixin
  */
+/* eslint-disable new-cap */
 import EventInfo from './eventinfo';
 import uid from './uid';
 import priorities from './priorities';
@@ -26,257 +27,238 @@ const _delegations = Symbol('delegations');
  * @mixin EmitterMixin
  * @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 = (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);
+export default function EmitterMixin(base) {
+    class Mixin extends base {
+        on(event, callback, options) {
+            this.listenTo(this, event, callback, options);
         }
-        const emitterId = _getEmitterId(emitter);
-        if (!(emitterInfo = emitters[emitterId])) {
-            emitterInfo = emitters[emitterId] = {
-                emitter,
-                callbacks: {}
+        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);
         }
-        if (!(eventCallbacks = emitterInfo.callbacks[event])) {
-            eventCallbacks = emitterInfo.callbacks[event] = [];
+        off(event, callback) {
+            this.stopListening(this, event, callback);
         }
-        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);
-                }
+        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] = {};
             }
-        }
-        // Only `emitter` and `event` provided. off() all callbacks for that event.
-        else if (eventCallbacks) {
-            while ((callback = eventCallbacks.pop())) {
-                removeEventListener(this, emitter, event, callback);
+            const emitters = this[_listeningTo];
+            if (!_getEmitterId(emitter)) {
+                _setEmitterId(emitter);
             }
-            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);
+            const emitterId = _getEmitterId(emitter);
+            if (!(emitterInfo = emitters[emitterId])) {
+                emitterInfo = emitters[emitterId] = {
+                    emitter,
+                    callbacks: {}
+                };
             }
-            delete emitters[emitterId];
-        }
-        // No params provided. off() all emitters.
-        else {
-            for (emitterId in emitters) {
-                this.stopListening(emitters[emitterId].emitter);
+            if (!(eventCallbacks = emitterInfo.callbacks[event])) {
+                eventCallbacks = emitterInfo.callbacks[event] = [];
             }
-            delete this[_listeningTo];
+            eventCallbacks.push(callback);
+            // Finally register the callback to the event.
+            addEventListener(this, emitter, event, callback, options);
         }
-    },
-    /**
-     * @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);
+        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];
                     }
-                    // Do not execute next callbacks if stop() was called.
-                    if (eventInfo.stop.called) {
-                        break;
+                    else {
+                        removeEventListener(this, emitter, event, callback);
                     }
                 }
             }
-            // 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);
+            // Only `emitter` and `event` provided. off() all callbacks for that event.
+            else if (eventCallbacks) {
+                while ((callback = eventCallbacks.pop())) {
+                    removeEventListener(this, emitter, event, callback);
                 }
-                if (passAllDestinations) {
-                    fireDelegatedEvents(passAllDestinations, eventInfo, args);
+                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];
             }
-            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();
+        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;
+                        }
+                    }
                 }
-                // 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]]));
+                // 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);
                     }
-                    else {
-                        destinations.set(emitter, nameOrFunction);
+                    if (passAllDestinations) {
+                        fireDelegatedEvents(passAllDestinations, eventInfo, args);
                     }
-                });
+                }
+                return eventInfo.return;
+            }
+            catch (err) {
+                // @if CK_DEBUG // throw err;
+                /* istanbul ignore next */
+                CKEditorError.rethrowUnexpectedError(err, this);
             }
-        };
-    },
-    /**
-     * @inheritDoc
-     */
-    stopDelegating(event, emitter) {
-        if (!this[_delegations]) {
-            return;
-        }
-        if (!event) {
-            this[_delegations].clear();
         }
-        else if (!emitter) {
-            this[_delegations].delete(event);
+        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);
+                        }
+                    });
+                }
+            };
         }
-        else {
-            const destinations = this[_delegations].get(event);
-            if (destinations) {
-                destinations.delete(emitter);
+        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);
+        _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--;
+        _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;
+    return Mixin;
+}
+export const Emitter = EmitterMixin(Object);
+// Backward compatibility with `mix`
+([
+    'on', 'once', 'off', 'listenTo',
+    'stopListening', 'fire', 'delegate', 'stopDelegating',
+    '_addEventListener', '_removeEventListener'
+]).forEach(key => {
+    EmitterMixin[key] = Emitter.prototype[key];
+});
 /**
  * Checks if `listeningEmitter` listens to an emitter with given `listenedToEmitterId` and if so, returns that emitter.
  * If not, returns `null`.
@@ -455,7 +437,7 @@ function addEventListener(listener, emitter, 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);
+        (listener._addEventListener).call(emitter, event, callback, options);
     }
 }
 // Helper for removing event callback from the emitter.

package/src/env.js

@@ -6,7 +6,22 @@
 /**
  * @module utils/env
  */
-const userAgent = navigator.userAgent.toLowerCase();
+/**
+ * Safely returns `userAgent` from browser's navigator API in a lower case.
+ * If navigator API is not available it will return an empty string.
+ *
+ * @returns {String}
+ */
+export function getUserAgent() {
+    // In some environments navigator API might not be available.
+    try {
+        return navigator.userAgent.toLowerCase();
+    }
+    catch (e) {
+        return '';
+    }
+}
+const userAgent = getUserAgent();
 /**
  * A namespace containing environment and browser information.
  *

package/src/focustracker.js

@@ -3,13 +3,13 @@
  * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
  */
 /* global setTimeout, clearTimeout */
+/* eslint-disable new-cap */
 /**
  * @module utils/focustracker
  */
 import DomEmitterMixin from './dom/emittermixin';
-import ObservableMixin from './observablemixin';
+import { Observable } from './observablemixin';
 import CKEditorError from './ckeditorerror';
-import mix from './mix';
 /**
  * Allows observing a group of `Element`s whether at least one of them is focused.
  *
@@ -25,8 +25,9 @@ import mix from './mix';
  * @mixes module:utils/dom/emittermixin~EmitterMixin
  * @mixes module:utils/observablemixin~ObservableMixin
  */
-class FocusTracker {
+export default class FocusTracker extends DomEmitterMixin(Observable) {
     constructor() {
+        super();
         this.set('isFocused', false);
         this.set('focusedElement', null);
         this._elements = new Set();
@@ -98,6 +99,3 @@ class FocusTracker {
         }, 0);
     }
 }
-mix(FocusTracker, DomEmitterMixin);
-mix(FocusTracker, ObservableMixin);
-export default FocusTracker;

package/src/keystrokehandler.js

@@ -71,7 +71,7 @@ export default class KeystrokeHandler {
      * the {@link module:utils/keyboard~parseKeystroke} function.
      * @param {Function} callback A function called with the
      * {@link module:engine/view/observer/keyobserver~KeyEventData key event data} object and
-     * a helper funcion to call both `preventDefault()` and `stopPropagation()` on the underlying event.
+     * a helper function to call both `preventDefault()` and `stopPropagation()` on the underlying event.
      * @param {Object} [options={}] Additional options.
      * @param {module:utils/priorities~PriorityString|Number} [options.priority='normal'] The priority of the keystroke
      * callback. The higher the priority value the sooner the callback will be executed. Keystrokes having the same priority

package/src/mix.js

@@ -25,6 +25,7 @@
  *
  * Note: Properties which already exist in the base class will not be overriden.
  *
+ * @depreciated Use mixin pattern, see: https://www.typescriptlang.org/docs/handbook/mixins.html.
  * @param {Function} [baseClass] Class which prototype will be extended.
  * @param {Object} [...mixins] Objects from which to get properties.
  */
@@ -36,6 +37,9 @@ export default function mix(baseClass, ...mixins) {
             if (key in baseClass.prototype) {
                 return;
             }
+            if (typeof mixin == 'function' && (key == 'length' || key == 'name' || key == 'prototype')) {
+                return;
+            }
             const sourceDescriptor = Object.getOwnPropertyDescriptor(mixin, key);
             sourceDescriptor.enumerable = false;
             Object.defineProperty(baseClass.prototype, key, sourceDescriptor);