mirror of
https://github.com/DzzXH/DzzOffice.git
synced 2026-04-11 13:45:13 +08:00
942 lines
29 KiB
JavaScript
942 lines
29 KiB
JavaScript
(function() {
|
|
function require(name) {
|
|
var module = require.modules[name];
|
|
if(!module) throw new Error('failed to require "' + name + '"');
|
|
if(!("exports" in module) && typeof module.definition === "function") {
|
|
module.client = module.component = true;
|
|
module.definition.call(this, module.exports = {}, module);
|
|
delete module.definition
|
|
}
|
|
return module.exports
|
|
}
|
|
require.loader = "component";
|
|
require.helper = {};
|
|
require.helper.semVerSort = function(a, b) {
|
|
var aArray = a.version.split(".");
|
|
var bArray = b.version.split(".");
|
|
for(var i = 0; i < aArray.length; ++i) {
|
|
var aInt = parseInt(aArray[i], 10);
|
|
var bInt = parseInt(bArray[i], 10);
|
|
if(aInt === bInt) {
|
|
var aLex = aArray[i].substr(("" + aInt).length);
|
|
var bLex = bArray[i].substr(("" + bInt).length);
|
|
if(aLex === "" && bLex !== "") return 1;
|
|
if(aLex !== "" && bLex === "") return -1;
|
|
if(aLex !== "" && bLex !== "") return aLex > bLex ? 1 : -1;
|
|
continue
|
|
} else if(aInt > bInt) {
|
|
return 1
|
|
} else {
|
|
return -1
|
|
}
|
|
}
|
|
return 0
|
|
};
|
|
require.latest = function(name, returnPath) {
|
|
function showError(name) {
|
|
throw new Error('failed to find latest module of "' + name + '"')
|
|
}
|
|
var versionRegexp = /(.*)~(.*)@v?(\d+\.\d+\.\d+[^\/]*)$/;
|
|
var remoteRegexp = /(.*)~(.*)/;
|
|
if(!remoteRegexp.test(name)) showError(name);
|
|
var moduleNames = Object.keys(require.modules);
|
|
var semVerCandidates = [];
|
|
var otherCandidates = [];
|
|
for(var i = 0; i < moduleNames.length; i++) {
|
|
var moduleName = moduleNames[i];
|
|
if(new RegExp(name + "@").test(moduleName)) {
|
|
var version = moduleName.substr(name.length + 1);
|
|
var semVerMatch = versionRegexp.exec(moduleName);
|
|
if(semVerMatch != null) {
|
|
semVerCandidates.push({
|
|
version: version,
|
|
name: moduleName
|
|
})
|
|
} else {
|
|
otherCandidates.push({
|
|
version: version,
|
|
name: moduleName
|
|
})
|
|
}
|
|
}
|
|
}
|
|
if(semVerCandidates.concat(otherCandidates).length === 0) {
|
|
showError(name)
|
|
}
|
|
if(semVerCandidates.length > 0) {
|
|
var module = semVerCandidates.sort(require.helper.semVerSort).pop().name;
|
|
if(returnPath === true) {
|
|
return module
|
|
}
|
|
return require(module)
|
|
}
|
|
var module = otherCandidates.sort(function(a, b) {
|
|
return a.name > b.name
|
|
})[0].name;
|
|
if(returnPath === true) {
|
|
return module
|
|
}
|
|
return require(module)
|
|
};
|
|
require.modules = {};
|
|
require.register = function(name, definition) {
|
|
require.modules[name] = {
|
|
definition: definition
|
|
}
|
|
};
|
|
require.define = function(name, exports) {
|
|
require.modules[name] = {
|
|
exports: exports
|
|
}
|
|
};
|
|
require.register("abpetkov~transitionize@0.0.3", function(exports, module) {
|
|
module.exports = Transitionize;
|
|
|
|
function Transitionize(element, props) {
|
|
if(!(this instanceof Transitionize)) return new Transitionize(element, props);
|
|
this.element = element;
|
|
this.props = props || {};
|
|
this.init()
|
|
}
|
|
Transitionize.prototype.isSafari = function() {
|
|
return /Safari/.test(navigator.userAgent) && /Apple Computer/.test(navigator.vendor)
|
|
};
|
|
Transitionize.prototype.init = function() {
|
|
var transitions = [];
|
|
for(var key in this.props) {
|
|
transitions.push(key + " " + this.props[key])
|
|
}
|
|
this.element.style.transition = transitions.join(", ");
|
|
if(this.isSafari()) this.element.style.webkitTransition = transitions.join(", ")
|
|
}
|
|
});
|
|
require.register("ftlabs~fastclick@v0.6.11", function(exports, module) {
|
|
function FastClick(layer) {
|
|
"use strict";
|
|
var oldOnClick, self = this;
|
|
this.trackingClick = false;
|
|
this.trackingClickStart = 0;
|
|
this.targetElement = null;
|
|
this.touchStartX = 0;
|
|
this.touchStartY = 0;
|
|
this.lastTouchIdentifier = 0;
|
|
this.touchBoundary = 10;
|
|
this.layer = layer;
|
|
if(!layer || !layer.nodeType) {
|
|
throw new TypeError("Layer must be a document node")
|
|
}
|
|
this.onClick = function() {
|
|
return FastClick.prototype.onClick.apply(self, arguments)
|
|
};
|
|
this.onMouse = function() {
|
|
return FastClick.prototype.onMouse.apply(self, arguments)
|
|
};
|
|
this.onTouchStart = function() {
|
|
return FastClick.prototype.onTouchStart.apply(self, arguments)
|
|
};
|
|
this.onTouchMove = function() {
|
|
return FastClick.prototype.onTouchMove.apply(self, arguments)
|
|
};
|
|
this.onTouchEnd = function() {
|
|
return FastClick.prototype.onTouchEnd.apply(self, arguments)
|
|
};
|
|
this.onTouchCancel = function() {
|
|
return FastClick.prototype.onTouchCancel.apply(self, arguments)
|
|
};
|
|
if(FastClick.notNeeded(layer)) {
|
|
return
|
|
}
|
|
if(this.deviceIsAndroid) {
|
|
layer.addEventListener("mouseover", this.onMouse, true);
|
|
layer.addEventListener("mousedown", this.onMouse, true);
|
|
layer.addEventListener("mouseup", this.onMouse, true)
|
|
}
|
|
layer.addEventListener("click", this.onClick, true);
|
|
layer.addEventListener("touchstart", this.onTouchStart, false);
|
|
layer.addEventListener("touchmove", this.onTouchMove, false);
|
|
layer.addEventListener("touchend", this.onTouchEnd, false);
|
|
layer.addEventListener("touchcancel", this.onTouchCancel, false);
|
|
if(!Event.prototype.stopImmediatePropagation) {
|
|
layer.removeEventListener = function(type, callback, capture) {
|
|
var rmv = Node.prototype.removeEventListener;
|
|
if(type === "click") {
|
|
rmv.call(layer, type, callback.hijacked || callback, capture)
|
|
} else {
|
|
rmv.call(layer, type, callback, capture)
|
|
}
|
|
};
|
|
layer.addEventListener = function(type, callback, capture) {
|
|
var adv = Node.prototype.addEventListener;
|
|
if(type === "click") {
|
|
adv.call(layer, type, callback.hijacked || (callback.hijacked = function(event) {
|
|
if(!event.propagationStopped) {
|
|
callback(event)
|
|
}
|
|
}), capture)
|
|
} else {
|
|
adv.call(layer, type, callback, capture)
|
|
}
|
|
}
|
|
}
|
|
if(typeof layer.onclick === "function") {
|
|
oldOnClick = layer.onclick;
|
|
layer.addEventListener("click", function(event) {
|
|
oldOnClick(event)
|
|
}, false);
|
|
layer.onclick = null
|
|
}
|
|
}
|
|
FastClick.prototype.deviceIsAndroid = navigator.userAgent.indexOf("Android") > 0;
|
|
FastClick.prototype.deviceIsIOS = /iP(ad|hone|od)/.test(navigator.userAgent);
|
|
FastClick.prototype.deviceIsIOS4 = FastClick.prototype.deviceIsIOS && /OS 4_\d(_\d)?/.test(navigator.userAgent);
|
|
FastClick.prototype.deviceIsIOSWithBadTarget = FastClick.prototype.deviceIsIOS && /OS ([6-9]|\d{2})_\d/.test(navigator.userAgent);
|
|
FastClick.prototype.needsClick = function(target) {
|
|
"use strict";
|
|
switch(target.nodeName.toLowerCase()) {
|
|
case "button":
|
|
case "select":
|
|
case "textarea":
|
|
if(target.disabled) {
|
|
return true
|
|
}
|
|
break;
|
|
case "input":
|
|
if(this.deviceIsIOS && target.type === "file" || target.disabled) {
|
|
return true
|
|
}
|
|
break;
|
|
case "label":
|
|
case "video":
|
|
return true
|
|
}
|
|
return /\bneedsclick\b/.test(target.className)
|
|
};
|
|
FastClick.prototype.needsFocus = function(target) {
|
|
"use strict";
|
|
switch(target.nodeName.toLowerCase()) {
|
|
case "textarea":
|
|
return true;
|
|
case "select":
|
|
return !this.deviceIsAndroid;
|
|
case "input":
|
|
switch(target.type) {
|
|
case "button":
|
|
case "checkbox":
|
|
case "file":
|
|
case "image":
|
|
case "radio":
|
|
case "submit":
|
|
return false
|
|
}
|
|
return !target.disabled && !target.readOnly;
|
|
default:
|
|
return /\bneedsfocus\b/.test(target.className)
|
|
}
|
|
};
|
|
FastClick.prototype.sendClick = function(targetElement, event) {
|
|
"use strict";
|
|
var clickEvent, touch;
|
|
if(document.activeElement && document.activeElement !== targetElement) {
|
|
document.activeElement.blur()
|
|
}
|
|
touch = event.changedTouches[0];
|
|
clickEvent = document.createEvent("MouseEvents");
|
|
clickEvent.initMouseEvent(this.determineEventType(targetElement), true, true, window, 1, touch.screenX, touch.screenY, touch.clientX, touch.clientY, false, false, false, false, 0, null);
|
|
clickEvent.forwardedTouchEvent = true;
|
|
targetElement.dispatchEvent(clickEvent)
|
|
};
|
|
FastClick.prototype.determineEventType = function(targetElement) {
|
|
"use strict";
|
|
if(this.deviceIsAndroid && targetElement.tagName.toLowerCase() === "select") {
|
|
return "mousedown"
|
|
}
|
|
return "click"
|
|
};
|
|
FastClick.prototype.focus = function(targetElement) {
|
|
"use strict";
|
|
var length;
|
|
if(this.deviceIsIOS && targetElement.setSelectionRange && targetElement.type.indexOf("date") !== 0 && targetElement.type !== "time") {
|
|
length = targetElement.value.length;
|
|
targetElement.setSelectionRange(length, length)
|
|
} else {
|
|
targetElement.focus()
|
|
}
|
|
};
|
|
FastClick.prototype.updateScrollParent = function(targetElement) {
|
|
"use strict";
|
|
var scrollParent, parentElement;
|
|
scrollParent = targetElement.fastClickScrollParent;
|
|
if(!scrollParent || !scrollParent.contains(targetElement)) {
|
|
parentElement = targetElement;
|
|
do {
|
|
if(parentElement.scrollHeight > parentElement.offsetHeight) {
|
|
scrollParent = parentElement;
|
|
targetElement.fastClickScrollParent = parentElement;
|
|
break
|
|
}
|
|
parentElement = parentElement.parentElement
|
|
} while (parentElement)
|
|
}
|
|
if(scrollParent) {
|
|
scrollParent.fastClickLastScrollTop = scrollParent.scrollTop
|
|
}
|
|
};
|
|
FastClick.prototype.getTargetElementFromEventTarget = function(eventTarget) {
|
|
"use strict";
|
|
if(eventTarget.nodeType === Node.TEXT_NODE) {
|
|
return eventTarget.parentNode
|
|
}
|
|
return eventTarget
|
|
};
|
|
FastClick.prototype.onTouchStart = function(event) {
|
|
"use strict";
|
|
var targetElement, touch, selection;
|
|
if(event.targetTouches.length > 1) {
|
|
return true
|
|
}
|
|
targetElement = this.getTargetElementFromEventTarget(event.target);
|
|
touch = event.targetTouches[0];
|
|
if(this.deviceIsIOS) {
|
|
selection = window.getSelection();
|
|
if(selection.rangeCount && !selection.isCollapsed) {
|
|
return true
|
|
}
|
|
if(!this.deviceIsIOS4) {
|
|
if(touch.identifier === this.lastTouchIdentifier) {
|
|
event.preventDefault();
|
|
return false
|
|
}
|
|
this.lastTouchIdentifier = touch.identifier;
|
|
this.updateScrollParent(targetElement)
|
|
}
|
|
}
|
|
this.trackingClick = true;
|
|
this.trackingClickStart = event.timeStamp;
|
|
this.targetElement = targetElement;
|
|
this.touchStartX = touch.pageX;
|
|
this.touchStartY = touch.pageY;
|
|
if(event.timeStamp - this.lastClickTime < 200) {
|
|
event.preventDefault()
|
|
}
|
|
return true
|
|
};
|
|
FastClick.prototype.touchHasMoved = function(event) {
|
|
"use strict";
|
|
var touch = event.changedTouches[0],
|
|
boundary = this.touchBoundary;
|
|
if(Math.abs(touch.pageX - this.touchStartX) > boundary || Math.abs(touch.pageY - this.touchStartY) > boundary) {
|
|
return true
|
|
}
|
|
return false
|
|
};
|
|
FastClick.prototype.onTouchMove = function(event) {
|
|
"use strict";
|
|
if(!this.trackingClick) {
|
|
return true
|
|
}
|
|
if(this.targetElement !== this.getTargetElementFromEventTarget(event.target) || this.touchHasMoved(event)) {
|
|
this.trackingClick = false;
|
|
this.targetElement = null
|
|
}
|
|
return true
|
|
};
|
|
FastClick.prototype.findControl = function(labelElement) {
|
|
"use strict";
|
|
if(labelElement.control !== undefined) {
|
|
return labelElement.control
|
|
}
|
|
if(labelElement.htmlFor) {
|
|
return document.getElementById(labelElement.htmlFor)
|
|
}
|
|
return labelElement.querySelector("button, input:not([type=hidden]), keygen, meter, output, progress, select, textarea")
|
|
};
|
|
FastClick.prototype.onTouchEnd = function(event) {
|
|
"use strict";
|
|
var forElement, trackingClickStart, targetTagName, scrollParent, touch, targetElement = this.targetElement;
|
|
if(!this.trackingClick) {
|
|
return true
|
|
}
|
|
if(event.timeStamp - this.lastClickTime < 200) {
|
|
this.cancelNextClick = true;
|
|
return true
|
|
}
|
|
this.cancelNextClick = false;
|
|
this.lastClickTime = event.timeStamp;
|
|
trackingClickStart = this.trackingClickStart;
|
|
this.trackingClick = false;
|
|
this.trackingClickStart = 0;
|
|
if(this.deviceIsIOSWithBadTarget) {
|
|
touch = event.changedTouches[0];
|
|
targetElement = document.elementFromPoint(touch.pageX - window.pageXOffset, touch.pageY - window.pageYOffset) || targetElement;
|
|
targetElement.fastClickScrollParent = this.targetElement.fastClickScrollParent
|
|
}
|
|
targetTagName = targetElement.tagName.toLowerCase();
|
|
if(targetTagName === "label") {
|
|
forElement = this.findControl(targetElement);
|
|
if(forElement) {
|
|
this.focus(targetElement);
|
|
if(this.deviceIsAndroid) {
|
|
return false
|
|
}
|
|
targetElement = forElement
|
|
}
|
|
} else if(this.needsFocus(targetElement)) {
|
|
if(event.timeStamp - trackingClickStart > 100 || this.deviceIsIOS && window.top !== window && targetTagName === "input") {
|
|
this.targetElement = null;
|
|
return false
|
|
}
|
|
this.focus(targetElement);
|
|
if(!this.deviceIsIOS4 || targetTagName !== "select") {
|
|
this.targetElement = null;
|
|
event.preventDefault()
|
|
}
|
|
return false
|
|
}
|
|
if(this.deviceIsIOS && !this.deviceIsIOS4) {
|
|
scrollParent = targetElement.fastClickScrollParent;
|
|
if(scrollParent && scrollParent.fastClickLastScrollTop !== scrollParent.scrollTop) {
|
|
return true
|
|
}
|
|
}
|
|
if(!this.needsClick(targetElement)) {
|
|
event.preventDefault();
|
|
this.sendClick(targetElement, event)
|
|
}
|
|
return false
|
|
};
|
|
FastClick.prototype.onTouchCancel = function() {
|
|
"use strict";
|
|
this.trackingClick = false;
|
|
this.targetElement = null
|
|
};
|
|
FastClick.prototype.onMouse = function(event) {
|
|
"use strict";
|
|
if(!this.targetElement) {
|
|
return true
|
|
}
|
|
if(event.forwardedTouchEvent) {
|
|
return true
|
|
}
|
|
if(!event.cancelable) {
|
|
return true
|
|
}
|
|
if(!this.needsClick(this.targetElement) || this.cancelNextClick) {
|
|
if(event.stopImmediatePropagation) {
|
|
event.stopImmediatePropagation()
|
|
} else {
|
|
event.propagationStopped = true
|
|
}
|
|
event.stopPropagation();
|
|
event.preventDefault();
|
|
return false
|
|
}
|
|
return true
|
|
};
|
|
FastClick.prototype.onClick = function(event) {
|
|
"use strict";
|
|
var permitted;
|
|
if(this.trackingClick) {
|
|
this.targetElement = null;
|
|
this.trackingClick = false;
|
|
return true
|
|
}
|
|
if(event.target.type === "submit" && event.detail === 0) {
|
|
return true
|
|
}
|
|
permitted = this.onMouse(event);
|
|
if(!permitted) {
|
|
this.targetElement = null
|
|
}
|
|
return permitted
|
|
};
|
|
FastClick.prototype.destroy = function() {
|
|
"use strict";
|
|
var layer = this.layer;
|
|
if(this.deviceIsAndroid) {
|
|
layer.removeEventListener("mouseover", this.onMouse, true);
|
|
layer.removeEventListener("mousedown", this.onMouse, true);
|
|
layer.removeEventListener("mouseup", this.onMouse, true)
|
|
}
|
|
layer.removeEventListener("click", this.onClick, true);
|
|
layer.removeEventListener("touchstart", this.onTouchStart, false);
|
|
layer.removeEventListener("touchmove", this.onTouchMove, false);
|
|
layer.removeEventListener("touchend", this.onTouchEnd, false);
|
|
layer.removeEventListener("touchcancel", this.onTouchCancel, false)
|
|
};
|
|
FastClick.notNeeded = function(layer) {
|
|
"use strict";
|
|
var metaViewport;
|
|
var chromeVersion;
|
|
if(typeof window.ontouchstart === "undefined") {
|
|
return true
|
|
}
|
|
chromeVersion = +(/Chrome\/([0-9]+)/.exec(navigator.userAgent) || [, 0])[1];
|
|
if(chromeVersion) {
|
|
if(FastClick.prototype.deviceIsAndroid) {
|
|
metaViewport = document.querySelector("meta[name=viewport]");
|
|
if(metaViewport) {
|
|
if(metaViewport.content.indexOf("user-scalable=no") !== -1) {
|
|
return true
|
|
}
|
|
if(chromeVersion > 31 && window.innerWidth <= window.screen.width) {
|
|
return true
|
|
}
|
|
}
|
|
} else {
|
|
return true
|
|
}
|
|
}
|
|
if(layer.style.msTouchAction === "none") {
|
|
return true
|
|
}
|
|
return false
|
|
};
|
|
FastClick.attach = function(layer) {
|
|
"use strict";
|
|
return new FastClick(layer)
|
|
};
|
|
if(typeof define !== "undefined" && define.amd) {
|
|
define(function() {
|
|
"use strict";
|
|
return FastClick
|
|
})
|
|
} else if(typeof module !== "undefined" && module.exports) {
|
|
module.exports = FastClick.attach;
|
|
module.exports.FastClick = FastClick
|
|
} else {
|
|
window.FastClick = FastClick
|
|
}
|
|
});
|
|
require.register("component~indexof@0.0.3", function(exports, 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@1.2.1", function(exports, module) {
|
|
var index = require("component~indexof@0.0.3");
|
|
var re = /\s+/;
|
|
var toString = Object.prototype.toString;
|
|
module.exports = function(el) {
|
|
return new ClassList(el)
|
|
};
|
|
|
|
function ClassList(el) {
|
|
if(!el) throw new Error("A DOM element reference is required");
|
|
this.el = el;
|
|
this.list = el.classList
|
|
}
|
|
ClassList.prototype.add = function(name) {
|
|
if(this.list) {
|
|
this.list.add(name);
|
|
return this
|
|
}
|
|
var arr = this.array();
|
|
var i = index(arr, name);
|
|
if(!~i) arr.push(name);
|
|
this.el.className = arr.join(" ");
|
|
return this
|
|
};
|
|
ClassList.prototype.remove = function(name) {
|
|
if("[object RegExp]" == toString.call(name)) {
|
|
return this.removeMatching(name)
|
|
}
|
|
if(this.list) {
|
|
this.list.remove(name);
|
|
return this
|
|
}
|
|
var arr = this.array();
|
|
var i = index(arr, name);
|
|
if(~i) arr.splice(i, 1);
|
|
this.el.className = arr.join(" ");
|
|
return this
|
|
};
|
|
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
|
|
};
|
|
ClassList.prototype.toggle = function(name, force) {
|
|
if(this.list) {
|
|
if("undefined" !== typeof force) {
|
|
if(force !== this.list.toggle(name, force)) {
|
|
this.list.toggle(name)
|
|
}
|
|
} else {
|
|
this.list.toggle(name)
|
|
}
|
|
return this
|
|
}
|
|
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
|
|
};
|
|
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
|
|
};
|
|
ClassList.prototype.has = ClassList.prototype.contains = function(name) {
|
|
return this.list ? this.list.contains(name) : !!~index(this.array(), name)
|
|
}
|
|
});
|
|
require.register("component~event@0.1.4", function(exports, module) {
|
|
var bind = window.addEventListener ? "addEventListener" : "attachEvent",
|
|
unbind = window.removeEventListener ? "removeEventListener" : "detachEvent",
|
|
prefix = bind !== "addEventListener" ? "on" : "";
|
|
exports.bind = function(el, type, fn, capture) {
|
|
el[bind](prefix + type, fn, capture || false);
|
|
return fn
|
|
};
|
|
exports.unbind = function(el, type, fn, capture) {
|
|
el[unbind](prefix + type, fn, capture || false);
|
|
return fn
|
|
}
|
|
});
|
|
require.register("component~query@0.0.3", function(exports, 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@0.1.5", function(exports, module) {
|
|
var query = require("component~query@0.0.3");
|
|
var proto = Element.prototype;
|
|
var vendor = proto.matches || proto.webkitMatchesSelector || proto.mozMatchesSelector || proto.msMatchesSelector || proto.oMatchesSelector;
|
|
module.exports = match;
|
|
|
|
function match(el, selector) {
|
|
if(!el || el.nodeType !== 1) return false;
|
|
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("component~closest@0.1.4", function(exports, module) {
|
|
var matches = require("component~matches-selector@0.1.5");
|
|
module.exports = function(element, selector, checkYoSelf, root) {
|
|
element = checkYoSelf ? {
|
|
parentNode: element
|
|
} : element;
|
|
root = root || document;
|
|
while((element = element.parentNode) && element !== document) {
|
|
if(matches(element, selector)) return element;
|
|
if(element === root) return
|
|
}
|
|
}
|
|
});
|
|
require.register("component~delegate@0.2.3", function(exports, module) {
|
|
var closest = require("component~closest@0.1.4"),
|
|
event = require("component~event@0.1.4");
|
|
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)
|
|
};
|
|
exports.unbind = function(el, type, fn, capture) {
|
|
event.unbind(el, type, fn, capture)
|
|
}
|
|
});
|
|
require.register("component~events@1.0.9", function(exports, module) {
|
|
var events = require("component~event@0.1.4");
|
|
var delegate = require("component~delegate@0.2.3");
|
|
module.exports = Events;
|
|
|
|
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 = {}
|
|
}
|
|
Events.prototype.sub = function(event, method, cb) {
|
|
this._events[event] = this._events[event] || {};
|
|
this._events[event][method] = cb
|
|
};
|
|
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);
|
|
|
|
function cb() {
|
|
var a = [].slice.call(arguments).concat(args);
|
|
obj[method].apply(obj, a)
|
|
}
|
|
if(e.selector) {
|
|
cb = delegate.bind(el, e.selector, name, cb)
|
|
} else {
|
|
events.bind(el, name, cb)
|
|
}
|
|
this.sub(name, method, cb);
|
|
return cb
|
|
};
|
|
Events.prototype.unbind = function(event, method) {
|
|
if(0 == arguments.length) return this.unbindAll();
|
|
if(1 == arguments.length) return this.unbindAllOf(event);
|
|
var bindings = this._events[event];
|
|
if(!bindings) return;
|
|
var cb = bindings[method];
|
|
if(!cb) return;
|
|
events.unbind(this.el, event, cb)
|
|
};
|
|
Events.prototype.unbindAll = function() {
|
|
for(var event in this._events) {
|
|
this.unbindAllOf(event)
|
|
}
|
|
};
|
|
Events.prototype.unbindAllOf = function(event) {
|
|
var bindings = this._events[event];
|
|
if(!bindings) return;
|
|
for(var method in bindings) {
|
|
this.unbind(event, method)
|
|
}
|
|
};
|
|
|
|
function parse(event) {
|
|
var parts = event.split(/ +/);
|
|
return {
|
|
name: parts.shift(),
|
|
selector: parts.join(" ")
|
|
}
|
|
}
|
|
});
|
|
require.register("switchery", function(exports, module) {
|
|
var transitionize = require("abpetkov~transitionize@0.0.3"),
|
|
fastclick = require("ftlabs~fastclick@v0.6.11"),
|
|
classes = require("component~classes@1.2.1"),
|
|
events = require("component~events@1.0.9");
|
|
module.exports = Switchery;
|
|
var defaults = {
|
|
color: "#398ff1",
|
|
secondaryColor: "#dfdfdf",
|
|
jackColor: "#fff",
|
|
jackSecondaryColor: null,
|
|
className: "switchery",
|
|
disabled: false,
|
|
disabledOpacity: .5,
|
|
speed: "0.4s",
|
|
size: "default"
|
|
};
|
|
|
|
function Switchery(element, options) {
|
|
if(!(this instanceof Switchery)) return new Switchery(element, options);
|
|
this.element = element;
|
|
this.options = options || {};
|
|
for(var i in defaults) {
|
|
if(this.options[i] == null) {
|
|
this.options[i] = defaults[i]
|
|
}
|
|
}
|
|
if(this.element != null && this.element.type == "checkbox") this.init();
|
|
if(this.isDisabled() === true) this.disable()
|
|
}
|
|
Switchery.prototype.hide = function() {
|
|
this.element.style.display = "none"
|
|
};
|
|
Switchery.prototype.show = function() {
|
|
var switcher = this.create();
|
|
this.insertAfter(this.element, switcher)
|
|
};
|
|
Switchery.prototype.create = function() {
|
|
this.switcher = document.createElement("span");
|
|
this.jack = document.createElement("small");
|
|
this.switcher.appendChild(this.jack);
|
|
this.switcher.className = this.options.className;
|
|
this.events = events(this.switcher, this);
|
|
return this.switcher
|
|
};
|
|
Switchery.prototype.insertAfter = function(reference, target) {
|
|
reference.parentNode.insertBefore(target, reference.nextSibling)
|
|
};
|
|
Switchery.prototype.setPosition = function(clicked) {
|
|
var checked = this.isChecked(),
|
|
switcher = this.switcher,
|
|
jack = this.jack;
|
|
if(clicked && checked) checked = false;
|
|
else if(clicked && !checked) checked = true;
|
|
if(checked === true) {
|
|
this.element.checked = true;
|
|
if(window.getComputedStyle) jack.style.left = parseInt(window.getComputedStyle(switcher).width) - parseInt(window.getComputedStyle(jack).width) + "px";
|
|
else jack.style.left = parseInt(switcher.currentStyle["width"]) - parseInt(jack.currentStyle["width"]) + "px";
|
|
if(this.options.color) this.colorize();
|
|
this.setSpeed()
|
|
} else {
|
|
jack.style.left = 0;
|
|
this.element.checked = false;
|
|
this.switcher.style.boxShadow = "inset 0 0 0 0 " + this.options.secondaryColor;
|
|
this.switcher.style.borderColor = this.options.secondaryColor;
|
|
this.switcher.style.backgroundColor = this.options.secondaryColor !== defaults.secondaryColor ? this.options.secondaryColor : "#fff";
|
|
this.jack.style.backgroundColor = this.options.jackSecondaryColor !== this.options.jackColor ? this.options.jackSecondaryColor : this.options.jackColor;
|
|
this.setSpeed()
|
|
}
|
|
};
|
|
Switchery.prototype.setSpeed = function() {
|
|
var switcherProp = {},
|
|
jackProp = {
|
|
"background-color": this.options.speed,
|
|
left: this.options.speed.replace(/[a-z]/, "") / 2 + "s"
|
|
};
|
|
if(this.isChecked()) {
|
|
switcherProp = {
|
|
border: this.options.speed,
|
|
"box-shadow": this.options.speed,
|
|
"background-color": this.options.speed.replace(/[a-z]/, "") * 3 + "s"
|
|
}
|
|
} else {
|
|
switcherProp = {
|
|
border: this.options.speed,
|
|
"box-shadow": this.options.speed
|
|
}
|
|
}
|
|
transitionize(this.switcher, switcherProp);
|
|
transitionize(this.jack, jackProp)
|
|
};
|
|
Switchery.prototype.setSize = function() {
|
|
var small = "switchery-small",
|
|
normal = "switchery-default",
|
|
large = "switchery-large";
|
|
switch(this.options.size) {
|
|
case "small":
|
|
classes(this.switcher).add(small);
|
|
break;
|
|
case "large":
|
|
classes(this.switcher).add(large);
|
|
break;
|
|
default:
|
|
classes(this.switcher).add(normal);
|
|
break
|
|
}
|
|
};
|
|
Switchery.prototype.colorize = function() {
|
|
var switcherHeight = this.switcher.offsetHeight / 2;
|
|
this.switcher.style.backgroundColor = this.options.color;
|
|
this.switcher.style.borderColor = this.options.color;
|
|
this.switcher.style.boxShadow = "inset 0 0 0 " + switcherHeight + "px " + this.options.color;
|
|
this.jack.style.backgroundColor = this.options.jackColor
|
|
};
|
|
Switchery.prototype.handleOnchange = function(state) {
|
|
if(document.dispatchEvent) {
|
|
var event = document.createEvent("HTMLEvents");
|
|
event.initEvent("change", true, true);
|
|
this.element.dispatchEvent(event)
|
|
} else {
|
|
this.element.fireEvent("onchange")
|
|
}
|
|
};
|
|
Switchery.prototype.handleChange = function() {
|
|
var self = this,
|
|
el = this.element;
|
|
if(el.addEventListener) {
|
|
el.addEventListener("change", function() {
|
|
self.setPosition()
|
|
})
|
|
} else {
|
|
el.attachEvent("onchange", function() {
|
|
self.setPosition()
|
|
})
|
|
}
|
|
};
|
|
Switchery.prototype.handleClick = function() {
|
|
var switcher = this.switcher;
|
|
fastclick(switcher);
|
|
this.events.bind("click", "bindClick")
|
|
};
|
|
Switchery.prototype.bindClick = function() {
|
|
var parent = this.element.parentNode.tagName.toLowerCase(),
|
|
labelParent = parent === "label" ? false : true;
|
|
this.setPosition(labelParent);
|
|
this.handleOnchange(this.element.checked)
|
|
};
|
|
Switchery.prototype.markAsSwitched = function() {
|
|
this.element.setAttribute("data-switchery", true)
|
|
};
|
|
Switchery.prototype.markedAsSwitched = function() {
|
|
return this.element.getAttribute("data-switchery")
|
|
};
|
|
Switchery.prototype.init = function() {
|
|
this.hide();
|
|
this.show();
|
|
this.setSize();
|
|
this.setPosition();
|
|
this.markAsSwitched();
|
|
this.handleChange();
|
|
this.handleClick()
|
|
};
|
|
Switchery.prototype.isChecked = function() {
|
|
return this.element.checked
|
|
};
|
|
Switchery.prototype.isDisabled = function() {
|
|
return this.options.disabled || this.element.disabled || this.element.readOnly
|
|
};
|
|
Switchery.prototype.destroy = function() {
|
|
this.events.unbind()
|
|
};
|
|
Switchery.prototype.enable = function() {
|
|
if(!this.options.disabled) return;
|
|
if(this.options.disabled) this.options.disabled = false;
|
|
if(this.element.disabled) this.element.disabled = false;
|
|
if(this.element.readOnly) this.element.readOnly = false;
|
|
this.switcher.style.opacity = 1;
|
|
this.events.bind("click", "bindClick")
|
|
};
|
|
Switchery.prototype.disable = function() {
|
|
if(this.options.disabled) return;
|
|
if(!this.options.disabled) this.options.disabled = true;
|
|
if(!this.element.disabled) this.element.disabled = true;
|
|
if(!this.element.readOnly) this.element.readOnly = true;
|
|
this.switcher.style.opacity = this.options.disabledOpacity;
|
|
this.destroy()
|
|
}
|
|
});
|
|
if(typeof exports == "object") {
|
|
module.exports = require("switchery")
|
|
} else if(typeof define == "function" && define.amd) {
|
|
define("Switchery", [], function() {
|
|
return require("switchery")
|
|
})
|
|
} else {
|
|
(this || window)["Switchery"] = require("switchery")
|
|
}
|
|
})(); |