|
|
// Copyright (c) 2013 Adobe Systems Incorporated. All rights reserved.
|
|
|
//
|
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
// you may not use this file except in compliance with the License.
|
|
|
// You may obtain a copy of the License at
|
|
|
//
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
|
//
|
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
// See the License for the specific language governing permissions and
|
|
|
// limitations under the License.
|
|
|
// ┌────────────────────────────────────────────────────────────┐ \\
|
|
|
// │ Eve 0.4.2 - JavaScript Events Library │ \\
|
|
|
// ├────────────────────────────────────────────────────────────┤ \\
|
|
|
// │ Author Dmitry Baranovskiy (http://dmitry.baranovskiy.com/) │ \\
|
|
|
// └────────────────────────────────────────────────────────────┘ \\
|
|
|
|
|
|
(function (glob) {
|
|
|
var version = "0.4.2",
|
|
|
has = "hasOwnProperty",
|
|
|
separator = /[\.\/]/,
|
|
|
wildcard = "*",
|
|
|
fun = function () {},
|
|
|
numsort = function (a, b) {
|
|
|
return a - b;
|
|
|
},
|
|
|
current_event,
|
|
|
stop,
|
|
|
events = {n: {}},
|
|
|
/*\
|
|
|
* eve
|
|
|
[ method ]
|
|
|
|
|
|
* Fires event with given `name`, given scope and other parameters.
|
|
|
|
|
|
> Arguments
|
|
|
|
|
|
- name (string) name of the *event*, dot (`.`) or slash (`/`) separated
|
|
|
- scope (object) context for the event handlers
|
|
|
- varargs (...) the rest of arguments will be sent to event handlers
|
|
|
|
|
|
= (object) array of returned values from the listeners
|
|
|
\*/
|
|
|
eve = function (name, scope) {
|
|
|
name = String(name);
|
|
|
var e = events,
|
|
|
oldstop = stop,
|
|
|
args = Array.prototype.slice.call(arguments, 2),
|
|
|
listeners = eve.listeners(name),
|
|
|
z = 0,
|
|
|
f = false,
|
|
|
l,
|
|
|
indexed = [],
|
|
|
queue = {},
|
|
|
out = [],
|
|
|
ce = current_event,
|
|
|
errors = [];
|
|
|
current_event = name;
|
|
|
stop = 0;
|
|
|
for (var i = 0, ii = listeners.length; i < ii; i++) if ("zIndex" in listeners[i]) {
|
|
|
indexed.push(listeners[i].zIndex);
|
|
|
if (listeners[i].zIndex < 0) {
|
|
|
queue[listeners[i].zIndex] = listeners[i];
|
|
|
}
|
|
|
}
|
|
|
indexed.sort(numsort);
|
|
|
while (indexed[z] < 0) {
|
|
|
l = queue[indexed[z++]];
|
|
|
out.push(l.apply(scope, args));
|
|
|
if (stop) {
|
|
|
stop = oldstop;
|
|
|
return out;
|
|
|
}
|
|
|
}
|
|
|
for (i = 0; i < ii; i++) {
|
|
|
l = listeners[i];
|
|
|
if ("zIndex" in l) {
|
|
|
if (l.zIndex == indexed[z]) {
|
|
|
out.push(l.apply(scope, args));
|
|
|
if (stop) {
|
|
|
break;
|
|
|
}
|
|
|
do {
|
|
|
z++;
|
|
|
l = queue[indexed[z]];
|
|
|
l && out.push(l.apply(scope, args));
|
|
|
if (stop) {
|
|
|
break;
|
|
|
}
|
|
|
} while (l)
|
|
|
} else {
|
|
|
queue[l.zIndex] = l;
|
|
|
}
|
|
|
} else {
|
|
|
out.push(l.apply(scope, args));
|
|
|
if (stop) {
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
stop = oldstop;
|
|
|
current_event = ce;
|
|
|
return out.length ? out : null;
|
|
|
};
|
|
|
// Undocumented. Debug only.
|
|
|
eve._events = events;
|
|
|
/*\
|
|
|
* eve.listeners
|
|
|
[ method ]
|
|
|
|
|
|
* Internal method which gives you array of all event handlers that will be triggered by the given `name`.
|
|
|
|
|
|
> Arguments
|
|
|
|
|
|
- name (string) name of the event, dot (`.`) or slash (`/`) separated
|
|
|
|
|
|
= (array) array of event handlers
|
|
|
\*/
|
|
|
eve.listeners = function (name) {
|
|
|
var names = name.split(separator),
|
|
|
e = events,
|
|
|
item,
|
|
|
items,
|
|
|
k,
|
|
|
i,
|
|
|
ii,
|
|
|
j,
|
|
|
jj,
|
|
|
nes,
|
|
|
es = [e],
|
|
|
out = [];
|
|
|
for (i = 0, ii = names.length; i < ii; i++) {
|
|
|
nes = [];
|
|
|
for (j = 0, jj = es.length; j < jj; j++) {
|
|
|
e = es[j].n;
|
|
|
items = [e[names[i]], e[wildcard]];
|
|
|
k = 2;
|
|
|
while (k--) {
|
|
|
item = items[k];
|
|
|
if (item) {
|
|
|
nes.push(item);
|
|
|
out = out.concat(item.f || []);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
es = nes;
|
|
|
}
|
|
|
return out;
|
|
|
};
|
|
|
|
|
|
/*\
|
|
|
* eve.on
|
|
|
[ method ]
|
|
|
**
|
|
|
* Binds given event handler with a given name. You can use wildcards “`*`” for the names:
|
|
|
| eve.on("*.under.*", f);
|
|
|
| eve("mouse.under.floor"); // triggers f
|
|
|
* Use @eve to trigger the listener.
|
|
|
**
|
|
|
> Arguments
|
|
|
**
|
|
|
- name (string) name of the event, dot (`.`) or slash (`/`) separated, with optional wildcards
|
|
|
- f (function) event handler function
|
|
|
**
|
|
|
= (function) returned function accepts a single numeric parameter that represents z-index of the handler. It is an optional feature and only used when you need to ensure that some subset of handlers will be invoked in a given order, despite of the order of assignment.
|
|
|
> Example:
|
|
|
| eve.on("mouse", eatIt)(2);
|
|
|
| eve.on("mouse", scream);
|
|
|
| eve.on("mouse", catchIt)(1);
|
|
|
* This will ensure that `catchIt()` function will be called before `eatIt()`.
|
|
|
*
|
|
|
* If you want to put your handler before non-indexed handlers, specify a negative value.
|
|
|
* Note: I assume most of the time you don’t need to worry about z-index, but it’s nice to have this feature “just in case”.
|
|
|
\*/
|
|
|
eve.on = function (name, f) {
|
|
|
name = String(name);
|
|
|
if (typeof f != "function") {
|
|
|
return function () {};
|
|
|
}
|
|
|
var names = name.split(separator),
|
|
|
e = events;
|
|
|
for (var i = 0, ii = names.length; i < ii; i++) {
|
|
|
e = e.n;
|
|
|
e = e.hasOwnProperty(names[i]) && e[names[i]] || (e[names[i]] = {n: {}});
|
|
|
}
|
|
|
e.f = e.f || [];
|
|
|
for (i = 0, ii = e.f.length; i < ii; i++) if (e.f[i] == f) {
|
|
|
return fun;
|
|
|
}
|
|
|
e.f.push(f);
|
|
|
return function (zIndex) {
|
|
|
if (+zIndex == +zIndex) {
|
|
|
f.zIndex = +zIndex;
|
|
|
}
|
|
|
};
|
|
|
};
|
|
|
/*\
|
|
|
* eve.f
|
|
|
[ method ]
|
|
|
**
|
|
|
* Returns function that will fire given event with optional arguments.
|
|
|
* Arguments that will be passed to the result function will be also
|
|
|
* concated to the list of final arguments.
|
|
|
| el.onclick = eve.f("click", 1, 2);
|
|
|
| eve.on("click", function (a, b, c) {
|
|
|
| console.log(a, b, c); // 1, 2, [event object]
|
|
|
| });
|
|
|
> Arguments
|
|
|
- event (string) event name
|
|
|
- varargs (…) and any other arguments
|
|
|
= (function) possible event handler function
|
|
|
\*/
|
|
|
eve.f = function (event) {
|
|
|
var attrs = [].slice.call(arguments, 1);
|
|
|
return function () {
|
|
|
eve.apply(null, [event, null].concat(attrs).concat([].slice.call(arguments, 0)));
|
|
|
};
|
|
|
};
|
|
|
/*\
|
|
|
* eve.stop
|
|
|
[ method ]
|
|
|
**
|
|
|
* Is used inside an event handler to stop the event, preventing any subsequent listeners from firing.
|
|
|
\*/
|
|
|
eve.stop = function () {
|
|
|
stop = 1;
|
|
|
};
|
|
|
/*\
|
|
|
* eve.nt
|
|
|
[ method ]
|
|
|
**
|
|
|
* Could be used inside event handler to figure out actual name of the event.
|
|
|
**
|
|
|
> Arguments
|
|
|
**
|
|
|
- subname (string) #optional subname of the event
|
|
|
**
|
|
|
= (string) name of the event, if `subname` is not specified
|
|
|
* or
|
|
|
= (boolean) `true`, if current event’s name contains `subname`
|
|
|
\*/
|
|
|
eve.nt = function (subname) {
|
|
|
if (subname) {
|
|
|
return new RegExp("(?:\\.|\\/|^)" + subname + "(?:\\.|\\/|$)").test(current_event);
|
|
|
}
|
|
|
return current_event;
|
|
|
};
|
|
|
/*\
|
|
|
* eve.nts
|
|
|
[ method ]
|
|
|
**
|
|
|
* Could be used inside event handler to figure out actual name of the event.
|
|
|
**
|
|
|
**
|
|
|
= (array) names of the event
|
|
|
\*/
|
|
|
eve.nts = function () {
|
|
|
return current_event.split(separator);
|
|
|
};
|
|
|
/*\
|
|
|
* eve.off
|
|
|
[ method ]
|
|
|
**
|
|
|
* Removes given function from the list of event listeners assigned to given name.
|
|
|
* If no arguments specified all the events will be cleared.
|
|
|
**
|
|
|
> Arguments
|
|
|
**
|
|
|
- name (string) name of the event, dot (`.`) or slash (`/`) separated, with optional wildcards
|
|
|
- f (function) event handler function
|
|
|
\*/
|
|
|
/*\
|
|
|
* eve.unbind
|
|
|
[ method ]
|
|
|
**
|
|
|
* See @eve.off
|
|
|
\*/
|
|
|
eve.off = eve.unbind = function (name, f) {
|
|
|
if (!name) {
|
|
|
eve._events = events = {n: {}};
|
|
|
return;
|
|
|
}
|
|
|
var names = name.split(separator),
|
|
|
e,
|
|
|
key,
|
|
|
splice,
|
|
|
i, ii, j, jj,
|
|
|
cur = [events];
|
|
|
for (i = 0, ii = names.length; i < ii; i++) {
|
|
|
for (j = 0; j < cur.length; j += splice.length - 2) {
|
|
|
splice = [j, 1];
|
|
|
e = cur[j].n;
|
|
|
if (names[i] != wildcard) {
|
|
|
if (e[names[i]]) {
|
|
|
splice.push(e[names[i]]);
|
|
|
}
|
|
|
} else {
|
|
|
for (key in e) if (e[has](key)) {
|
|
|
splice.push(e[key]);
|
|
|
}
|
|
|
}
|
|
|
cur.splice.apply(cur, splice);
|
|
|
}
|
|
|
}
|
|
|
for (i = 0, ii = cur.length; i < ii; i++) {
|
|
|
e = cur[i];
|
|
|
while (e.n) {
|
|
|
if (f) {
|
|
|
if (e.f) {
|
|
|
for (j = 0, jj = e.f.length; j < jj; j++) if (e.f[j] == f) {
|
|
|
e.f.splice(j, 1);
|
|
|
break;
|
|
|
}
|
|
|
!e.f.length && delete e.f;
|
|
|
}
|
|
|
for (key in e.n) if (e.n[has](key) && e.n[key].f) {
|
|
|
var funcs = e.n[key].f;
|
|
|
for (j = 0, jj = funcs.length; j < jj; j++) if (funcs[j] == f) {
|
|
|
funcs.splice(j, 1);
|
|
|
break;
|
|
|
}
|
|
|
!funcs.length && delete e.n[key].f;
|
|
|
}
|
|
|
} else {
|
|
|
delete e.f;
|
|
|
for (key in e.n) if (e.n[has](key) && e.n[key].f) {
|
|
|
delete e.n[key].f;
|
|
|
}
|
|
|
}
|
|
|
e = e.n;
|
|
|
}
|
|
|
}
|
|
|
};
|
|
|
/*\
|
|
|
* eve.once
|
|
|
[ method ]
|
|
|
**
|
|
|
* Binds given event handler with a given name to only run once then unbind itself.
|
|
|
| eve.once("login", f);
|
|
|
| eve("login"); // triggers f
|
|
|
| eve("login"); // no listeners
|
|
|
* Use @eve to trigger the listener.
|
|
|
**
|
|
|
> Arguments
|
|
|
**
|
|
|
- name (string) name of the event, dot (`.`) or slash (`/`) separated, with optional wildcards
|
|
|
- f (function) event handler function
|
|
|
**
|
|
|
= (function) same return function as @eve.on
|
|
|
\*/
|
|
|
eve.once = function (name, f) {
|
|
|
var f2 = function () {
|
|
|
eve.unbind(name, f2);
|
|
|
return f.apply(this, arguments);
|
|
|
};
|
|
|
return eve.on(name, f2);
|
|
|
};
|
|
|
/*\
|
|
|
* eve.version
|
|
|
[ property (string) ]
|
|
|
**
|
|
|
* Current version of the library.
|
|
|
\*/
|
|
|
eve.version = version;
|
|
|
eve.toString = function () {
|
|
|
return "You are running Eve " + version;
|
|
|
};
|
|
|
(typeof module != "undefined" && module.exports) ? (module.exports = eve) : (typeof define != "undefined" ? (define("eve", [], function() { return eve; })) : (glob.eve = eve));
|
|
|
})(this);
|
