1868 lines
39 KiB
JavaScript
1868 lines
39 KiB
JavaScript
;(function(){
|
|
|
|
/**
|
|
* Require the given path.
|
|
*
|
|
* @param {String} path
|
|
* @return {Object} exports
|
|
* @api public
|
|
*/
|
|
|
|
function require(path, parent, orig) {
|
|
var resolved = require.resolve(path);
|
|
|
|
// lookup failed
|
|
if (null == resolved) {
|
|
orig = orig || path;
|
|
parent = parent || 'root';
|
|
var err = new Error('Failed to require "' + orig + '" from "' + parent + '"');
|
|
err.path = orig;
|
|
err.parent = parent;
|
|
err.require = true;
|
|
throw err;
|
|
}
|
|
|
|
var module = require.modules[resolved];
|
|
|
|
// perform real require()
|
|
// by invoking the module's
|
|
// registered function
|
|
if (!module._resolving && !module.exports) {
|
|
var mod = {};
|
|
mod.exports = {};
|
|
mod.client = mod.component = true;
|
|
module._resolving = true;
|
|
module.call(this, mod.exports, require.relative(resolved), mod);
|
|
delete module._resolving;
|
|
module.exports = mod.exports;
|
|
}
|
|
|
|
return module.exports;
|
|
}
|
|
|
|
/**
|
|
* Registered modules.
|
|
*/
|
|
|
|
require.modules = {};
|
|
|
|
/**
|
|
* Registered aliases.
|
|
*/
|
|
|
|
require.aliases = {};
|
|
|
|
/**
|
|
* Resolve `path`.
|
|
*
|
|
* Lookup:
|
|
*
|
|
* - PATH/index.js
|
|
* - PATH.js
|
|
* - PATH
|
|
*
|
|
* @param {String} path
|
|
* @return {String} path or null
|
|
* @api private
|
|
*/
|
|
|
|
require.resolve = function(path) {
|
|
if (path.charAt(0) === '/') path = path.slice(1);
|
|
|
|
var paths = [
|
|
path,
|
|
path + '.js',
|
|
path + '.json',
|
|
path + '/index.js',
|
|
path + '/index.json'
|
|
];
|
|
|
|
for (var i = 0; i < paths.length; i++) {
|
|
var path = paths[i];
|
|
if (require.modules.hasOwnProperty(path)) return path;
|
|
if (require.aliases.hasOwnProperty(path)) return require.aliases[path];
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Normalize `path` relative to the current path.
|
|
*
|
|
* @param {String} curr
|
|
* @param {String} path
|
|
* @return {String}
|
|
* @api private
|
|
*/
|
|
|
|
require.normalize = function(curr, path) {
|
|
var segs = [];
|
|
|
|
if ('.' != path.charAt(0)) return path;
|
|
|
|
curr = curr.split('/');
|
|
path = path.split('/');
|
|
|
|
for (var i = 0; i < path.length; ++i) {
|
|
if ('..' == path[i]) {
|
|
curr.pop();
|
|
} else if ('.' != path[i] && '' != path[i]) {
|
|
segs.push(path[i]);
|
|
}
|
|
}
|
|
|
|
return curr.concat(segs).join('/');
|
|
};
|
|
|
|
/**
|
|
* Register module at `path` with callback `definition`.
|
|
*
|
|
* @param {String} path
|
|
* @param {Function} definition
|
|
* @api private
|
|
*/
|
|
|
|
require.register = function(path, definition) {
|
|
require.modules[path] = definition;
|
|
};
|
|
|
|
/**
|
|
* Alias a module definition.
|
|
*
|
|
* @param {String} from
|
|
* @param {String} to
|
|
* @api private
|
|
*/
|
|
|
|
require.alias = function(from, to) {
|
|
if (!require.modules.hasOwnProperty(from)) {
|
|
throw new Error('Failed to alias "' + from + '", it does not exist');
|
|
}
|
|
require.aliases[to] = from;
|
|
};
|
|
|
|
/**
|
|
* Return a require function relative to the `parent` path.
|
|
*
|
|
* @param {String} parent
|
|
* @return {Function}
|
|
* @api private
|
|
*/
|
|
|
|
require.relative = function(parent) {
|
|
var p = require.normalize(parent, '..');
|
|
|
|
/**
|
|
* lastIndexOf helper.
|
|
*/
|
|
|
|
function lastIndexOf(arr, obj) {
|
|
var i = arr.length;
|
|
while (i--) {
|
|
if (arr[i] === obj) return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* The relative require() itself.
|
|
*/
|
|
|
|
function localRequire(path) {
|
|
var resolved = localRequire.resolve(path);
|
|
return require(resolved, parent, path);
|
|
}
|
|
|
|
/**
|
|
* Resolve relative to the parent.
|
|
*/
|
|
|
|
localRequire.resolve = function(path) {
|
|
var c = path.charAt(0);
|
|
if ('/' == c) return path.slice(1);
|
|
if ('.' == c) return require.normalize(p, path);
|
|
|
|
// resolve deps by returning
|
|
// the dep in the nearest "deps"
|
|
// directory
|
|
var segs = parent.split('/');
|
|
var i = lastIndexOf(segs, 'deps') + 1;
|
|
if (!i) i = 0;
|
|
path = segs.slice(0, i + 1).join('/') + '/deps/' + path;
|
|
return path;
|
|
};
|
|
|
|
/**
|
|
* Check if module is defined at `path`.
|
|
*/
|
|
|
|
localRequire.exists = function(path) {
|
|
return require.modules.hasOwnProperty(localRequire.resolve(path));
|
|
};
|
|
|
|
return localRequire;
|
|
};
|
|
require.register("component-event/index.js", function(exports, require, module){
|
|
var bind = window.addEventListener ? 'addEventListener' : 'attachEvent',
|
|
unbind = window.removeEventListener ? 'removeEventListener' : 'detachEvent',
|
|
prefix = bind !== 'addEventListener' ? 'on' : '';
|
|
|
|
/**
|
|
* Bind `el` event `type` to `fn`.
|
|
*
|
|
* @param {Element} el
|
|
* @param {String} type
|
|
* @param {Function} fn
|
|
* @param {Boolean} capture
|
|
* @return {Function}
|
|
* @api public
|
|
*/
|
|
|
|
exports.bind = function(el, type, fn, capture){
|
|
el[bind](prefix + type, fn, capture || false);
|
|
return fn;
|
|
};
|
|
|
|
/**
|
|
* Unbind `el` event `type`'s callback `fn`.
|
|
*
|
|
* @param {Element} el
|
|
* @param {String} type
|
|
* @param {Function} fn
|
|
* @param {Boolean} capture
|
|
* @return {Function}
|
|
* @api public
|
|
*/
|
|
|
|
exports.unbind = function(el, type, fn, capture){
|
|
el[unbind](prefix + type, fn, capture || false);
|
|
return fn;
|
|
};
|
|
});
|
|
require.register("component-query/index.js", function(exports, require, module){
|
|
function one(selector, el) {
|
|
return el.querySelector(selector);
|
|
}
|
|
|
|
exports = module.exports = function(selector, el){
|
|
el = el || document;
|
|
return one(selector, el);
|
|
};
|
|
|
|
exports.all = function(selector, el){
|
|
el = el || document;
|
|
return el.querySelectorAll(selector);
|
|
};
|
|
|
|
exports.engine = function(obj){
|
|
if (!obj.one) throw new Error('.one callback required');
|
|
if (!obj.all) throw new Error('.all callback required');
|
|
one = obj.one;
|
|
exports.all = obj.all;
|
|
return exports;
|
|
};
|
|
|
|
});
|
|
require.register("component-matches-selector/index.js", function(exports, require, module){
|
|
/**
|
|
* Module dependencies.
|
|
*/
|
|
|
|
var query = require('query');
|
|
|
|
/**
|
|
* Element prototype.
|
|
*/
|
|
|
|
var proto = Element.prototype;
|
|
|
|
/**
|
|
* Vendor function.
|
|
*/
|
|
|
|
var vendor = proto.matches
|
|
|| proto.webkitMatchesSelector
|
|
|| proto.mozMatchesSelector
|
|
|| proto.msMatchesSelector
|
|
|| proto.oMatchesSelector;
|
|
|
|
/**
|
|
* Expose `match()`.
|
|
*/
|
|
|
|
module.exports = match;
|
|
|
|
/**
|
|
* Match `el` to `selector`.
|
|
*
|
|
* @param {Element} el
|
|
* @param {String} selector
|
|
* @return {Boolean}
|
|
* @api public
|
|
*/
|
|
|
|
function match(el, selector) {
|
|
if (vendor) return vendor.call(el, selector);
|
|
var nodes = query.all(selector, el.parentNode);
|
|
for (var i = 0; i < nodes.length; ++i) {
|
|
if (nodes[i] == el) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
});
|
|
require.register("discore-closest/index.js", function(exports, require, module){
|
|
var matches = require('matches-selector')
|
|
|
|
module.exports = function (element, selector, checkYoSelf, root) {
|
|
element = checkYoSelf ? {parentNode: element} : element
|
|
|
|
root = root || document
|
|
|
|
// Make sure `element !== document` and `element != null`
|
|
// otherwise we get an illegal invocation
|
|
while ((element = element.parentNode) && element !== document) {
|
|
if (matches(element, selector))
|
|
return element
|
|
// After `matches` on the edge case that
|
|
// the selector matches the root
|
|
// (when the root is not the document)
|
|
if (element === root)
|
|
return
|
|
}
|
|
}
|
|
});
|
|
require.register("component-delegate/index.js", function(exports, require, module){
|
|
/**
|
|
* Module dependencies.
|
|
*/
|
|
|
|
var closest = require('closest')
|
|
, event = require('event');
|
|
|
|
/**
|
|
* Delegate event `type` to `selector`
|
|
* and invoke `fn(e)`. A callback function
|
|
* is returned which may be passed to `.unbind()`.
|
|
*
|
|
* @param {Element} el
|
|
* @param {String} selector
|
|
* @param {String} type
|
|
* @param {Function} fn
|
|
* @param {Boolean} capture
|
|
* @return {Function}
|
|
* @api public
|
|
*/
|
|
|
|
exports.bind = function(el, selector, type, fn, capture){
|
|
return event.bind(el, type, function(e){
|
|
var target = e.target || e.srcElement;
|
|
e.delegateTarget = closest(target, selector, true, el);
|
|
if (e.delegateTarget) fn.call(el, e);
|
|
}, capture);
|
|
};
|
|
|
|
/**
|
|
* Unbind event `type`'s callback `fn`.
|
|
*
|
|
* @param {Element} el
|
|
* @param {String} type
|
|
* @param {Function} fn
|
|
* @param {Boolean} capture
|
|
* @api public
|
|
*/
|
|
|
|
exports.unbind = function(el, type, fn, capture){
|
|
event.unbind(el, type, fn, capture);
|
|
};
|
|
|
|
});
|
|
require.register("component-events/index.js", function(exports, require, module){
|
|
|
|
/**
|
|
* Module dependencies.
|
|
*/
|
|
|
|
var events = require('event');
|
|
var delegate = require('delegate');
|
|
|
|
/**
|
|
* Expose `Events`.
|
|
*/
|
|
|
|
module.exports = Events;
|
|
|
|
/**
|
|
* Initialize an `Events` with the given
|
|
* `el` object which events will be bound to,
|
|
* and the `obj` which will receive method calls.
|
|
*
|
|
* @param {Object} el
|
|
* @param {Object} obj
|
|
* @api public
|
|
*/
|
|
|
|
function Events(el, obj) {
|
|
if (!(this instanceof Events)) return new Events(el, obj);
|
|
if (!el) throw new Error('element required');
|
|
if (!obj) throw new Error('object required');
|
|
this.el = el;
|
|
this.obj = obj;
|
|
this._events = {};
|
|
}
|
|
|
|
/**
|
|
* Subscription helper.
|
|
*/
|
|
|
|
Events.prototype.sub = function(event, method, cb){
|
|
this._events[event] = this._events[event] || {};
|
|
this._events[event][method] = cb;
|
|
};
|
|
|
|
/**
|
|
* Bind to `event` with optional `method` name.
|
|
* When `method` is undefined it becomes `event`
|
|
* with the "on" prefix.
|
|
*
|
|
* Examples:
|
|
*
|
|
* Direct event handling:
|
|
*
|
|
* events.bind('click') // implies "onclick"
|
|
* events.bind('click', 'remove')
|
|
* events.bind('click', 'sort', 'asc')
|
|
*
|
|
* Delegated event handling:
|
|
*
|
|
* events.bind('click li > a')
|
|
* events.bind('click li > a', 'remove')
|
|
* events.bind('click a.sort-ascending', 'sort', 'asc')
|
|
* events.bind('click a.sort-descending', 'sort', 'desc')
|
|
*
|
|
* @param {String} event
|
|
* @param {String|function} [method]
|
|
* @return {Function} callback
|
|
* @api public
|
|
*/
|
|
|
|
Events.prototype.bind = function(event, method){
|
|
var e = parse(event);
|
|
var el = this.el;
|
|
var obj = this.obj;
|
|
var name = e.name;
|
|
var method = method || 'on' + name;
|
|
var args = [].slice.call(arguments, 2);
|
|
|
|
// callback
|
|
function cb(){
|
|
var a = [].slice.call(arguments).concat(args);
|
|
obj[method].apply(obj, a);
|
|
}
|
|
|
|
// bind
|
|
if (e.selector) {
|
|
cb = delegate.bind(el, e.selector, name, cb);
|
|
} else {
|
|
events.bind(el, name, cb);
|
|
}
|
|
|
|
// subscription for unbinding
|
|
this.sub(name, method, cb);
|
|
|
|
return cb;
|
|
};
|
|
|
|
/**
|
|
* Unbind a single binding, all bindings for `event`,
|
|
* or all bindings within the manager.
|
|
*
|
|
* Examples:
|
|
*
|
|
* Unbind direct handlers:
|
|
*
|
|
* events.unbind('click', 'remove')
|
|
* events.unbind('click')
|
|
* events.unbind()
|
|
*
|
|
* Unbind delegate handlers:
|
|
*
|
|
* events.unbind('click', 'remove')
|
|
* events.unbind('click')
|
|
* events.unbind()
|
|
*
|
|
* @param {String|Function} [event]
|
|
* @param {String|Function} [method]
|
|
* @api public
|
|
*/
|
|
|
|
Events.prototype.unbind = function(event, method){
|
|
if (0 == arguments.length) return this.unbindAll();
|
|
if (1 == arguments.length) return this.unbindAllOf(event);
|
|
|
|
// no bindings for this event
|
|
var bindings = this._events[event];
|
|
if (!bindings) return;
|
|
|
|
// no bindings for this method
|
|
var cb = bindings[method];
|
|
if (!cb) return;
|
|
|
|
events.unbind(this.el, event, cb);
|
|
};
|
|
|
|
/**
|
|
* Unbind all events.
|
|
*
|
|
* @api private
|
|
*/
|
|
|
|
Events.prototype.unbindAll = function(){
|
|
for (var event in this._events) {
|
|
this.unbindAllOf(event);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Unbind all events for `event`.
|
|
*
|
|
* @param {String} event
|
|
* @api private
|
|
*/
|
|
|
|
Events.prototype.unbindAllOf = function(event){
|
|
var bindings = this._events[event];
|
|
if (!bindings) return;
|
|
|
|
for (var method in bindings) {
|
|
this.unbind(event, method);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Parse `event`.
|
|
*
|
|
* @param {String} event
|
|
* @return {Object}
|
|
* @api private
|
|
*/
|
|
|
|
function parse(event) {
|
|
var parts = event.split(/ +/);
|
|
return {
|
|
name: parts.shift(),
|
|
selector: parts.join(' ')
|
|
}
|
|
}
|
|
|
|
});
|
|
require.register("component-indexof/index.js", function(exports, require, module){
|
|
module.exports = function(arr, obj){
|
|
if (arr.indexOf) return arr.indexOf(obj);
|
|
for (var i = 0; i < arr.length; ++i) {
|
|
if (arr[i] === obj) return i;
|
|
}
|
|
return -1;
|
|
};
|
|
});
|
|
require.register("component-classes/index.js", function(exports, require, module){
|
|
/**
|
|
* Module dependencies.
|
|
*/
|
|
|
|
var index = require('indexof');
|
|
|
|
/**
|
|
* Whitespace regexp.
|
|
*/
|
|
|
|
var re = /\s+/;
|
|
|
|
/**
|
|
* toString reference.
|
|
*/
|
|
|
|
var toString = Object.prototype.toString;
|
|
|
|
/**
|
|
* Wrap `el` in a `ClassList`.
|
|
*
|
|
* @param {Element} el
|
|
* @return {ClassList}
|
|
* @api public
|
|
*/
|
|
|
|
module.exports = function(el){
|
|
return new ClassList(el);
|
|
};
|
|
|
|
/**
|
|
* Initialize a new ClassList for `el`.
|
|
*
|
|
* @param {Element} el
|
|
* @api private
|
|
*/
|
|
|
|
function ClassList(el) {
|
|
if (!el) throw new Error('A DOM element reference is required');
|
|
this.el = el;
|
|
this.list = el.classList;
|
|
}
|
|
|
|
/**
|
|
* Add class `name` if not already present.
|
|
*
|
|
* @param {String} name
|
|
* @return {ClassList}
|
|
* @api public
|
|
*/
|
|
|
|
ClassList.prototype.add = function(name){
|
|
// classList
|
|
if (this.list) {
|
|
this.list.add(name);
|
|
return this;
|
|
}
|
|
|
|
// fallback
|
|
var arr = this.array();
|
|
var i = index(arr, name);
|
|
if (!~i) arr.push(name);
|
|
this.el.className = arr.join(' ');
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Remove class `name` when present, or
|
|
* pass a regular expression to remove
|
|
* any which match.
|
|
*
|
|
* @param {String|RegExp} name
|
|
* @return {ClassList}
|
|
* @api public
|
|
*/
|
|
|
|
ClassList.prototype.remove = function(name){
|
|
if ('[object RegExp]' == toString.call(name)) {
|
|
return this.removeMatching(name);
|
|
}
|
|
|
|
// classList
|
|
if (this.list) {
|
|
this.list.remove(name);
|
|
return this;
|
|
}
|
|
|
|
// fallback
|
|
var arr = this.array();
|
|
var i = index(arr, name);
|
|
if (~i) arr.splice(i, 1);
|
|
this.el.className = arr.join(' ');
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Remove all classes matching `re`.
|
|
*
|
|
* @param {RegExp} re
|
|
* @return {ClassList}
|
|
* @api private
|
|
*/
|
|
|
|
ClassList.prototype.removeMatching = function(re){
|
|
var arr = this.array();
|
|
for (var i = 0; i < arr.length; i++) {
|
|
if (re.test(arr[i])) {
|
|
this.remove(arr[i]);
|
|
}
|
|
}
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Toggle class `name`, can force state via `force`.
|
|
*
|
|
* For browsers that support classList, but do not support `force` yet,
|
|
* the mistake will be detected and corrected.
|
|
*
|
|
* @param {String} name
|
|
* @param {Boolean} force
|
|
* @return {ClassList}
|
|
* @api public
|
|
*/
|
|
|
|
ClassList.prototype.toggle = function(name, force){
|
|
// classList
|
|
if (this.list) {
|
|
if ("undefined" !== typeof force) {
|
|
if (force !== this.list.toggle(name, force)) {
|
|
this.list.toggle(name); // toggle again to correct
|
|
}
|
|
} else {
|
|
this.list.toggle(name);
|
|
}
|
|
return this;
|
|
}
|
|
|
|
// fallback
|
|
if ("undefined" !== typeof force) {
|
|
if (!force) {
|
|
this.remove(name);
|
|
} else {
|
|
this.add(name);
|
|
}
|
|
} else {
|
|
if (this.has(name)) {
|
|
this.remove(name);
|
|
} else {
|
|
this.add(name);
|
|
}
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Return an array of classes.
|
|
*
|
|
* @return {Array}
|
|
* @api public
|
|
*/
|
|
|
|
ClassList.prototype.array = function(){
|
|
var str = this.el.className.replace(/^\s+|\s+$/g, '');
|
|
var arr = str.split(re);
|
|
if ('' === arr[0]) arr.shift();
|
|
return arr;
|
|
};
|
|
|
|
/**
|
|
* Check if class `name` is present.
|
|
*
|
|
* @param {String} name
|
|
* @return {ClassList}
|
|
* @api public
|
|
*/
|
|
|
|
ClassList.prototype.has =
|
|
ClassList.prototype.contains = function(name){
|
|
return this.list
|
|
? this.list.contains(name)
|
|
: !! ~index(this.array(), name);
|
|
};
|
|
|
|
});
|
|
require.register("component-emitter/index.js", function(exports, require, module){
|
|
|
|
/**
|
|
* Expose `Emitter`.
|
|
*/
|
|
|
|
module.exports = Emitter;
|
|
|
|
/**
|
|
* Initialize a new `Emitter`.
|
|
*
|
|
* @api public
|
|
*/
|
|
|
|
function Emitter(obj) {
|
|
if (obj) return mixin(obj);
|
|
};
|
|
|
|
/**
|
|
* Mixin the emitter properties.
|
|
*
|
|
* @param {Object} obj
|
|
* @return {Object}
|
|
* @api private
|
|
*/
|
|
|
|
function mixin(obj) {
|
|
for (var key in Emitter.prototype) {
|
|
obj[key] = Emitter.prototype[key];
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
/**
|
|
* Listen on the given `event` with `fn`.
|
|
*
|
|
* @param {String} event
|
|
* @param {Function} fn
|
|
* @return {Emitter}
|
|
* @api public
|
|
*/
|
|
|
|
Emitter.prototype.on =
|
|
Emitter.prototype.addEventListener = function(event, fn){
|
|
this._callbacks = this._callbacks || {};
|
|
(this._callbacks[event] = this._callbacks[event] || [])
|
|
.push(fn);
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Adds an `event` listener that will be invoked a single
|
|
* time then automatically removed.
|
|
*
|
|
* @param {String} event
|
|
* @param {Function} fn
|
|
* @return {Emitter}
|
|
* @api public
|
|
*/
|
|
|
|
Emitter.prototype.once = function(event, fn){
|
|
var self = this;
|
|
this._callbacks = this._callbacks || {};
|
|
|
|
function on() {
|
|
self.off(event, on);
|
|
fn.apply(this, arguments);
|
|
}
|
|
|
|
on.fn = fn;
|
|
this.on(event, on);
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Remove the given callback for `event` or all
|
|
* registered callbacks.
|
|
*
|
|
* @param {String} event
|
|
* @param {Function} fn
|
|
* @return {Emitter}
|
|
* @api public
|
|
*/
|
|
|
|
Emitter.prototype.off =
|
|
Emitter.prototype.removeListener =
|
|
Emitter.prototype.removeAllListeners =
|
|
Emitter.prototype.removeEventListener = function(event, fn){
|
|
this._callbacks = this._callbacks || {};
|
|
|
|
// all
|
|
if (0 == arguments.length) {
|
|
this._callbacks = {};
|
|
return this;
|
|
}
|
|
|
|
// specific event
|
|
var callbacks = this._callbacks[event];
|
|
if (!callbacks) return this;
|
|
|
|
// remove all handlers
|
|
if (1 == arguments.length) {
|
|
delete this._callbacks[event];
|
|
return this;
|
|
}
|
|
|
|
// remove specific handler
|
|
var cb;
|
|
for (var i = 0; i < callbacks.length; i++) {
|
|
cb = callbacks[i];
|
|
if (cb === fn || cb.fn === fn) {
|
|
callbacks.splice(i, 1);
|
|
break;
|
|
}
|
|
}
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Emit `event` with the given args.
|
|
*
|
|
* @param {String} event
|
|
* @param {Mixed} ...
|
|
* @return {Emitter}
|
|
*/
|
|
|
|
Emitter.prototype.emit = function(event){
|
|
this._callbacks = this._callbacks || {};
|
|
var args = [].slice.call(arguments, 1)
|
|
, callbacks = this._callbacks[event];
|
|
|
|
if (callbacks) {
|
|
callbacks = callbacks.slice(0);
|
|
for (var i = 0, len = callbacks.length; i < len; ++i) {
|
|
callbacks[i].apply(this, args);
|
|
}
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Return array of callbacks for `event`.
|
|
*
|
|
* @param {String} event
|
|
* @return {Array}
|
|
* @api public
|
|
*/
|
|
|
|
Emitter.prototype.listeners = function(event){
|
|
this._callbacks = this._callbacks || {};
|
|
return this._callbacks[event] || [];
|
|
};
|
|
|
|
/**
|
|
* Check if this emitter has `event` handlers.
|
|
*
|
|
* @param {String} event
|
|
* @return {Boolean}
|
|
* @api public
|
|
*/
|
|
|
|
Emitter.prototype.hasListeners = function(event){
|
|
return !! this.listeners(event).length;
|
|
};
|
|
|
|
});
|
|
require.register("ui-component-mouse/index.js", function(exports, require, module){
|
|
|
|
/**
|
|
* dependencies.
|
|
*/
|
|
|
|
var emitter = require('emitter')
|
|
, event = require('event');
|
|
|
|
/**
|
|
* export `Mouse`
|
|
*/
|
|
|
|
module.exports = function(el, obj){
|
|
return new Mouse(el, obj);
|
|
};
|
|
|
|
/**
|
|
* initialize new `Mouse`.
|
|
*
|
|
* @param {Element} el
|
|
* @param {Object} obj
|
|
*/
|
|
|
|
function Mouse(el, obj){
|
|
this.obj = obj || {};
|
|
this.el = el;
|
|
}
|
|
|
|
/**
|
|
* mixin emitter.
|
|
*/
|
|
|
|
emitter(Mouse.prototype);
|
|
|
|
/**
|
|
* bind mouse.
|
|
*
|
|
* @return {Mouse}
|
|
*/
|
|
|
|
Mouse.prototype.bind = function(){
|
|
var obj = this.obj
|
|
, self = this;
|
|
|
|
// up
|
|
function up(e){
|
|
obj.onmouseup && obj.onmouseup(e);
|
|
event.unbind(document, 'mousemove', move);
|
|
event.unbind(document, 'mouseup', up);
|
|
self.emit('up', e);
|
|
}
|
|
|
|
// move
|
|
function move(e){
|
|
obj.onmousemove && obj.onmousemove(e);
|
|
self.emit('move', e);
|
|
}
|
|
|
|
// down
|
|
self.down = function(e){
|
|
obj.onmousedown && obj.onmousedown(e);
|
|
event.bind(document, 'mouseup', up);
|
|
event.bind(document, 'mousemove', move);
|
|
self.emit('down', e);
|
|
};
|
|
|
|
// bind all.
|
|
event.bind(this.el, 'mousedown', self.down);
|
|
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* unbind mouse.
|
|
*
|
|
* @return {Mouse}
|
|
*/
|
|
|
|
Mouse.prototype.unbind = function(){
|
|
event.unbind(this.el, 'mousedown', this.down);
|
|
this.down = null;
|
|
};
|
|
|
|
});
|
|
require.register("abpetkov-percentage-calc/percentage-calc.js", function(exports, require, module){
|
|
|
|
/**
|
|
* Percentage-Calc 0.0.1
|
|
* https://github.com/abpetkov/percentage-calc
|
|
*
|
|
* Authored by Alexander Petkov
|
|
* https://github.com/abpetkov
|
|
*
|
|
* Copyright 2014, Alexander Petkov
|
|
* License: The MIT License (MIT)
|
|
* http://opensource.org/licenses/MIT
|
|
*
|
|
*/
|
|
|
|
/**
|
|
* Check if number.
|
|
*
|
|
* @param {Number} num
|
|
* @returns {Boolean}
|
|
* @api public
|
|
*/
|
|
|
|
exports.isNumber = function(num) {
|
|
return (typeof num === 'number') ? true : false;
|
|
};
|
|
|
|
/**
|
|
* Calculate percentage of a number.
|
|
*
|
|
* @param {Number} perc
|
|
* @param {Number} num
|
|
* @returns {Number} result
|
|
* @api public
|
|
*/
|
|
|
|
exports.of = function(perc, num) {
|
|
if (exports.isNumber(perc) && exports.isNumber(num)) return (perc / 100) * num;
|
|
};
|
|
|
|
/**
|
|
* Calculate percentage of a number out ot another number.
|
|
*
|
|
* @param {Number} part
|
|
* @param {Number} target
|
|
* @returns {Number} result
|
|
* @api public
|
|
*/
|
|
|
|
exports.from = function(part, target) {
|
|
if (exports.isNumber(part) && exports.isNumber(target)) return (part / target) * 100;
|
|
};
|
|
});
|
|
require.register("abpetkov-closest-num/closest-num.js", function(exports, require, module){
|
|
/**
|
|
* Closest-num 0.0.1
|
|
* https://github.com/abpetkov/closest-num
|
|
*
|
|
* Author: Alexander Petkov
|
|
* https://github.com/abpetkov
|
|
*
|
|
* Copyright 2014, Alexander Petkov
|
|
* License: The MIT License (MIT)
|
|
* http://opensource.org/licenses/MIT
|
|
*
|
|
*/
|
|
|
|
/**
|
|
* Get closest number in array.
|
|
*
|
|
* @param {Number} target
|
|
* @param {Array} points
|
|
* @returns {Number} closest
|
|
* @api private
|
|
*/
|
|
|
|
exports.find = function(target, points) {
|
|
var diff = null
|
|
, current = null
|
|
, closest = points[0];
|
|
|
|
for (i = 0; i < points.length; i++) {
|
|
diff = Math.abs(target - closest);
|
|
current = Math.abs(target - points[i]);
|
|
if (current < diff) closest = points[i];
|
|
}
|
|
|
|
return closest;
|
|
};
|
|
});
|
|
require.register("vesln-super/lib/super.js", function(exports, require, module){
|
|
/**
|
|
* slice
|
|
*/
|
|
|
|
var slice = Array.prototype.slice;
|
|
|
|
/**
|
|
* Primary export
|
|
*/
|
|
|
|
var exports = module.exports = super_;
|
|
|
|
/**
|
|
* ### _super (dest, orig)
|
|
*
|
|
* Inherits the prototype methods or merges objects.
|
|
* This is the primary export and it is recommended
|
|
* that it be imported as `inherits` in node to match
|
|
* the auto imported browser interface.
|
|
*
|
|
* var inherits = require('super');
|
|
*
|
|
* @param {Object|Function} destination object
|
|
* @param {Object|Function} source object
|
|
* @name _super
|
|
* @api public
|
|
*/
|
|
|
|
function super_() {
|
|
var args = slice.call(arguments);
|
|
if (!args.length) return;
|
|
if (typeof args[0] !== 'function') return exports.merge(args);
|
|
exports.inherits.apply(null, args);
|
|
};
|
|
|
|
/**
|
|
* ### extend (proto[, klass])
|
|
*
|
|
* Provide `.extend` mechanism to allow extenion without
|
|
* needing to use dependancy.
|
|
*
|
|
* function Bar () {
|
|
* this._konstructed = true;
|
|
* }
|
|
*
|
|
* Bar.extend = inherits.extend;
|
|
*
|
|
* var Fu = Bar.extend({
|
|
* initialize: function () {
|
|
* this._initialized = true;
|
|
* }
|
|
* });
|
|
*
|
|
* var fu = new Fu();
|
|
* fu.should.be.instanceof(Fu); // true
|
|
* fu.should.be.instanceof(Bar); // true
|
|
*
|
|
* @param {Object} properties/methods to add to new prototype
|
|
* @param {Object} properties/methods to add to new class
|
|
* @returns {Object} new constructor
|
|
* @name extend
|
|
* @api public
|
|
*/
|
|
|
|
exports.extend = function(proto, klass) {
|
|
var self = this
|
|
, child = function () { return self.apply(this, arguments); };
|
|
exports.merge([ child, this ]);
|
|
exports.inherits(child, this);
|
|
if (proto) exports.merge([ child.prototype, proto ]);
|
|
if (klass) exports.merge([ child, klass ]);
|
|
child.extend = this.extend; // prevent overwrite
|
|
return child;
|
|
};
|
|
|
|
/**
|
|
* ### inherits (ctor, superCtor)
|
|
*
|
|
* Inherit the prototype methods from on contructor
|
|
* to another.
|
|
*
|
|
* @param {Function} destination
|
|
* @param {Function} source
|
|
* @api private
|
|
*/
|
|
|
|
exports.inherits = function(ctor, superCtor) {
|
|
ctor.super_ = superCtor;
|
|
if (Object.create) {
|
|
ctor.prototype = Object.create(superCtor.prototype,
|
|
{ constructor: {
|
|
value: ctor
|
|
, enumerable: false
|
|
, writable: true
|
|
, configurable: true
|
|
}
|
|
});
|
|
} else {
|
|
ctor.prototype = new superCtor();
|
|
ctor.prototype.constructor = ctor;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Extends multiple objects.
|
|
*
|
|
* @param {Array} array of objects
|
|
* @api private
|
|
*/
|
|
|
|
exports.merge = function (arr) {
|
|
var main = arr.length === 2 ? arr.shift() : {};
|
|
var obj = null;
|
|
|
|
for (var i = 0, len = arr.length; i < len; i++) {
|
|
obj = arr[i];
|
|
for (var p in obj) {
|
|
if (!obj.hasOwnProperty(p)) continue;
|
|
main[p] = obj[p];
|
|
}
|
|
}
|
|
|
|
return main;
|
|
};
|
|
|
|
});
|
|
require.register("powerange/lib/powerange.js", function(exports, require, module){
|
|
/**
|
|
* Require classes.
|
|
*/
|
|
|
|
var Main = require('./main')
|
|
, Horizontal = require('./horizontal')
|
|
, Vertical = require('./vertical');
|
|
|
|
/**
|
|
* Set default values.
|
|
*
|
|
* @api public
|
|
*/
|
|
|
|
var defaults = {
|
|
callback: function() {}
|
|
, decimal: false
|
|
, disable: false
|
|
, disableOpacity: 0.5
|
|
, hideRange: false
|
|
, klass: ''
|
|
, min: 0
|
|
, max: 100
|
|
, start: null
|
|
, step: null
|
|
, vertical: false
|
|
};
|
|
|
|
/**
|
|
* Expose proper type of `Powerange`.
|
|
*/
|
|
|
|
module.exports = function(element, options) {
|
|
options = options || {};
|
|
|
|
for (var i in defaults) {
|
|
if (options[i] == null) {
|
|
options[i] = defaults[i];
|
|
}
|
|
}
|
|
|
|
if (options.vertical) {
|
|
return new Vertical(element, options);
|
|
} else {
|
|
return new Horizontal(element, options);
|
|
}
|
|
};
|
|
});
|
|
require.register("powerange/lib/main.js", function(exports, require, module){
|
|
/**
|
|
* External dependencies.
|
|
*
|
|
*/
|
|
|
|
var mouse = require('mouse')
|
|
, events = require('events')
|
|
, classes = require('classes')
|
|
, percentage = require('percentage-calc');
|
|
|
|
/**
|
|
* Expose `Powerange`.
|
|
*/
|
|
|
|
module.exports = Powerange;
|
|
|
|
/**
|
|
* Create Powerange object.
|
|
*
|
|
* @constructor
|
|
* @param {Object} element
|
|
* @param {Object} options
|
|
* @api public
|
|
*/
|
|
|
|
function Powerange(element, options) {
|
|
if (!(this instanceof Powerange)) return new Powerange(element, options);
|
|
|
|
this.element = element;
|
|
this.options = options || {};
|
|
this.slider = this.create('span', 'range-bar');
|
|
|
|
if (this.element !== null && this.element.type === 'text') this.init();
|
|
}
|
|
|
|
/**
|
|
* Bind events on handle element.
|
|
*
|
|
* @api private
|
|
*/
|
|
|
|
Powerange.prototype.bindEvents = function () {
|
|
this.handle = this.slider.querySelector('.range-handle');
|
|
this.touch = events(this.handle, this);
|
|
this.touch.bind('touchstart', 'onmousedown');
|
|
this.touch.bind('touchmove', 'onmousemove');
|
|
this.touch.bind('touchend', 'onmouseup');
|
|
this.mouse = mouse(this.handle, this);
|
|
this.mouse.bind();
|
|
};
|
|
|
|
/**
|
|
* Hide the target element.
|
|
*
|
|
* @api private
|
|
*/
|
|
|
|
Powerange.prototype.hide = function() {
|
|
this.element.style.display = 'none';
|
|
};
|
|
|
|
/**
|
|
* Append the target after the element.
|
|
*
|
|
* @api private
|
|
*/
|
|
|
|
Powerange.prototype.append = function() {
|
|
var slider = this.generate();
|
|
this.insertAfter(this.element, slider);
|
|
};
|
|
|
|
/**
|
|
* Generate the appropriate type of slider.
|
|
*
|
|
* @returns {Object} this.slider
|
|
* @api private
|
|
*/
|
|
|
|
Powerange.prototype.generate = function() {
|
|
var elems = {
|
|
'handle': {
|
|
'type': 'span'
|
|
, 'selector': 'range-handle'
|
|
}
|
|
, 'min': {
|
|
'type': 'span'
|
|
, 'selector': 'range-min'
|
|
}
|
|
, 'max': {
|
|
'type': 'span'
|
|
, 'selector': 'range-max'
|
|
}
|
|
, 'quantity': {
|
|
'type': 'span'
|
|
, 'selector': 'range-quantity'
|
|
}
|
|
};
|
|
|
|
for (var key in elems) {
|
|
if (elems.hasOwnProperty(key)) {
|
|
var temp = this.create(elems[key].type, elems[key].selector);
|
|
this.slider.appendChild(temp);
|
|
}
|
|
}
|
|
|
|
return this.slider;
|
|
};
|
|
|
|
/**
|
|
* Create HTML element.
|
|
*
|
|
* @param {String} type
|
|
* @param {String} name
|
|
* @returns {Object} elem
|
|
* @api private
|
|
*/
|
|
|
|
Powerange.prototype.create = function(type, name) {
|
|
var elem = document.createElement(type);
|
|
elem.className = name;
|
|
|
|
return elem;
|
|
};
|
|
|
|
/**
|
|
* Insert element after another element.
|
|
*
|
|
* @param {Object} reference
|
|
* @param {Object} target
|
|
* @api private
|
|
*/
|
|
|
|
Powerange.prototype.insertAfter = function(reference, target) {
|
|
reference.parentNode.insertBefore(target, reference.nextSibling);
|
|
};
|
|
|
|
/**
|
|
* Add an additional class for extra customization.
|
|
*
|
|
* @param {String} klass
|
|
* @api private
|
|
*/
|
|
|
|
Powerange.prototype.extraClass = function(klass) {
|
|
if (this.options.klass) classes(this.slider).add(klass);
|
|
};
|
|
|
|
/**
|
|
* Set min and max values.
|
|
*
|
|
* @param {Number} min
|
|
* @param {Number} max
|
|
* @api private
|
|
*/
|
|
|
|
Powerange.prototype.setRange = function(min, max) {
|
|
if (typeof min === 'number' && typeof max === 'number' && !this.options.hideRange) {
|
|
this.slider.querySelector('.range-min').innerHTML = min;
|
|
this.slider.querySelector('.range-max').innerHTML = max;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Set slider current value.
|
|
*
|
|
* @param {Number} offset
|
|
* @param {Number} size
|
|
* @api private
|
|
*/
|
|
|
|
Powerange.prototype.setValue = function (offset, size) {
|
|
var part = percentage.from(parseFloat(offset), size)
|
|
, value = percentage.of(part, this.options.max - this.options.min) + this.options.min
|
|
, changed = false;
|
|
|
|
value = (this.options.decimal) ? (Math.round(value * 100) / 100) : Math.round(value);
|
|
changed = (this.element.value != value) ? true : false;
|
|
|
|
this.element.value = value;
|
|
this.options.callback();
|
|
if (changed) this.changeEvent();
|
|
};
|
|
|
|
/**
|
|
* Set step.
|
|
*
|
|
* @param {Number} sliderSize
|
|
* @param {Number} handleSize
|
|
* @returns {Array} this.steps
|
|
* @api private
|
|
*/
|
|
|
|
Powerange.prototype.step = function(sliderSize, handleSize) {
|
|
var dimension = sliderSize - handleSize
|
|
, part = percentage.from(this.checkStep(this.options.step), this.options.max - this.options.min)
|
|
, interval = percentage.of(part, dimension)
|
|
, steps = [];
|
|
|
|
for (i = 0; i <= dimension; i += interval) {
|
|
steps.push(i);
|
|
}
|
|
|
|
this.steps = steps;
|
|
|
|
return this.steps;
|
|
};
|
|
|
|
/**
|
|
* Check values.
|
|
*
|
|
* @param {Number} start
|
|
* @api private
|
|
*/
|
|
|
|
Powerange.prototype.checkValues = function(start) {
|
|
if (start < this.options.min) this.options.start = this.options.min;
|
|
if (start > this.options.max) this.options.start = this.options.max;
|
|
if (this.options.min >= this.options.max) this.options.min = this.options.max;
|
|
};
|
|
|
|
/**
|
|
* Make sure `step` is positive.
|
|
*
|
|
* @param {Number} value
|
|
* @returns {Number} this.options.step
|
|
* @api private
|
|
*/
|
|
|
|
Powerange.prototype.checkStep = function(value) {
|
|
if (value < 0) value = Math.abs(value);
|
|
this.options.step = value;
|
|
return this.options.step;
|
|
};
|
|
|
|
/**
|
|
* Disable range slider.
|
|
*
|
|
* @api private
|
|
*/
|
|
|
|
Powerange.prototype.disable = function() {
|
|
if (this.options.min == this.options.max || this.options.min > this.options.max || this.options.disable) {
|
|
this.mouse.unbind();
|
|
this.touch.unbind();
|
|
this.slider.style.opacity = this.options.disableOpacity;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Make element unselectable.
|
|
*
|
|
* @param {Object} element
|
|
* @param {Boolean} set
|
|
* @api private
|
|
*/
|
|
|
|
Powerange.prototype.unselectable = function(element, set) {
|
|
if (!classes(this.slider).has('unselectable') && set === true) {
|
|
classes(this.slider).add('unselectable');
|
|
} else {
|
|
classes(this.slider).remove('unselectable');
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Handle the onchange event.
|
|
*
|
|
* @param {Boolean} state
|
|
* @api private
|
|
*/
|
|
|
|
Powerange.prototype.changeEvent = function(state) {
|
|
if (typeof Event === 'function' || !document.fireEvent) {
|
|
var event = document.createEvent('HTMLEvents');
|
|
event.initEvent('change', false, true);
|
|
this.element.dispatchEvent(event);
|
|
} else {
|
|
this.element.fireEvent('onchange');
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Initialize main class.
|
|
*
|
|
* @api private
|
|
*/
|
|
|
|
Powerange.prototype.init = function() {
|
|
this.hide();
|
|
this.append();
|
|
this.bindEvents();
|
|
this.extraClass(this.options.klass);
|
|
this.checkValues(this.options.start);
|
|
this.setRange(this.options.min, this.options.max);
|
|
this.disable();
|
|
};
|
|
});
|
|
require.register("powerange/lib/horizontal.js", function(exports, require, module){
|
|
/**
|
|
* External dependencies.
|
|
*
|
|
*/
|
|
|
|
var inherits = require('super')
|
|
, closest = require('closest-num')
|
|
, percentage = require('percentage-calc');
|
|
|
|
/**
|
|
* Require main class.
|
|
*/
|
|
|
|
var Powerange = require('./main');
|
|
|
|
/**
|
|
* Expose `Horizontal`.
|
|
*/
|
|
|
|
module.exports = Horizontal;
|
|
|
|
/**
|
|
* Create horizontal slider object.
|
|
*
|
|
* @api public
|
|
*/
|
|
|
|
function Horizontal() {
|
|
Powerange.apply(this, arguments);
|
|
if (this.options.step) this.step(this.slider.offsetWidth, this.handle.offsetWidth);
|
|
this.setStart(this.options.start);
|
|
}
|
|
|
|
/**
|
|
* Inherit the main class.
|
|
*/
|
|
|
|
inherits(Horizontal, Powerange);
|
|
|
|
/**
|
|
* Set horizontal slider position.
|
|
*
|
|
* @param {Number} start
|
|
* @api private
|
|
*/
|
|
|
|
Horizontal.prototype.setStart = function(start) {
|
|
var begin = (start === null) ? this.options.min : start
|
|
, part = percentage.from(begin - this.options.min, this.options.max - this.options.min) || 0
|
|
, offset = percentage.of(part, this.slider.offsetWidth - this.handle.offsetWidth)
|
|
, position = (this.options.step) ? closest.find(offset, this.steps) : offset;
|
|
|
|
this.setPosition(position);
|
|
this.setValue(this.handle.style.left, this.slider.offsetWidth - this.handle.offsetWidth);
|
|
};
|
|
|
|
/**
|
|
* Set horizontal slider current position.
|
|
*
|
|
* @param {Number} val
|
|
* @api private
|
|
*/
|
|
|
|
Horizontal.prototype.setPosition = function(val) {
|
|
this.handle.style.left = val + 'px';
|
|
this.slider.querySelector('.range-quantity').style.width = val + 'px';
|
|
};
|
|
|
|
/**
|
|
* On slider mouse down.
|
|
*
|
|
* @param {Object} e
|
|
* @api private
|
|
*/
|
|
|
|
Horizontal.prototype.onmousedown = function(e) {
|
|
if (e.touches) e = e.touches[0];
|
|
this.startX = e.clientX;
|
|
this.handleOffsetX = this.handle.offsetLeft;
|
|
this.restrictHandleX = this.slider.offsetWidth - this.handle.offsetWidth;
|
|
this.unselectable(this.slider, true);
|
|
};
|
|
|
|
/**
|
|
* On slider mouse move.
|
|
*
|
|
* @param {Object} e
|
|
* @api private
|
|
*/
|
|
|
|
Horizontal.prototype.onmousemove = function(e) {
|
|
e.preventDefault();
|
|
if (e.touches) e = e.touches[0];
|
|
|
|
var leftOffset = this.handleOffsetX + e.clientX - this.startX
|
|
, position = (this.steps) ? closest.find(leftOffset, this.steps) : leftOffset;
|
|
|
|
if (leftOffset <= 0) {
|
|
this.setPosition(0);
|
|
} else if (leftOffset >= this.restrictHandleX) {
|
|
this.setPosition(this.restrictHandleX);
|
|
} else {
|
|
this.setPosition(position);
|
|
}
|
|
|
|
this.setValue(this.handle.style.left, this.slider.offsetWidth - this.handle.offsetWidth);
|
|
};
|
|
|
|
/**
|
|
* On mouse up.
|
|
*
|
|
* @param {Object} e
|
|
* @api private
|
|
*/
|
|
|
|
Horizontal.prototype.onmouseup = function(e) {
|
|
this.unselectable(this.slider, false);
|
|
};
|
|
});
|
|
require.register("powerange/lib/vertical.js", function(exports, require, module){
|
|
/**
|
|
* External dependencies.
|
|
*
|
|
*/
|
|
|
|
var inherits = require('super')
|
|
, classes = require('classes')
|
|
, closest = require('closest-num')
|
|
, percentage = require('percentage-calc');
|
|
|
|
/**
|
|
* Require main class.
|
|
*/
|
|
|
|
var Powerange = require('./main');
|
|
|
|
/**
|
|
* Expose `Vertical`.
|
|
*/
|
|
|
|
module.exports = Vertical;
|
|
|
|
/**
|
|
* Create vertical slider object.
|
|
*
|
|
* @api public
|
|
*/
|
|
|
|
function Vertical() {
|
|
Powerange.apply(this, arguments);
|
|
classes(this.slider).add('vertical');
|
|
if (this.options.step) this.step(this.slider.offsetHeight, this.handle.offsetHeight);
|
|
this.setStart(this.options.start);
|
|
}
|
|
|
|
/**
|
|
* Inherit the main class.
|
|
*/
|
|
|
|
inherits(Vertical, Powerange);
|
|
|
|
/**
|
|
* Set vertical slider position.
|
|
*
|
|
* @param {Number} start
|
|
* @api private
|
|
*/
|
|
|
|
Vertical.prototype.setStart = function(start) {
|
|
var begin = (start === null) ? this.options.min : start
|
|
, part = percentage.from(begin - this.options.min, this.options.max - this.options.min) || 0
|
|
, offset = percentage.of(part, this.slider.offsetHeight - this.handle.offsetHeight)
|
|
, position = (this.options.step) ? closest.find(offset, this.steps) : offset;
|
|
|
|
this.setPosition(position);
|
|
this.setValue(this.handle.style.bottom, this.slider.offsetHeight - this.handle.offsetHeight);
|
|
};
|
|
|
|
/**
|
|
* Set vertical slider current position.
|
|
*
|
|
* @param {Number} val
|
|
* @api private
|
|
*/
|
|
|
|
Vertical.prototype.setPosition = function(val) {
|
|
this.handle.style.bottom = val + 'px';
|
|
this.slider.querySelector('.range-quantity').style.height = val + 'px';
|
|
};
|
|
|
|
/**
|
|
* On mouse down.
|
|
*
|
|
* @param {Object} e
|
|
* @api private
|
|
*/
|
|
|
|
Vertical.prototype.onmousedown = function(e) {
|
|
if (e.touches) e = e.touches[0];
|
|
this.startY = e.clientY;
|
|
this.handleOffsetY = this.slider.offsetHeight - this.handle.offsetHeight - this.handle.offsetTop;
|
|
this.restrictHandleY = this.slider.offsetHeight - this.handle.offsetHeight;
|
|
this.unselectable(this.slider, true);
|
|
};
|
|
|
|
/**
|
|
* On vertical slider mouse move.
|
|
*
|
|
* @param {Object} e
|
|
* @api private
|
|
*/
|
|
|
|
Vertical.prototype.onmousemove = function(e) {
|
|
e.preventDefault();
|
|
if (e.touches) e = e.touches[0];
|
|
|
|
var bottomOffset = this.handleOffsetY + this.startY - e.clientY
|
|
, position = (this.steps) ? closest.find(bottomOffset, this.steps) : bottomOffset;
|
|
|
|
if (bottomOffset <= 0) {
|
|
this.setPosition(0);
|
|
} else if (bottomOffset >= this.restrictHandleY) {
|
|
this.setPosition(this.restrictHandleY);
|
|
} else {
|
|
this.setPosition(position);
|
|
}
|
|
|
|
this.setValue(this.handle.style.bottom, this.slider.offsetHeight - this.handle.offsetHeight);
|
|
};
|
|
|
|
/**
|
|
* On mouse up.
|
|
*
|
|
* @param {Object} e
|
|
* @api private
|
|
*/
|
|
|
|
Vertical.prototype.onmouseup = function(e) {
|
|
this.unselectable(this.slider, false);
|
|
};
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
require.alias("component-events/index.js", "powerange/deps/events/index.js");
|
|
require.alias("component-events/index.js", "events/index.js");
|
|
require.alias("component-event/index.js", "component-events/deps/event/index.js");
|
|
|
|
require.alias("component-delegate/index.js", "component-events/deps/delegate/index.js");
|
|
require.alias("discore-closest/index.js", "component-delegate/deps/closest/index.js");
|
|
require.alias("discore-closest/index.js", "component-delegate/deps/closest/index.js");
|
|
require.alias("component-matches-selector/index.js", "discore-closest/deps/matches-selector/index.js");
|
|
require.alias("component-query/index.js", "component-matches-selector/deps/query/index.js");
|
|
|
|
require.alias("discore-closest/index.js", "discore-closest/index.js");
|
|
require.alias("component-event/index.js", "component-delegate/deps/event/index.js");
|
|
|
|
require.alias("component-classes/index.js", "powerange/deps/classes/index.js");
|
|
require.alias("component-classes/index.js", "classes/index.js");
|
|
require.alias("component-indexof/index.js", "component-classes/deps/indexof/index.js");
|
|
|
|
require.alias("ui-component-mouse/index.js", "powerange/deps/mouse/index.js");
|
|
require.alias("ui-component-mouse/index.js", "mouse/index.js");
|
|
require.alias("component-emitter/index.js", "ui-component-mouse/deps/emitter/index.js");
|
|
|
|
require.alias("component-event/index.js", "ui-component-mouse/deps/event/index.js");
|
|
|
|
require.alias("abpetkov-percentage-calc/percentage-calc.js", "powerange/deps/percentage-calc/percentage-calc.js");
|
|
require.alias("abpetkov-percentage-calc/percentage-calc.js", "powerange/deps/percentage-calc/index.js");
|
|
require.alias("abpetkov-percentage-calc/percentage-calc.js", "percentage-calc/index.js");
|
|
require.alias("abpetkov-percentage-calc/percentage-calc.js", "abpetkov-percentage-calc/index.js");
|
|
require.alias("abpetkov-closest-num/closest-num.js", "powerange/deps/closest-num/closest-num.js");
|
|
require.alias("abpetkov-closest-num/closest-num.js", "powerange/deps/closest-num/index.js");
|
|
require.alias("abpetkov-closest-num/closest-num.js", "closest-num/index.js");
|
|
require.alias("abpetkov-closest-num/closest-num.js", "abpetkov-closest-num/index.js");
|
|
require.alias("vesln-super/lib/super.js", "powerange/deps/super/lib/super.js");
|
|
require.alias("vesln-super/lib/super.js", "powerange/deps/super/index.js");
|
|
require.alias("vesln-super/lib/super.js", "super/index.js");
|
|
require.alias("vesln-super/lib/super.js", "vesln-super/index.js");
|
|
require.alias("powerange/lib/powerange.js", "powerange/index.js");if (typeof exports == "object") {
|
|
module.exports = require("powerange");
|
|
} else if (typeof define == "function" && define.amd) {
|
|
define([], function(){ return require("powerange"); });
|
|
} else {
|
|
this["Powerange"] = require("powerange");
|
|
}})();
|