https://cdn4.hola.org/util/events.js

1/*jslint skip_file:true*/
2(function(){
3var define;
4var is_node = typeof module=='object' && module.exports && module.children;
5if (!is_node)
6    define = self.define;
7else
8    define = require('./require_node.js').define(module, '../');
9define([], function(){
10
11/**
12 * Minimal EventEmitter interface that is molded against the Node.js
13 * EventEmitter interface.
14 *
15 * @constructor
16 * @api public
17 */
18function EventEmitter(){ this._events = {}; }
19
20/**
21 * Return a list of assigned event listeners.
22 *
23 * @param {String} name The events that should be listed.
24 * @returns {Array}
25 * @api public
26 */
27EventEmitter.prototype.listeners = function listeners(name){
28    var events = this._events && this._events[name] || [];
29    var length = events.length, listeners = [], event;
30    for (var i = 0; i<length; event = events[++i])
31        listeners.push(events[i].fn);
32    return listeners;
33};
34
35/**
36 * Emit an event to all registered event listeners.
37 *
38 * @param {String} name The name of the event.
39 * @returns {Boolean} Indication if we've emitted an event.
40 * @api public
41 */
42EventEmitter.prototype.emit = function emit(name, a1, a2, a3, a4, a5){
43    if (!this._events || !this._events[name])
44        return false;
45    var listeners = this._events[name], length = listeners.length;
46    var len = arguments.length, event = listeners[0], args, i;
47    if (length===1)
48    {
49        switch (len)
50        {
51        case 1:
52            event.fn.call(event.context||this);
53            break;
54        case 2:
55            event.fn.call(event.context||this, a1);
56            break;
57        case 3:
58            event.fn.call(event.context||this, a1, a2);
59            break;
60        case 4:
61            event.fn.call(event.context||this, a1, a2, a3);
62            break;
63        case 5:
64            event.fn.call(event.context||this, a1, a2, a3, a4);
65            break;
66        case 6:
67            event.fn.call(event.context||this, a1, a2, a3, a4, a5);
68            break;
69        default:
70            for (i = 1, args = new Array(len-1); i<len; i++)
71                args[i-1] = arguments[i];
72            event.fn.apply(event.context||this, args);
73        }
74        if (event.once)
75            remove_listener.apply(this, [name, event]);
76    }
77    else
78    {
79        for (i = 1, args = new Array(len-1); i<len; i++)
80            args[i-1] = arguments[i];
81        for (i = 0; i<length; event = listeners[++i])
82        {
83            event.fn.apply(event.context||this, args);
84            if (event.once)
85                remove_listener.apply(this, [name, event]);
86        }
87    }
88    return true;
89};
90
91function add_listener(name, fn, opt){
92    opt = opt||{};
93    if (!this._events)
94        this._events = {};
95    if (!this._events[name])
96        this._events[name] = [];
97    var event = {fn: fn};
98    if (opt.context)
99        event.context = opt.context;
100    if (opt.once)
101        event.once = opt.once;
102    if (opt.prepend)
103        this._events[name].unshift(event);
104    else
105        this._events[name].push(event);
106    return this;
107}
108
109function remove_listener(name, listener){
110    if (!this._events || !this._events[name])
111        return this;
112    var listeners = this._events[name], events = [];
113    var is_fn = typeof listener=='function';
114    for (var i = 0, length = listeners.length; i<length; i++){
115        if (!listener)
116            continue;
117        if (is_fn && listeners[i].fn!==listener ||
118            !is_fn && listeners[i]!==listener)
119        {
120            events.push(listeners[i]);
121        }
122    }
123    // reset the array, or remove it completely if we have no more listeners
124    if (events.length)
125        this._events[name] = events;
126    else
127        this._events[name] = null;
128    return this;
129}
130
131/**
132 * Register a new EventListener for the given event.
133 *
134 * @param {String} name Name of the event.
135 * @param {Function} fn Callback function.
136 * @param context The context of the function.
137 * @api public
138 */
139EventEmitter.prototype.on = function on(name, fn, context){
140    return add_listener.apply(this, [name, fn, {context: context}]); };
141
142/**
143 * Add an EventListener that's only called once.
144 *
145 * @param {String} name Name of the event.
146 * @param {Function} fn Callback function.
147 * @param context The context of the function.
148 * @api public
149 */
150EventEmitter.prototype.once = function once(name, fn, context){
151    return add_listener.apply(this, [name, fn,
152        {context: context, once: true}]);
153};
154
155EventEmitter.prototype.prependListener = function prependListener(name, fn,
156    context)
157{
158    return add_listener.apply(this, [name, fn, {context: context,
159        prepend: true}]);
160};
161
162EventEmitter.prototype.prependOnceListener = function prependOnceListener(
163    name, fn, context)
164{
165    return this.prependListener(name, fn, {context: context, prepend: true,
166        once: true});
167};
168
169/**
170 * Remove event listeners.
171 *
172 * @param {String} name The event we want to remove.
173 * @param {Function} fn The listener that we need to find.
174 * @api public
175 */
176EventEmitter.prototype.removeListener = function removeListener(name, fn){
177    return remove_listener.apply(this, [name, fn]); };
178
179/**
180 * Remove all listeners or only the listeners for the specified event.
181 *
182 * @param {String} name The event want to remove all listeners for.
183 * @api public
184 */
185EventEmitter.prototype.removeAllListeners = function removeAllListeners(name){
186  if (!this._events)
187      return this;
188  if (name)
189      this._events[name] = null;
190  else
191      this._events = {};
192  return this;
193};
194
195// alias methods names because people roll like that
196EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
197EventEmitter.prototype.addListener = EventEmitter.prototype.on;
198
199// this function doesn't apply anymore
200EventEmitter.prototype.setMaxListeners = function setMaxListeners(){
201  return this; };
202
203EventEmitter.prototype.eventNames = function eventNames(){
204    var _this = this;
205    return Object.keys(this._events).filter(function(e){
206        return _this._events[e]!==null; });
207};
208

209// expose the module
210EventEmitter.EventEmitter = EventEmitter;
211// XXX pavlo: don't exist in node sources, not used in our code, need to check
212// external usages and remove
213EventEmitter.EventEmitter2 = EventEmitter;
214EventEmitter.EventEmitter3 = EventEmitter;
215
216return EventEmitter; }); })();