Code coverage report for umd/event-emitter.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
14
 
 
14
 
 
14
14
 
 
 
14
1
 
 
14
 
 
 
 
 
 
 
 
 
 
1
19
 
 
14
 
 
 
 
 
 
 
 
 
12
 
12
 
 
 
 
 
 
 
 
 
9
 
9
5
 
5
4
 
1
 
 
4
 
 
 
 
 
 
 
 
 
 
 
22
 
22
 
 
 
 
9
 
9
10
 
10
 
 
13
 
 
 
 
14
 
(function (global, factory) {
    'use strict';
 
    var built = factory(global);
 
    /* istanbul ignore else */
    Eif (typeof module === 'object' && module) {
        module.exports = built;
    }
 
    /* istanbul ignore next */
    Iif (typeof define === 'function' && define.amd) {
        define(factory);
    }
 
    global.EventEmitter = built;
}(typeof global !== 'undefined' ? global : /* istanbul ignore next */ this, function (global) {
 
    'use strict';
 
/**
 * Creates an instance of EventEmitter class.
 *
 * @constructor
 */
 
function EventEmitter() {
    this._events = {};
}
 
EventEmitter.prototype = {
    constructor: EventEmitter,
 
    /**
     * Adds event listener to an event.
     *
     * @param {string} event The name of the event.
     * @param {Function} callback Callback method to be invoked when event is being emitted.
     */
    on: function (event, callback) {
        var listeners = this._events[event] = this._events[event] || [];
 
        listeners.push(callback);
    },
 
    /**
     * Removes an event from the list of event listeners to some event.
     *
     * @param {string} event The name of the event.
     * @param {function} callback Callback method to be removed from the list of listeners.
     */
    off: function (event, callback) {
        var listeners = this._events[event];
 
        if (listeners) {
            var callbackIndex = listeners.indexOf(callback);
 
            if (callbackIndex > -1) {
                listeners.splice(callbackIndex, 1);
            } else {
                console.warn('Off: callback was not removed: ' + callback.toString());
            }
        } else {
            console.warn('Off: there are no listeners for event: ' + event);
        }
    },
 
    /**
     * Emits an event. The function calls all registered listeners in the order they have been added. The provided args
     * param will be passed to each listener of the event.
     *
     * @param {string} event The name of the event.
     * @param {object} args Object, which will be passed to the listener as only argument.
     */
    emit: function (event, args) {
        var listeners = this._events[event];
 
        if (listeners) {
            // Slicing is needed to prevent the following situation:
            // A listener is being invoked. During its execution, it may
            // remove itself from the list. In this case, for loop will
            // be damaged, since i will be out of sync.
            listeners = listeners.slice(0);
 
            for (var i = 0; i < listeners.length; i++) {
                var listener = listeners[i];
 
                listener.call(listener, args);
            }
        } else {
            console.warn('No listeners for event: ' + event);
        }
    }
};
 
    return EventEmitter;
}));