xonecas.io
142
St

startsInvasion / files

startsInvasion / libs / node_modules / bean / bean.js

10.7 KB
1/*!
2  * bean.js - copyright Jacob Thornton 2011
3  * https://github.com/fat/bean
4  * MIT License
5  * special thanks to:
6  * dean edwards: http://dean.edwards.name/
7  * dperini: https://github.com/dperini/nwevents
8  * the entire mootools team: github.com/mootools/mootools-core
9  */
10!function (context) {
11  var __uid = 1, registry = {}, collected = {},
12      overOut = /over|out/,
13      namespace = /[^\.]*(?=\..*)\.|.*/,
14      stripName = /\..*/,
15      addEvent = 'addEventListener',
16      attachEvent = 'attachEvent',
17      removeEvent = 'removeEventListener',
18      detachEvent = 'detachEvent',
19      doc = context.document || {},
20      root = doc.documentElement || {},
21      W3C_MODEL = root[addEvent],
22      eventSupport = W3C_MODEL ? addEvent : attachEvent,
23
24  isDescendant = function (parent, child) {
25    var node = child.parentNode;
26    while (node !== null) {
27      if (node == parent) {
28        return true;
29      }
30      node = node.parentNode;
31    }
32  },
33
34  retrieveUid = function (obj, uid) {
35    return (obj.__uid = uid || obj.__uid || __uid++);
36  },
37
38  retrieveEvents = function (element) {
39    var uid = retrieveUid(element);
40    return (registry[uid] = registry[uid] || {});
41  },
42
43  listener = W3C_MODEL ? function (element, type, fn, add) {
44    element[add ? addEvent : removeEvent](type, fn, false);
45  } : function (element, type, fn, add, custom) {
46    custom && add && (element['_on' + custom] = element['_on' + custom] || 0);
47    element[add ? attachEvent : detachEvent]('on' + type, fn);
48  },
49
50  nativeHandler = function (element, fn, args) {
51    return function (event) {
52      event = fixEvent(event || ((this.ownerDocument || this.document || this).parentWindow || context).event);
53      return fn.apply(element, [event].concat(args));
54    };
55  },
56
57  customHandler = function (element, fn, type, condition, args) {
58    return function (event) {
59      if (condition ? condition.call(this, event) : W3C_MODEL ? true : event && event.propertyName == '_on' + type || !event) {
60        fn.apply(element, [event].concat(args));
61      }
62    };
63  },
64
65  addListener = function (element, orgType, fn, args) {
66    var type = orgType.replace(stripName, ''),
67        events = retrieveEvents(element),
68        handlers = events[type] || (events[type] = {}),
69        originalFn = fn,
70        uid = retrieveUid(fn, orgType.replace(namespace, ''));
71    if (handlers[uid]) {
72      return element;
73    }
74    var custom = customEvents[type];
75    if (custom) {
76      fn = custom.condition ? customHandler(element, fn, type, custom.condition) : fn;
77      type = custom.base || type;
78    }
79    var isNative = nativeEvents[type];
80    fn = isNative ? nativeHandler(element, fn, args) : customHandler(element, fn, type, false, args);
81    isNative = W3C_MODEL || isNative;
82    if (type == 'unload') {
83      var org = fn;
84      fn = function () {
85        removeListener(element, type, fn) && org();
86      };
87    }
88    element[eventSupport] && listener(element, isNative ? type : 'propertychange', fn, true, !isNative && type);
89    handlers[uid] = fn;
90    fn.__uid = uid;
91    fn.__originalFn = originalFn;
92    return type == 'unload' ? element : (collected[retrieveUid(element)] = element);
93  },
94
95  removeListener = function (element, orgType, handler) {
96    var uid, names, uids, i, events = retrieveEvents(element), type = orgType.replace(stripName, '');
97    if (!events || !events[type]) {
98      return element;
99    }
100    names = orgType.replace(namespace, '');
101    uids = names ? names.split('.') : [handler.__uid];
102    for (i = uids.length; i--;) {
103      uid = uids[i];
104      handler = events[type][uid];
105      delete events[type][uid];
106      if (element[eventSupport]) {
107        type = customEvents[type] ? customEvents[type].base : type;
108        var isNative = W3C_MODEL || nativeEvents[type];
109        listener(element, isNative ? type : 'propertychange', handler, false, !isNative && type);
110      }
111    }
112    return element;
113  },
114
115  del = function (selector, fn, $) {
116    return function (e) {
117      var array = typeof selector == 'string' ? $(selector, this) : selector;
118      for (var target = e.target; target && target != this; target = target.parentNode) {
119        for (var i = array.length; i--;) {
120          if (array[i] == target) {
121            return fn.apply(target, arguments);
122          }
123        }
124      }
125    };
126  },
127
128  add = function (element, events, fn, delfn, $) {
129    if (typeof events == 'object' && !fn) {
130      for (var type in events) {
131        events.hasOwnProperty(type) && add(element, type, events[type]);
132      }
133    } else {
134      var isDel = typeof fn == 'string', types = (isDel ? fn : events).split(' ');
135      fn = isDel ? del(events, delfn, $) : fn;
136      for (var i = types.length; i--;) {
137        addListener(element, types[i], fn, Array.prototype.slice.call(arguments, isDel ? 4 : 3));
138      }
139    }
140    return element;
141  },
142
143  remove = function (element, orgEvents, fn) {
144    var k, type, events, i,
145        isString = typeof(orgEvents) == 'string',
146        names = isString && orgEvents.replace(namespace, ''),
147        rm = removeListener,
148        attached = retrieveEvents(element);
149    if (isString && /\s/.test(orgEvents)) {
150      orgEvents = orgEvents.split(' ');
151      i = orgEvents.length - 1;
152      while (remove(element, orgEvents[i]) && i--) {}
153      return element;
154    }
155    events = isString ? orgEvents.replace(stripName, '') : orgEvents;
156    if (!attached || (isString && !attached[events])) {
157      return element;
158    }
159    if (typeof fn == 'function') {
160      rm(element, events, fn);
161    } else if (names) {
162      rm(element, orgEvents);
163    } else {
164      rm = events ? rm : remove;
165      type = isString && events;
166      events = events ? (fn || attached[events] || events) : attached;
167      for (k in events) {
168        if (events.hasOwnProperty(k)) {
169          rm(element, type || k, events[k]);
170          delete events[k]; // remove unused leaf keys
171        }
172      }
173    }
174    return element;
175  },
176
177  fire = function (element, type, args) {
178    var evt, k, i, types = type.split(' ');
179    for (i = types.length; i--;) {
180      type = types[i].replace(stripName, '');
181      var isNative = nativeEvents[type],
182          isNamespace = types[i].replace(namespace, ''),
183          handlers = retrieveEvents(element)[type];
184      if (isNamespace) {
185        isNamespace = isNamespace.split('.');
186        for (k = isNamespace.length; k--;) {
187          handlers[isNamespace[k]] && handlers[isNamespace[k]].apply(element, args);
188        }
189      } else if (!args && element[eventSupport]) {
190        fireListener(isNative, type, element);
191      } else {
192        for (k in handlers) {
193          handlers.hasOwnProperty(k) && handlers[k].apply(element, args);
194        }
195      }
196    }
197    return element;
198  },
199
200  fireListener = W3C_MODEL ? function (isNative, type, element) {
201    evt = document.createEvent(isNative ? "HTMLEvents" : "UIEvents");
202    evt[isNative ? 'initEvent' : 'initUIEvent'](type, true, true, context, 1);
203    element.dispatchEvent(evt);
204  } : function (isNative, type, element) {
205    isNative ? element.fireEvent('on' + type, document.createEventObject()) : element['_on' + type]++;
206  },
207
208  clone = function (element, from, type) {
209    var events = retrieveEvents(from), obj, k;
210    var uid = retrieveUid(element);
211    obj = type ? events[type] : events;
212    for (k in obj) {
213      obj.hasOwnProperty(k) && (type ? add : clone)(element, type || from, type ? obj[k].__originalFn : k);
214    }
215    return element;
216  },
217
218  fixEvent = function (e) {
219    var result = {};
220    if (!e) {
221      return result;
222    }
223    var type = e.type, target = e.target || e.srcElement;
224    result.preventDefault = fixEvent.preventDefault(e);
225    result.stopPropagation = fixEvent.stopPropagation(e);
226    result.target = target && target.nodeType == 3 ? target.parentNode : target;
227    if (~type.indexOf('key')) {
228      result.keyCode = e.which || e.keyCode;
229    } else if ((/click|mouse|menu/i).test(type)) {
230      result.rightClick = e.which == 3 || e.button == 2;
231      result.pos = { x: 0, y: 0 };
232      if (e.pageX || e.pageY) {
233        result.clientX = e.pageX;
234        result.clientY = e.pageY;
235      } else if (e.clientX || e.clientY) {
236        result.clientX = e.clientX + document.body.scrollLeft + document.documentElement.scrollLeft;
237        result.clientY = e.clientY + document.body.scrollTop + document.documentElement.scrollTop;
238      }
239      overOut.test(type) && (result.relatedTarget = e.relatedTarget || e[(type == 'mouseover' ? 'from' : 'to') + 'Element']);
240    }
241    for (var k in e) {
242      if (!(k in result)) {
243        result[k] = e[k];
244      }
245    }
246    return result;
247  };
248
249  fixEvent.preventDefault = function (e) {
250    return function () {
251      if (e.preventDefault) {
252        e.preventDefault();
253      }
254      else {
255        e.returnValue = false;
256      }
257    };
258  };
259
260  fixEvent.stopPropagation = function (e) {
261    return function () {
262      if (e.stopPropagation) {
263        e.stopPropagation();
264      } else {
265        e.cancelBubble = true;
266      }
267    };
268  };
269
270  var nativeEvents = { click: 1, dblclick: 1, mouseup: 1, mousedown: 1, contextmenu: 1, //mouse buttons
271    mousewheel: 1, DOMMouseScroll: 1, //mouse wheel
272    mouseover: 1, mouseout: 1, mousemove: 1, selectstart: 1, selectend: 1, //mouse movement
273    keydown: 1, keypress: 1, keyup: 1, //keyboard
274    orientationchange: 1, // mobile
275    touchstart: 1, touchmove: 1, touchend: 1, touchcancel: 1, // touch
276    gesturestart: 1, gesturechange: 1, gestureend: 1, // gesture
277    focus: 1, blur: 1, change: 1, reset: 1, select: 1, submit: 1, //form elements
278    load: 1, unload: 1, beforeunload: 1, resize: 1, move: 1, DOMContentLoaded: 1, readystatechange: 1, //window
279    error: 1, abort: 1, scroll: 1 }; //misc
280
281  function check(event) {
282    var related = event.relatedTarget;
283    if (!related) {
284      return related === null;
285    }
286    return (related != this && related.prefix != 'xul' && !/document/.test(this.toString()) && !isDescendant(this, related));
287  }
288
289  var customEvents = {
290    mouseenter: { base: 'mouseover', condition: check },
291    mouseleave: { base: 'mouseout', condition: check },
292    mousewheel: { base: /Firefox/.test(navigator.userAgent) ? 'DOMMouseScroll' : 'mousewheel' }
293  };
294
295  var bean = { add: add, remove: remove, clone: clone, fire: fire };
296
297  var clean = function (el) {
298    var uid = remove(el).__uid;
299    if (uid) {
300      delete collected[uid];
301      delete registry[uid];
302    }
303  };
304
305  if (context[attachEvent]) {
306    add(context, 'unload', function () {
307      for (var k in collected) {
308        collected.hasOwnProperty(k) && clean(collected[k]);
309      }
310      context.CollectGarbage && CollectGarbage();
311    });
312  }
313
314  var oldBean = context.bean;
315  bean.noConflict = function () {
316    context.bean = oldBean;
317    return this;
318  };
319
320  (typeof module !== 'undefined' && module.exports) ?
321    (module.exports = bean) :
322    (context['bean'] = bean);
323
324}(this);