/*
Copyright 2010, KISSY UI Library v1.1.6
MIT Licensed
build time: Dec 2 22:19
*/
/*
* @module kissy
* @author lifesinger@gmail.com
*/
(function(S, undef) {
var meta = {
/**
* Copies all the properties of s to r.
* @return {Object} the augmented object
*/
mix: function(r, s, ov, wl) {
if (!s || !r) return r;
if (ov === undef) ov = true;
var i, p, l;
if (wl && (l = wl.length)) {
for (i = 0; i < l; i++) {
p = wl[i];
if (p in s) {
if (ov || !(p in r)) {
r[p] = s[p];
}
}
}
} else {
for (p in s) {
if (ov || !(p in r)) {
r[p] = s[p];
}
}
}
return r;
}
},
host = this,
// If KISSY is already defined, the existing KISSY object will not
// be overwritten so that defined namespaces are preserved.
seed = host[S] || {},
guid = 0,
EMPTY = '';
if(!seed.mix) seed.mix = meta.mix;
S = host[S] = seed; // shortcut
S.mix(S, {
// The host of runtime environment.
__HOST: host,
// S.app() with these members.
__APP_MEMBERS: ['namespace'],
__APP_INIT_METHODS: ['__init'],
/**
* The version of the library.
* @type {String}
*/
version: '1.1.6',
/**
* Returns a new object containing all of the properties of
* all the supplied objects. The properties from later objects
* will overwrite those in earlier objects. Passing in a
* single object will create a shallow copy of it.
* @return {Object} the new merged object
*/
merge: function() {
var o = {}, i, l = arguments.length;
for (i = 0; i < l; ++i) {
S.mix(o, arguments[i]);
}
return o;
},
/**
* Applies prototype properties from the supplier to the receiver.
* @return {Object} the augmented object
*/
augment: function(/*r, s1, s2, ..., ov, wl*/) {
var args = arguments, len = args.length - 2,
r = args[0], ov = args[len], wl = args[len + 1],
i = 1;
if (!S.isArray(wl)) {
ov = wl;
wl = undef;
len++;
}
if (!S.isBoolean(ov)) {
ov = undef;
len++;
}
for (; i < len; i++) {
S.mix(r.prototype, args[i].prototype || args[i], ov, wl);
}
return r;
},
/**
* Utility to set up the prototype, constructor and superclass properties to
* support an inheritance strategy that can chain constructors and methods.
* Static members will not be inherited.
* @param r {Function} the object to modify
* @param s {Function} the object to inherit
* @param px {Object} prototype properties to add/override
* @param sx {Object} static properties to add/override
* @return r {Object}
*/
extend: function(r, s, px, sx) {
if (!s || !r) return r;
var OP = Object.prototype,
O = function (o) {
function F() {
}
F.prototype = o;
return new F();
},
sp = s.prototype,
rp = O(sp);
r.prototype = rp;
rp.constructor = r;
r.superclass = sp;
// assign constructor property
if (s !== Object && sp.constructor === OP.constructor) {
sp.constructor = s;
}
// add prototype overrides
if (px) {
S.mix(rp, px);
}
// add object overrides
if (sx) {
S.mix(r, sx);
}
return r;
},
/****************************************************************************************
* The KISSY System Framework *
****************************************************************************************/
/**
* Initializes KISSY
*/
__init: function() {
this.Config = this.Config || {};
this.Env = this.Env || {};
// NOTICE: '@DEBUG@' will replace with '' when compressing.
// So, if loading source file, debug is on by default.
// If loading min version, debug is turned off automatically.
this.Config.debug = '@DEBUG@';
},
/**
* Returns the namespace specified and creates it if it doesn't exist. Be careful
* when naming packages. Reserved words may work in some browsers and not others.
*
* S.namespace('KISSY.app'); // returns KISSY.app
* S.namespace('app.Shop'); // returns KISSY.app.Shop
* S.namespace('TB.app.Shop', true); // returns TB.app.Shop
*
* @return {Object} A reference to the last namespace object created
*/
namespace: function() {
var args = arguments, l = args.length,
o = null, i, j, p,
global = (args[l - 1] === true && l--);
for (i = 0; i < l; ++i) {
p = (EMPTY + args[i]).split('.');
o = global ? host : this;
for (j = (host[p[0]] === o) ? 1 : 0; j < p.length; ++j) {
o = o[p[j]] = o[p[j]] || { };
}
}
return o;
},
/**
* create app based on KISSY.
* @param name {String} the app name
* @param sx {Object} static properties to add/override
*
* S.app('TB');
* TB.namespace('app'); // returns TB.app
*
* @return {Object} A reference to the app global object
*/
app: function(name, sx) {
var isStr = S.isString(name),
O = isStr ? host[name] || {} : name,
i = 0,
len = S.__APP_INIT_METHODS.length;
S.mix(O, this, true, S.__APP_MEMBERS);
for(; i < len; ++i) S[S.__APP_INIT_METHODS[i]].call(O);
S.mix(O, S.isFunction(sx) ? sx() : sx);
isStr && (host[name] = O);
return O;
},
/**
* Prints debug info.
* @param msg {String} the message to log.
* @param cat {String} the log category for the message. Default
* categories are "info", "warn", "error", "time" etc.
* @param src {String} the source of the the message (opt)
*/
log: function(msg, cat, src) {
if (S.Config.debug) {
if (src) {
msg = src + ': ' + msg;
}
if (host['console'] !== undef && console.log) {
console[cat && console[cat] ? cat : 'log'](msg);
}
}
},
/**
* Throws error message.
*/
error: function(msg) {
if (S.Config.debug) {
throw msg;
}
},
/*
* Generate a global unique id.
* @param pre {String} optional guid prefix
* @return {String} the guid
*/
guid: function(pre) {
return (pre || EMPTY) + guid++;
}
});
S.__init();
})('KISSY');
/**
* @module lang
* @author lifesinger@gmail.com
*/
(function(S, undef) {
var host = S.__HOST,
indexOf = Array.prototype.indexOf,
lastIndexOf = Array.prototype.lastIndexOf,
filter = Array.prototype.filter,
trim = String.prototype.trim,
EMPTY = '',
RE_TRIM = /^\s+|\s+$/g,
// [[Class]] -> type pairs
class2type = {};
S.mix(S, {
/**
* Determine the internal JavaScript [[Class]] of an object.
*/
type: function(o) {
return o == null ?
String(o) :
class2type[Object.prototype.toString.call(o)] || 'object';
},
isNull: function(o) {
return o === null;
},
isUndefined: function(o) {
return o === undef;
},
/**
* Checks to see if an object is empty.
*/
isEmptyObject: function(o) {
for (var p in o) {
return false;
}
return true;
},
/**
* Removes the whitespace from the beginning and end of a string.
*/
trim: trim ?
function(str) {
return (str == undef) ? EMPTY : trim.call(str);
} :
function(str) {
return (str == undef) ? EMPTY : str.toString().replace(RE_TRIM, EMPTY);
},
/**
* Substitutes keywords in a string using an object/array.
* Removes undefined keywords and ignores escaped keywords.
*/
substitute: function(str, o, regexp) {
if (!S.isString(str) || !S.isPlainObject(o)) return str;
return str.replace(regexp || /\\?\{([^{}]+)\}/g, function(match, name) {
if (match.charAt(0) === '\\') return match.slice(1);
return (o[name] !== undef) ? o[name] : EMPTY;
});
},
/**
* Executes the supplied function on each item in the array.
* @param object {Object} the object to iterate
* @param fn {Function} the function to execute on each item. The function
* receives three arguments: the value, the index, the full array.
* @param context {Object} (opt)
*/
each: function(object, fn, context) {
var key, val, i = 0, length = object.length,
isObj = length === undef || S.type(object) === 'function';
context = context || host;
if (isObj) {
for (key in object) {
if (fn.call(context, object[key], key, object) === false) {
break;
}
}
} else {
for (val = object[0];
i < length && fn.call(context, val, i, object) !== false; val = object[++i]) {
}
}
return object;
},
/**
* Search for a specified value within an array.
*/
indexOf: indexOf ?
function(item, arr) {
return indexOf.call(arr, item);
} :
function(item, arr) {
for (var i = 0, len = arr.length; i < len; ++i) {
if (arr[i] === item) {
return i;
}
}
return -1;
},
/**
* Returns the index of the last item in the array
* that contains the specified value, -1 if the
* value isn't found.
*/
lastIndexOf: (lastIndexOf) ?
function(item, arr) {
return lastIndexOf.call(arr, item);
} :
function(item, arr) {
for (var i = arr.length - 1; i >= 0; i--) {
if (arr[i] === item) {
break;
}
}
return i;
},
/**
* Returns a copy of the array with the duplicate entries removed
* @param a {Array} the array to find the subset of uniques for
* @param override {Boolean}
* if override is true, S.unique([a, b, a]) => [b, a]
* if override is false, S.unique([a, b, a]) => [a, b]
* @return {Array} a copy of the array with duplicate entries removed
*/
unique: function(a, override) {
if (override) a.reverse();
var b = a.slice(), i = 0, n, item;
while (i < b.length) {
item = b[i];
while ((n = S.lastIndexOf(item, b)) !== i) {
b.splice(n, 1);
}
i += 1;
}
if (override) b.reverse();
return b;
},
/**
* Search for a specified value index within an array.
*/
inArray: function(item, arr) {
return S.indexOf(item, arr) > -1;
},
/**
* Executes the supplied function on each item in the array.
* Returns a new array containing the items that the supplied
* function returned true for.
* @param arr {Array} the array to iterate
* @param fn {Function} the function to execute on each item
* @param context {Object} optional context object
* @return {Array} The items on which the supplied function
* returned true. If no items matched an empty array is
* returned.
*/
filter: filter ?
function(arr, fn, context) {
return filter.call(arr, fn, context);
} :
function(arr, fn, context) {
var ret = [];
S.each(arr, function(item, i, arr) {
if (fn.call(context, item, i, arr)) {
ret.push(item);
}
});
return ret;
},
/**
* Gets current date in milliseconds.
*/
now: function() {
return new Date().getTime();
}
});
S.each('Boolean Number String Function Array Date RegExp Object'.split(' '),
function(name, lc) {
// populate the class2type map
class2type['[object ' + name + ']'] = (lc = name.toLowerCase());
// add isBoolean/isNumber/...
S['is' + name] = function(o) {
return S.type(o) == lc;
}
});
})(KISSY);
/**
* @module lang
* @author lifesinger@gmail.com
*/
(function(S, undef) {
var win = S.__HOST,
doc = win['document'],
docElem = doc.documentElement,
hasOwn = Object.prototype.hasOwnProperty,
EMPTY = '',
SEP = '&',
BRACKET = encodeURIComponent('[]'),
// Is the DOM ready to be used? Set to true once it occurs.
isReady = false,
// The functions to execute on DOM ready.
readyList = [],
// Has the ready events already been bound?
readyBound = false,
// The number of poll times.
POLL_RETRYS = 500,
// The poll interval in milliseconds.
POLL_INTERVAL = 40,
// #id or id
RE_IDSTR = /^#?([\w-]+)$/,
RE_ARR_KEY = /^(\w+)\[\]$/,
RE_NOT_WHITE = /\S/;
S.mix(S, {
/**
* A crude way of determining if an object is a window
*/
isWindow: function(o) {
return o && typeof o === 'object' && 'setInterval' in o;
},
/**
* Checks to see if an object is a plain object (created using "{}" or "new Object").
*/
isPlainObject: function(o) {
// Must be an Object.
// Because of IE, we also have to check the presence of the constructor property.
// Make sure that DOM nodes and window objects don't pass through, as well
if (!o || S.type(o) !== 'object' || o.nodeType || S.isWindow(o)) {
return false;
}
// Not own constructor property must be Object
if (o.constructor &&
!hasOwn.call(o, 'constructor') &&
!hasOwn.call(o.constructor.prototype, 'isPrototypeOf')) {
return false;
}
// Own properties are enumerated firstly, so to speed up,
// if last one is own, then all properties are own.
var key;
for (key in o) {
}
return key === undef || hasOwn.call(o, key);
},
/**
* Creates a deep copy of a plain object or array. Others are returned untouched.
*/
clone: function(o) {
var ret = o, b, k;
// array or plain object
if (o && ((b = S.isArray(o)) || S.isPlainObject(o))) {
ret = b ? [] : {};
for (k in o) {
if (o.hasOwnProperty(k)) {
ret[k] = S.clone(o[k]);
}
}
}
return ret;
},
/**
* Converts object to a true array.
*/
makeArray: function(o) {
if (o === null || o === undef) return [];
if (S.isArray(o)) return o;
// The strings and functions also have 'length'
if (typeof o.length !== 'number' || S.isString(o) || S.isFunction(o)) {
return [o];
}
return slice2Arr(o);
},
/**
* Parses a URI-like query string and returns an object composed of parameter/value pairs.
*
* 'section=blog&id=45' // -> {section: 'blog', id: '45'}
* 'section=blog&tag[]=js&tag[]=doc' // -> {section: 'blog', tag: ['js', 'doc']}
* 'tag=ruby%20on%20rails' // -> {tag: 'ruby on rails'}
* 'id=45&raw' // -> {id: '45', raw: ''}
*
*/
unparam: function(str, sep) {
if (typeof str !== 'string' || (str = S.trim(str)).length === 0) return {};
var ret = {},
pairs = str.split(sep || SEP),
pair, key, val, m,
i = 0, len = pairs.length;
for (; i < len; ++i) {
pair = pairs[i].split('=');
key = decodeURIComponent(pair[0]);
// decodeURIComponent will throw exception when pair[1] contains
// GBK encoded chinese characters.
try {
val = decodeURIComponent(pair[1] || EMPTY);
} catch (ex) {
val = pair[1] || EMPTY;
}
if ((m = key.match(RE_ARR_KEY)) && m[1]) {
ret[m[1]] = ret[m[1]] || [];
ret[m[1]].push(val);
} else {
ret[key] = val;
}
}
return ret;
},
/**
* Creates a serialized string of an array or object.
*
* {foo: 1, bar: 2} // -> 'foo=1&bar=2'
* {foo: 1, bar: [2, 3]} // -> 'foo=1&bar[]=2&bar[]=3'
* {foo: '', bar: 2} // -> 'foo=&bar=2'
* {foo: undefined, bar: 2} // -> 'foo=undefined&bar=2'
* {foo: true, bar: 2} // -> 'foo=true&bar=2'
*
*/
param: function(o, sep) {
if (!S.isPlainObject(o)) return EMPTY;
sep = sep || SEP;
var buf = [], key, val;
for (key in o) {
val = o[key];
key = encodeURIComponent(key);
// val is valid non-array value
if (isValidParamValue(val)) {
buf.push(key, '=', encodeURIComponent(val + EMPTY), sep);
}
// val is not empty array
else if (S.isArray(val) && val.length) {
for (var i = 0, len = val.length; i < len; ++i) {
if (isValidParamValue(val[i])) {
buf.push(key, BRACKET + '=', encodeURIComponent(val[i] + EMPTY), sep);
}
}
}
// ignore other cases, including empty array, Function, RegExp, Date etc.
}
buf.pop();
return buf.join(EMPTY);
},
/**
* Executes the supplied function in the context of the supplied
* object 'when' milliseconds later. Executes the function a
* single time unless periodic is set to true.
* @param fn {Function|String} the function to execute or the name of the method in
* the 'o' object to execute.
* @param when {Number} the number of milliseconds to wait until the fn is executed.
* @param periodic {Boolean} if true, executes continuously at supplied interval
* until canceled.
* @param o {Object} the context object.
* @param data [Array] that is provided to the function. This accepts either a single
* item or an array. If an array is provided, the function is executed with
* one parameter for each array item. If you need to pass a single array
* parameter, it needs to be wrapped in an array [myarray].
* @return {Object} a timer object. Call the cancel() method on this object to stop
* the timer.
*/
later: function(fn, when, periodic, o, data) {
when = when || 0;
o = o || { };
var m = fn, d = S.makeArray(data), f, r;
if (S.isString(fn)) {
m = o[fn];
}
if (!m) {
S.error('method undefined');
}
f = function() {
m.apply(o, d);
};
r = (periodic) ? setInterval(f, when) : setTimeout(f, when);
return {
id: r,
interval: periodic,
cancel: function() {
if (this.interval) {
clearInterval(r);
} else {
clearTimeout(r);
}
}
};
},
/**
* Evalulates a script in a global context.
*/
globalEval: function(data) {
if (data && RE_NOT_WHITE.test(data)) {
// Inspired by code by Andrea Giammarchi
// http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
var head = doc.getElementsByTagName('head')[0] || docElem,
script = doc.createElement('script');
// It works! All browsers support!
script.text = data;
// Use insertBefore instead of appendChild to circumvent an IE6 bug.
// This arises when a base node is used.
head.insertBefore(script, head.firstChild);
head.removeChild(script);
}
},
/**
* Specify a function to execute when the DOM is fully loaded.
* @param fn {Function} A function to execute after the DOM is ready
*
* KISSY.ready(function(S){ });
*
* @return {KISSY}
*/
ready: function(fn) {
// Attach the listeners
if (!readyBound) this._bindReady();
// If the DOM is already ready
if (isReady) {
// Execute the function immediately
fn.call(win, this);
} else {
// Remember the function for later
readyList.push(fn);
}
return this;
},
/**
* Binds ready events.
*/
_bindReady: function() {
var self = this,
doScroll = doc.documentElement.doScroll,
eventType = doScroll ? 'onreadystatechange' : 'DOMContentLoaded',
COMPLETE = 'complete',
fire = function() {
self._fireReady();
};
// Set to true once it runs
readyBound = true;
// Catch cases where ready() is called after the
// browser event has already occurred.
if (doc.readyState === COMPLETE) {
return fire();
}
// w3c mode
if (doc.addEventListener) {
function domReady() {
doc.removeEventListener(eventType, domReady, false);
fire();
}
doc.addEventListener(eventType, domReady, false);
// A fallback to window.onload, that will always work
win.addEventListener('load', fire, false);
}
// IE event model is used
else {
function stateChange() {
if (doc.readyState === COMPLETE) {
doc.detachEvent(eventType, stateChange);
fire();
}
}
// ensure firing before onload, maybe late but safe also for iframes
doc.attachEvent(eventType, stateChange);
// A fallback to window.onload, that will always work.
win.attachEvent('onload', fire);
// If IE and not a frame
// continually check to see if the document is ready
var notframe = false;
try {
notframe = win['frameElement'] == null;
} catch(e) {
}
if (doScroll && notframe) {
function readyScroll() {
try {
// Ref: http://javascript.nwbox.com/IEContentLoaded/
doScroll('left');
fire();
} catch(ex) {
setTimeout(readyScroll, 1);
}
}
readyScroll();
}
}
},
/**
* Executes functions bound to ready event.
*/
_fireReady: function() {
if (isReady) return;
// Remember that the DOM is ready
isReady = true;
// If there are functions bound, to execute
if (readyList) {
// Execute all of them
var fn, i = 0;
while (fn = readyList[i++]) {
fn.call(win, this);
}
// Reset the list of functions
readyList = null;
}
},
/**
* Executes the supplied callback when the item with the supplied id is found.
* @param id The id of the element, or an array of ids to look for.
* @param fn What to execute when the element is found.
*/
available: function(id, fn) {
id = (id + EMPTY).match(RE_IDSTR)[1];
if (!id || !S.isFunction(fn)) return;
var retryCount = 1,
timer = S.later(function() {
if (doc.getElementById(id) && (fn() || 1) || ++retryCount > POLL_RETRYS) {
timer.cancel();
}
}, POLL_INTERVAL, true);
}
});
function isValidParamValue(val) {
var t = typeof val;
// If the type of val is null, undefined, number, string, boolean, return true.
return val === null || (t !== 'object' && t !== 'function');
}
// Converts array-like collection such as LiveNodeList to normal array.
function slice2Arr(arr) {
return Array.prototype.slice.call(arr);
}
// IE will throw error.
try {
slice2Arr(docElem.childNodes);
}
catch(e) {
slice2Arr = function(arr) {
for (var ret = [], i = arr.length - 1; i >= 0; i--) {
ret[i] = arr[i];
}
return ret;
}
}
// If url contains '?ks-debug', debug mode will turn on automatically.
if (location && (location.search || EMPTY).indexOf('ks-debug') !== -1) {
S.Config.debug = true;
}
})(KISSY);
/**
* @module loader
* @author lifesinger@gmail.com, lijing00333@163.com
*/
(function(S, undef) {
var win = S.__HOST,
doc = win['document'],
head = doc.getElementsByTagName('head')[0] || doc.documentElement,
EMPTY = '', CSSFULLPATH = 'cssfullpath',
LOADING = 1, LOADED = 2, ERROR = 3, ATTACHED = 4,
mix = S.mix,
scriptOnload = doc.createElement('script').readyState ?
function(node, callback) {
var oldCallback = node.onreadystatechange;
node.onreadystatechange = function() {
var rs = node.readyState;
if (rs === 'loaded' || rs === 'complete') {
node.onreadystatechange = null;
oldCallback && oldCallback();
callback.call(this);
}
};
} :
function(node, callback) {
node.addEventListener('load', callback, false);
},
RE_CSS = /\.css(?:\?|$)/i,
loader;
loader = {
/**
* Registers a module.
* @param name {String} module name
* @param fn {Function} entry point into the module that is used to bind module to KISSY
* @param config {Object}
*
* KISSY.add('module-name', function(S){ }, requires: ['mod1']);
*
*
* KISSY.add({
* 'mod-name': {
* fullpath: 'url',
* requires: ['mod1','mod2'],
* attach: false // 默认为 true
* }
* });
*
* @return {KISSY}
*/
add: function(name, fn, config) {
var self = this, mods = self.Env.mods, mod, o;
// S.add(name, config) => S.add( { name: config } )
if (S.isString(name) && !config && S.isPlainObject(fn)) {
o = {};
o[name] = fn;
name = o;
}
// S.add( { name: config } )
if (S.isPlainObject(name)) {
S.each(name, function(v, k) {
v.name = k;
if (mods[k]) mix(v, mods[k], false); // 保留之前添加的配置
});
mix(mods, name);
}
// S.add(name[, fn[, config]])
else {
config = config || {};
mod = mods[name] || {};
name = config.host || mod.host || name;
mod = mods[name] || {};
// 注意：通过 S.add(name[, fn[, config]]) 注册的代码，无论是页面中的代码，还
// 是 js 文件里的代码，add 执行时，都意味着该模块已经 LOADED
mix(mod, { name: name, status: LOADED });
if (!mod.fns) mod.fns = [];
fn && mod.fns.push(fn);
mix((mods[name] = mod), config);
// 对于 requires 都已 attached 的模块，比如 core 中的模块，直接 attach
if ((mod['attach'] !== false) && self.__isAttached(mod.requires)) {
self.__attachMod(mod);
}
}
return self;
},
/**
* Start load specific mods, and fire callback when these mods and requires are attached.
*
* S.use('mod-name', callback, config);
* S.use('mod1,mod2', callback, config);
*
* config = {
* order: true, // 默认为 false. 是否严格按照 modNames 的排列顺序来回调入口函数
* global: KISSY // 默认为 KISSY. 当在 this.Env.mods 上找不到某个 mod 的属性时，会到 global.Env.mods 上去找
* }
*/
use: function(modNames, callback, config) {
modNames = modNames.replace(/\s+/g, EMPTY).split(',');
config = config || {};
var self = this, mods = self.Env.mods,
global = (config || 0).global,
i, len = modNames.length, mod, name, fired;
// 将 global 上的 mods, 移动到 instance 上
if (global) self.__mixMods(global);
// 已经全部 attached, 直接执行回调即可
if (self.__isAttached(modNames)) {
callback && callback(self);
return;
}
// 有尚未 attached 的模块
for (i = 0; i < len && (mod = mods[modNames[i]]); i++) {
if (mod.status === ATTACHED) continue;
// 通过添加依赖，来保证调用顺序
if (config.order && i > 0) {
if (!mod.requires) mod.requires = [];
mod._requires = mod.requires.concat(); // 保留，以便还原
name = modNames[i - 1];
if (!S.inArray(name, mod.requires)
&& !(S.inArray(mod.name, mods[name].requires || []))) { // 避免循环依赖
mod.requires.push(name);
}
}
self.__attach(mod, function() {
if (mod._requires) {
mod.requires = mod._requires; // restore requires
delete mod._requires;
}
if (!fired && self.__isAttached(modNames)) {
fired = true;
callback && callback(self);
}
}, global);
}
return self;
},
/**
* Attach a module and all required modules.
*/
__attach: function(mod, callback, global) {
var self = this, requires = mod['requires'] || [],
i = 0, len = requires.length;
// attach all required modules
for (; i < len; i++) {
self.__attach(self.Env.mods[requires[i]], fn, global);
}
// load and attach this module
self.__buildPath(mod);
self.__load(mod, fn, global);
function fn() {
if (self.__isAttached(requires)) {
if (mod.status === LOADED) {
self.__attachMod(mod);
}
if (mod.status === ATTACHED) {
callback();
}
}
}
},
__mixMods: function(global) {
var mods = this.Env.mods, gMods = global.Env.mods, name;
for (name in gMods) {
this.__mixMod(mods, gMods, name, global);
}
},
__mixMod: function(mods, gMods, name, global) {
var mod = mods[name] || {}, status = mod.status;
S.mix(mod, S.clone(gMods[name]));
// status 属于实例，当有值时，不能被覆盖。只有没有初始值时，才从 global 上继承
if (status) mod.status = status;
// 来自 global 的 mod, path 应该基于 global
if (global) this.__buildPath(mod, global.Config.base);
mods[name] = mod;
},
__attachMod: function(mod) {
var self = this;
if (mod.fns) {
S.each(mod.fns, function(fn) {
fn && fn(self);
});
mod.fns = undef; // 保证 attach 过的方法只执行一次
//S.log(mod.name + '.status = attached');
}
mod.status = ATTACHED;
},
__isAttached: function(modNames) {
var mods = this.Env.mods, mod,
i = (modNames = S.makeArray(modNames)).length - 1;
for (; i >= 0 && (mod = mods[modNames[i]]); i--) {
if (mod.status !== ATTACHED) return false;
}
return true;
},
/**
* Load a single module.
*/
__load: function(mod, callback, global) {
var self = this, url = mod['fullpath'],
loadQueque = S.Env._loadQueue, // 这个是全局的，防止多实例对同一模块的重复下载
node = loadQueque[url], ret;
mod.status = mod.status || 0;
// 可能已经由其它模块触发加载
if (mod.status < LOADING && node) {
mod.status = node.nodeName ? LOADING : LOADED;
}
// 加载 css, 仅发出请求，不做任何其它处理
if (S.isString(mod[CSSFULLPATH])) {
self.getScript(mod[CSSFULLPATH]);
mod[CSSFULLPATH] = LOADED;
}
if (mod.status < LOADING && url) {
mod.status = LOADING;
ret = self.getScript(url, {
success: function() {
KISSY.log(mod.name + ' is loaded.', 'info'); // 压缩时不过滤该句，以方便线上调试
_success();
},
error: function() {
mod.status = ERROR;
_final();
},
charset: mod.charset
});
// css 是同步的，在 success 回调里，已经将 loadQueque[url] 置成 LOADED
// 不需要再置成节点，否则有问题
if (!RE_CSS.test(url)) {
loadQueque[url] = ret;
}
}
// 已经在加载中，需要添加回调到 script onload 中
// 注意：没有考虑 error 情形
else if (mod.status === LOADING) {
scriptOnload(node, _success);
}
// 是内嵌代码，或者已经 loaded
else {
callback();
}
function _success() {
_final();
if (mod.status !== ERROR) {
// 对于动态下载下来的模块，loaded 后，global 上有可能更新 mods 信息，需要同步到 instance 上去
// 注意：要求 mod 对应的文件里，仅修改该 mod 信息
if (global) self.__mixMod(self.Env.mods, global.Env.mods, mod.name, global);
// 注意：当多个模块依赖同一个下载中的模块A下，模块A仅需 attach 一次
// 因此要加上下面的 !== 判断，否则会出现重复 attach, 比如编辑器里动态加载时，被依赖的模块会重复
if (mod.status !== ATTACHED) mod.status = LOADED;
callback();
}
}
function _final() {
loadQueque[url] = LOADED;
}
},
__buildPath: function(mod, base) {
var Config = this.Config;
build('path', 'fullpath');
if (mod[CSSFULLPATH] !== LOADED) build('csspath', CSSFULLPATH);
function build(path, fullpath) {
if (!mod[fullpath] && mod[path]) {
mod[fullpath] = (base || Config.base) + mod[path];
}
// debug 模式下，加载非 min 版
if (mod[fullpath] && Config.debug) {
mod[fullpath] = mod[fullpath].replace(/-min/g, '');
}
}
},
/**
* Load a JavaScript file from the server using a GET HTTP request, then execute it.
*
* getScript(url, success, charset);
* or
* getScript(url, {
* charset: string
* success: fn,
* error: fn,
* timeout: number
* });
*
*/
getScript: function(url, success, charset) {
var isCSS = RE_CSS.test(url),
node = doc.createElement(isCSS ? 'link' : 'script'),
config = success, error, timeout, timer;
if (S.isPlainObject(config)) {
success = config.success;
error = config.error;
timeout = config.timeout;
charset = config.charset;
}
if (isCSS) {
node.href = url;
node.rel = 'stylesheet';
} else {
node.src = url;
node.async = true;
}
if (charset) node.charset = charset;
if (isCSS) {
S.isFunction(success) && success.call(node);
} else {
scriptOnload(node, function() {
if (timer) {
timer.cancel();
timer = undef;
}
S.isFunction(success) && success.call(node);
// remove script
if (head && node.parentNode) {
head.removeChild(node);
}
});
}
if (S.isFunction(error)) {
timer = S.later(function() {
timer = undef;
error();
}, (timeout || this.Config.timeout) * 1000);
}
head.insertBefore(node, head.firstChild);
return node;
}
};
mix(S, loader);
/**
* Initializes loader.
*/
S.__initLoader = function() {
// get base from current script file path
var scripts = doc.getElementsByTagName('script'),
currentScript = scripts[scripts.length - 1],
base = currentScript.src.replace(/^(.*)(seed|kissy).*$/i, '$1');
this.Env.mods = {}; // all added mods
this.Env._loadQueue = {}; // information for loading and loaded mods
this.Config.base = base;
this.Config.timeout = 10; // the default timeout for getScript
};
S.__initLoader();
// for S.app working properly
S.each(loader, function(v, k) {
S.__APP_MEMBERS.push(k);
});
S.__APP_INIT_METHODS.push('__initLoader');
})(KISSY);
/**
* @module mods
* @author lifesinger@gmail.com
*/
(function(S) {
var map = {
core: {
path: 'packages/core-min.js',
charset: 'utf-8'
}
};
S.each([
'sizzle', 'dd', 'datalazyload', // pure utilities
'flash', // flash etc.
'switchable', 'suggest', 'calendar', // UI components based on Base
'uibase', 'overlay', 'imagezoom' // UI components based on UIBase
],
function(modName) {
map[modName] = {
path: modName + '/' + modName + '-pkg-min.js',
requires: ['core'],
charset: 'utf-8'
};
});
map['calendar'].csspath = 'calendar/default-min.css';
S.add(map);
})(KISSY);
/*
Copyright 2010, KISSY UI Library v1.1.6
MIT Licensed
build time: Dec 2 22:19
*/
/**
* @module ua
* @author lifesinger@gmail.com
*/
KISSY.add('ua', function(S) {
var ua = navigator.userAgent,
EMPTY = '', MOBILE = 'mobile',
core = EMPTY, shell = EMPTY, m,
o = {
// browser core type
//webkit: 0,
//trident: 0,
//gecko: 0,
//presto: 0,
// browser type
//chrome: 0,
//safari: 0,
//firefox: 0,
//ie: 0,
//opera: 0
//mobile: '',
//core: '',
//shell: ''
},
numberify = function(s) {
var c = 0;
// convert '1.2.3.4' to 1.234
return parseFloat(s.replace(/\./g, function() {
return (c++ === 0) ? '.' : '';
}));
};
// WebKit
if ((m = ua.match(/AppleWebKit\/([\d.]*)/)) && m[1]) {
o[core = 'webkit'] = numberify(m[1]);
// Chrome
if ((m = ua.match(/Chrome\/([\d.]*)/)) && m[1]) {
o[shell = 'chrome'] = numberify(m[1]);
}
// Safari
else if ((m = ua.match(/\/([\d.]*) Safari/)) && m[1]) {
o[shell = 'safari'] = numberify(m[1]);
}
// Apple Mobile
if (/ Mobile\//.test(ua)) {
o[MOBILE] = 'apple'; // iPad, iPhone or iPod Touch
}
// Other WebKit Mobile Browsers
else if ((m = ua.match(/NokiaN[^\/]*|Android \d\.\d|webOS\/\d\.\d/))) {
o[MOBILE] = m[0].toLowerCase(); // Nokia N-series, Android, webOS, ex: NokiaN95
}
}
// NOT WebKit
else {
// Presto
// ref: http://www.useragentstring.com/pages/useragentstring.php
if ((m = ua.match(/Presto\/([\d.]*)/)) && m[1]) {
o[core = 'presto'] = numberify(m[1]);
// Opera
if ((m = ua.match(/Opera\/([\d.]*)/)) && m[1]) {
o[shell = 'opera'] = numberify(m[1]); // Opera detected, look for revision
if ((m = ua.match(/Opera\/.* Version\/([\d.]*)/)) && m[1]) {
o[shell] = numberify(m[1]);
}
// Opera Mini
if ((m = ua.match(/Opera Mini[^;]*/)) && m) {
o[MOBILE] = m[0].toLowerCase(); // ex: Opera Mini/2.0.4509/1316
}
// Opera Mobile
// ex: Opera/9.80 (Windows NT 6.1; Opera Mobi/49; U; en) Presto/2.4.18 Version/10.00
// issue: 由于 Opera Mobile 有 Version/ 字段，可能会与 Opera 混淆，同时对于 Opera Mobile 的版本号也比较混乱
else if ((m = ua.match(/Opera Mobi[^;]*/)) && m){
o[MOBILE] = m[0];
}
}
// NOT WebKit or Presto
} else {
// MSIE
if ((m = ua.match(/MSIE\s([^;]*)/)) && m[1]) {
o[core = 'trident'] = 0.1; // Trident detected, look for revision
// 注意：
// o.shell = ie, 表示外壳是 ie
// 但 o.ie = 7, 并不代表外壳是 ie7, 还有可能是 ie8 的兼容模式
// 对于 ie8 的兼容模式，还要通过 documentMode 去判断。但此处不能让 o.ie = 8, 否则
// 很多脚本判断会失误。因为 ie8 的兼容模式表现行为和 ie7 相同，而不是和 ie8 相同
o[shell = 'ie'] = numberify(m[1]);
// Get the Trident's accurate version
if ((m = ua.match(/Trident\/([\d.]*)/)) && m[1]) {
o[core] = numberify(m[1]);
}
// NOT WebKit, Presto or IE
} else {
// Gecko
if ((m = ua.match(/Gecko/))) {
o[core = 'gecko'] = 0.1; // Gecko detected, look for revision
if ((m = ua.match(/rv:([\d.]*)/)) && m[1]) {
o[core] = numberify(m[1]);
}
// Firefox
if ((m = ua.match(/Firefox\/([\d.]*)/)) && m[1]) {
o[shell = 'firefox'] = numberify(m[1]);
}
}
}
}
}
o.core = core;
o.shell = shell;
o._numberify = numberify;
S.UA = o;
});
/**
* NOTES:
*
* 2010.03
* - jQuery, YUI 等类库都推荐用特性探测替代浏览器嗅探。特性探测的好处是能自动适应未来设备和未知设备，比如
* if(document.addEventListener) 假设 IE9 支持标准事件，则代码不用修改，就自适应了“未来浏览器”。
* 对于未知浏览器也是如此。但是，这并不意味着浏览器嗅探就得彻底抛弃。当代码很明确就是针对已知特定浏览器的，
* 同时并非是某个特性探测可以解决时，用浏览器嗅探反而能带来代码的简洁，同时也也不会有什么后患。总之，一切
* 皆权衡。
* - UA.ie && UA.ie < 8 并不意味着浏览器就不是 IE8, 有可能是 IE8 的兼容模式。进一步的判断需要使用 documentMode.
*
* TODO:
* - test mobile
*
*/
/**
* @module ua-extra
* @author gonghao
*/
KISSY.add('ua-extra', function(S) {
var UA = S.UA,
ua = navigator.userAgent,
m, external, shell,
o = { },
numberify = UA._numberify;
/**
* 说明：
* @子涯总结的各国产浏览器的判断依据: http://spreadsheets0.google.com/ccc?key=tluod2VGe60_ceDrAaMrfMw&hl=zh_CN#gid=0
* 根据 CNZZ 2009 年度浏览器占用率报告，优化了判断顺序：http://www.tanmi360.com/post/230.htm
* 如果检测出浏览器，但是具体版本号未知用 0.1 作为标识
* 世界之窗 & 360 浏览器，在 3.x 以下的版本都无法通过 UA 或者特性检测进行判断，所以目前只要检测到 UA 关键字就认为起版本号为 3
*/
// 360Browser
if (m = ua.match(/360SE/)) {
o[shell = 'se360'] = 3; // issue: 360Browser 2.x cannot be recognised, so if recognised default set verstion number to 3
}
// Maxthon
else if ((m = ua.match(/Maxthon/)) && (external = window.external)) {
// issue: Maxthon 3.x in IE-Core cannot be recognised and it doesn't have exact version number
// but other maxthon versions all have exact version number
shell = 'maxthon';
try {
o[shell] = numberify(external['max_version']);
} catch(ex) {
o[shell] = 0.1;
}
}
// TT
else if (m = ua.match(/TencentTraveler\s([\d.]*)/)) {
o[shell = 'tt'] = m[1] ? numberify(m[1]) : 0.1;
}
// TheWorld
else if (m = ua.match(/TheWorld/)) {
o[shell = 'theworld'] = 3; // issue: TheWorld 2.x cannot be recognised, so if recognised default set verstion number to 3
}
// Sougou
else if (m = ua.match(/SE\s([\d.]*)/)) {
o[shell = 'sougou'] = m[1] ? numberify(m[1]) : 0.1;
}
// If the browser has shell(no matter IE-core or Webkit-core or others), set the shell key
shell && (o.shell = shell);
S.mix(UA, o);
});
/*
Copyright 2010, KISSY UI Library v1.1.6
MIT Licensed
build time: Dec 2 22:18
*/
/**
* @module dom
* @author lifesinger@gmail.com
*/
KISSY.add('dom', function(S, undefined) {
S.DOM = {
/**
* 是不是 element node
*/
_isElementNode: function(elem) {
return nodeTypeIs(elem, 1);
},
/**
* 是不是 KISSY.Node
*/
_isKSNode: function(elem) {
return S.Node && nodeTypeIs(elem, S.Node.TYPE);
},
/**
* elem 为 window 时，直接返回
* elem 为 document 时，返回关联的 window
* elem 为 undefined 时，返回当前 window
* 其它值，返回 false
*/
_getWin: function(elem) {
return (elem && ('scrollTo' in elem) && elem['document']) ?
elem :
nodeTypeIs(elem, 9) ?
elem.defaultView || elem.parentWindow :
elem === undefined ?
window : false;
},
_nodeTypeIs: nodeTypeIs
};
function nodeTypeIs(node, val) {
return node && node.nodeType === val;
}
});
/**
* @module selector
* @author lifesinger@gmail.com
*/
KISSY.add('selector', function(S, undefined) {
var doc = document, DOM = S.DOM,
SPACE = ' ', ANY = '*',
GET_DOM_NODE = 'getDOMNode', GET_DOM_NODES = GET_DOM_NODE + 's',
REG_ID = /^#[\w-]+$/,
REG_QUERY = /^(?:#([\w-]+))?\s*([\w-]+|\*)?\.?([\w-]+)?$/;
/**
* Retrieves an Array of HTMLElement based on the given CSS selector.
* @param {string} selector
* @param {string|HTMLElement} context An #id string or a HTMLElement used as context
* @return {Array} The array of found HTMLElement
*/
function query(selector, context) {
var match, t, ret = [], id, tag, cls;
context = tuneContext(context);
// Ref: http://ejohn.org/blog/selectors-that-people-actually-use/
// 考虑 2/8 原则，仅支持以下选择器：
// #id
// tag
// .cls
// #id tag
// #id .cls
// tag.cls
// #id tag.cls
// 注 1：REG_QUERY 还会匹配 #id.cls
// 注 2：tag 可以为 * 字符
// 返回值为数组
// 选择器不支持时，抛出异常
// selector 为字符串是最常见的情况，优先考虑
// 注：空白字符串无需判断，运行下去自动能返回空数组
if (S.isString(selector)) {
selector = S.trim(selector);
// selector 为 #id 是最常见的情况，特殊优化处理
if (REG_ID.test(selector)) {
t = getElementById(selector.slice(1), context);
if (t) ret = [t]; // #id 无效时，返回空数组
}
// selector 为支持列表中的其它 6 种
else if ((match = REG_QUERY.exec(selector))) {
// 获取匹配出的信息
id = match[1];
tag = match[2];
cls = match[3];
if ((context = id ? getElementById(id, context) : context)) {
// #id .cls | #id tag.cls | .cls | tag.cls
if (cls) {
if (!id || selector.indexOf(SPACE) !== -1) { // 排除 #id.cls
ret = getElementsByClassName(cls, tag, context);
}
// 处理 #id.cls
else {
t = getElementById(id, context);
if(t && DOM.hasClass(t, cls)) {
ret = [t];
}
}
}
// #id tag | tag
else if (tag) { // 排除空白字符串
ret = getElementsByTagName(tag, context);
}
}
}
// 采用外部选择器
else if(S.ExternalSelector) {
return S.ExternalSelector(selector, context);
}
// 依旧不支持，抛异常
else {
error(selector);
}
}
// 传入的 selector 是 KISSY.Node/NodeList. 始终返回原生 DOM Node
else if(selector && (selector[GET_DOM_NODE] || selector[GET_DOM_NODES])) {
ret = selector[GET_DOM_NODE] ? [selector[GET_DOM_NODE]()] : selector[GET_DOM_NODES]();
}
// 传入的 selector 是 NodeList 或已是 Array
else if (selector && (S.isArray(selector) || isNodeList(selector))) {
ret = selector;
}
// 传入的 selector 是 Node 等非字符串对象，原样返回
else if (selector) {
ret = [selector];
}
// 传入的 selector 是其它值时，返回空数组
// 将 NodeList 转换为普通数组
if(isNodeList(ret)) {
ret = S.makeArray(ret);
}
// attach each method
ret.each = function(fn, context) {
return S.each(ret, fn, context);
};
return ret;
}
// Ref: http://lifesinger.github.com/lab/2010/nodelist.html
function isNodeList(o) {
// 注1：ie 下，有 window.item, typeof node.item 在 ie 不同版本下，返回值不同
// 注2：select 等元素也有 item, 要用 !node.nodeType 排除掉
// 注3：通过 namedItem 来判断不可靠
// 注4：getElementsByTagName 和 querySelectorAll 返回的集合不同
return o && !o.nodeType && o.item && (o != window);
}
// 调整 context 为合理值
function tuneContext(context) {
// 1). context 为 undefined 是最常见的情况，优先考虑
if (context === undefined) {
context = doc;
}
// 2). context 的第二使用场景是传入 #id
else if (S.isString(context) && REG_ID.test(context)) {
context = getElementById(context.slice(1), doc);
// 注：#id 可能无效，这时获取的 context 为 null
}
// 3). context 还可以传入 HTMLElement, 此时无需处理
// 4). 经历 1 - 3, 如果 context 还不是 HTMLElement, 赋值为 null
else if (context && context.nodeType !== 1 && context.nodeType !== 9) {
context = null;
}
return context;
}
// query #id
function getElementById(id, context) {
if(context.nodeType !== 9) {
context = context.ownerDocument;
}
return context.getElementById(id);
}
// query tag
function getElementsByTagName(tag, context) {
return context.getElementsByTagName(tag);
}
(function() {
// Check to see if the browser returns only elements
// when doing getElementsByTagName('*')
// Create a fake element
var div = doc.createElement('div');
div.appendChild(doc.createComment(''));
// Make sure no comments are found
if (div.getElementsByTagName(ANY).length > 0) {
getElementsByTagName = function(tag, context) {
var ret = context.getElementsByTagName(tag);
if (tag === ANY) {
var t = [], i = 0, j = 0, node;
while ((node = ret[i++])) {
// Filter out possible comments
if (node.nodeType === 1) {
t[j++] = node;
}
}
ret = t;
}
return ret;
};
}
})();
// query .cls
function getElementsByClassName(cls, tag, context) {
var els = context.getElementsByClassName(cls),
ret = els, i = 0, j = 0, len = els.length, el;
if (tag && tag !== ANY) {
ret = [];
tag = tag.toUpperCase();
for (; i < len; ++i) {
el = els[i];
if (el.tagName === tag) {
ret[j++] = el;
}
}
}
return ret;
}
if (!doc.getElementsByClassName) {
// 降级使用 querySelectorAll
if (doc.querySelectorAll) {
getElementsByClassName = function(cls, tag, context) {
return context.querySelectorAll((tag ? tag : '') + '.' + cls);
}
}
// 降级到普通方法
else {
getElementsByClassName = function(cls, tag, context) {
var els = context.getElementsByTagName(tag || ANY),
ret = [], i = 0, j = 0, len = els.length, el, t;
cls = SPACE + cls + SPACE;
for (; i < len; ++i) {
el = els[i];
t = el.className;
if (t && (SPACE + t + SPACE).indexOf(cls) > -1) {
ret[j++] = el;
}
}
return ret;
}
}
}
// throw exception
function error(msg) {
S.error('Unsupported selector: ' + msg);
}
// public api
S.query = query;
S.get = function(selector, context) {
return query(selector, context)[0] || null;
};
S.mix(DOM, {
query: query,
get: S.get,
/**
* Filters an array of elements to only include matches of a filter.
* @param filter selector or fn
*/
filter: function(selector, filter) {
var elems = query(selector), match, tag, cls, ret = [];
// 默认仅支持最简单的 tag.cls 形式
if (S.isString(filter) && (match = REG_QUERY.exec(filter)) && !match[1]) {
tag = match[2];
cls = match[3];
filter = function(elem) {
return !((tag && elem.tagName !== tag.toUpperCase()) || (cls && !DOM.hasClass(elem, cls)));
}
}
if (S.isFunction(filter)) {
ret = S.filter(elems, filter);
}
// 其它复杂 filter, 采用外部选择器
else if (filter && S.ExternalSelector) {
ret = S.ExternalSelector._filter(selector, filter + '');
}
// filter 为空或不支持的 selector
else {
error(filter);
}
return ret;
},
/**
* Returns true if the passed element(s) match the passed filter
*/
test: function(selector, filter) {
var elems = query(selector);
return elems.length && (DOM.filter(elems, filter).length === elems.length);
}
});
});
/**
* NOTES:
*
* 2010.01
* - 对 reg exec 的结果(id, tag, className)做 cache, 发现对性能影响很小，去掉。
* - getElementById 使用频率最高，使用直达通道优化。
* - getElementsByClassName 性能优于 querySelectorAll, 但 IE 系列不支持。
* - instanceof 对性能有影响。
* - 内部方法的参数，比如 cls, context 等的异常情况，已经在 query 方法中有保证，无需冗余“防卫”。
* - query 方法中的条件判断考虑了“频率优先”原则。最有可能出现的情况放在前面。
* - Array 的 push 方法可以用 j++ 来替代，性能有提升。
* - 返回值策略和 Sizzle 一致，正常时，返回数组；其它所有情况，返回空数组。
*
* - 从压缩角度考虑，还可以将 getElmentsByTagName 和 getElementsByClassName 定义为常量，
* 不过感觉这样做太“压缩控”，还是保留不替换的好。
*
* - 调整 getElementsByClassName 的降级写法，性能最差的放最后。
*
* 2010.02
* - 添加对分组选择器的支持（主要参考 Sizzle 的代码，代去除了对非 Grade A 级浏览器的支持）
*
* 2010.03
* - 基于原生 dom 的两个 api: S.query 返回数组; S.get 返回第一个。
* 基于 Node 的 api: S.one, 在 Node 中实现。
* 基于 NodeList 的 api: S.all, 在 NodeList 中实现。
* 通过 api 的分层，同时满足初级用户和高级用户的需求。
*
* 2010.05
* - 去掉给 S.query 返回值默认添加的 each 方法，保持纯净。
* - 对于不支持的 selector, 采用外部耦合进来的 Selector.
*
* 2010.06
* - 增加 filter 和 test 方法
*
* 2010.07
* - 取消对 , 分组的支持，group 直接用 Sizzle
*
* 2010.08
* - 给 S.query 的结果 attach each 方法
*
* Bugs:
* - S.query('#test-data *') 等带 * 号的选择器，在 IE6 下返回的值不对。jQuery 等类库也有此 bug, 诡异。
*
* References:
* - http://ejohn.org/blog/selectors-that-people-actually-use/
* - http://ejohn.org/blog/thoughts-on-queryselectorall/
* - MDC: querySelector, querySelectorAll, getElementsByClassName
* - Sizzle: http://github.com/jeresig/sizzle
* - MINI: http://james.padolsey.com/javascript/mini/
* - Peppy: http://jamesdonaghue.com/?p=40
* - Sly: http://github.com/digitarald/sly
* - XPath, TreeWalker：http://www.cnblogs.com/rubylouvre/archive/2009/07/24/1529640.html
*
* - http://www.quirksmode.org/blog/archives/2006/01/contains_for_mo.html
* - http://www.quirksmode.org/dom/getElementsByTagNames.html
* - http://ejohn.org/blog/comparing-document-position/
* - http://github.com/jeresig/sizzle/blob/master/sizzle.js
*/
/**
* @module dom-data
* @author lifesinger@gmail.com
*/
KISSY.add('dom-data', function(S, undefined) {
var win = window,
DOM = S.DOM,
expando = '_ks_data_' + S.now(), // 让每一份 kissy 的 expando 都不同
dataCache = { }, // 存储 node 节点的 data
winDataCache = { }, // 避免污染全局
// The following elements throw uncatchable exceptions if you
// attempt to add expando properties to them.
noData = {
EMBED: 1,
OBJECT: 1,
APPLET: 1
};
S.mix(DOM, {
/**
* Store arbitrary data associated with the matched elements.
*/
data: function(selector, name, data) {
// suports hash
if (S.isPlainObject(name)) {
for (var k in name) {
DOM.data(selector, k, name[k]);
}
return;
}
// getter
if (data === undefined) {
var elem = S.get(selector), isNode,
cache, key, thisCache;
if (!elem || noData[elem.nodeName]) return;
if (elem == win) elem = winDataCache;
isNode = checkIsNode(elem);
cache = isNode ? dataCache : elem;
key = isNode ? elem[expando] : expando;
thisCache = cache[key];
if(S.isString(name) && thisCache) {
return thisCache[name];
}
return thisCache;
}
// setter
else {
S.query(selector).each(function(elem) {
if (!elem || noData[elem.nodeName]) return;
if (elem == win) elem = winDataCache;
var cache = dataCache, key;
if (!checkIsNode(elem)) {
key = expando;
cache = elem;
}
else if (!(key = elem[expando])) {
key = elem[expando] = S.guid();
}
if (name && data !== undefined) {
if (!cache[key]) cache[key] = { };
cache[key][name] = data;
}
});
}
},
/**
* Remove a previously-stored piece of data.
*/
removeData: function(selector, name) {
S.query(selector).each(function(elem) {
if (!elem) return;
if (elem == win) elem = winDataCache;
var key, cache = dataCache, thisCache,
isNode = checkIsNode(elem);
if (!isNode) {
cache = elem;
key = expando;
} else {
key = elem[expando];
}
if (!key) return;
thisCache = cache[key];
// If we want to remove a specific section of the element's data
if (name) {
if (thisCache) {
delete thisCache[name];
// If we've removed all the data, remove the element's cache
if (S.isEmptyObject(thisCache)) {
DOM.removeData(elem);
}
}
}
// Otherwise, we want to remove all of the element's data
else {
if (!isNode) {
try {
delete elem[expando];
} catch(ex) {
}
} else if (elem.removeAttribute) {
elem.removeAttribute(expando);
}
// Completely remove the data cache
if (isNode) {
delete cache[key];
}
}
});
}
});
function checkIsNode(elem) {
return elem && elem.nodeType;
}
});
/**
* @module dom-class
* @author lifesinger@gmail.com
*/
KISSY.add('dom-class', function(S, undefined) {
var SPACE = ' ',
DOM = S.DOM,
REG_SPLIT = /[\.\s]\s*\.?/,
REG_CLASS = /[\n\t]/g;
S.mix(DOM, {
/**
* Determine whether any of the matched elements are assigned the given class.
*/
hasClass: function(selector, value) {
return batch(selector, value, function(elem, classNames, cl) {
var elemClass = elem.className;
if (elemClass) {
var className = SPACE + elemClass + SPACE, j = 0, ret = true;
for (; j < cl; j++) {
if (className.indexOf(SPACE + classNames[j] + SPACE) < 0) {
ret = false;
break;
}
}
if (ret) return true;
}
}, true);
},
/**
* Adds the specified class(es) to each of the set of matched elements.
*/
addClass: function(selector, value) {
batch(selector, value, function(elem, classNames, cl) {
var elemClass = elem.className;
if (!elemClass) {
elem.className = value;
}
else {
var className = SPACE + elemClass + SPACE, setClass = elemClass, j = 0;
for (; j < cl; j++) {
if (className.indexOf(SPACE + classNames[j] + SPACE) < 0) {
setClass += SPACE + classNames[j];
}
}
elem.className = S.trim(setClass);
}
});
},
/**
* Remove a single class, multiple classes, or all classes from each element in the set of matched elements.
*/
removeClass: function(selector, value) {
batch(selector, value, function(elem, classNames, cl) {
var elemClass = elem.className;
if (elemClass) {
if (!cl) {
elem.className = '';
}
else {
var className = (SPACE + elemClass + SPACE).replace(REG_CLASS, SPACE), j = 0, needle;
for (; j < cl; j++) {
needle = SPACE + classNames[j] + SPACE;
// 一个 cls 有可能多次出现：'link link2 link link3 link'
while (className.indexOf(needle) >= 0) {
className = className.replace(needle, SPACE);
}
}
elem.className = S.trim(className);
}
}
});
},
/**
* Replace a class with another class for matched elements.
* If no oldClassName is present, the newClassName is simply added.
*/
replaceClass: function(selector, oldClassName, newClassName) {
DOM.removeClass(selector, oldClassName);
DOM.addClass(selector, newClassName);
},
/**
* Add or remove one or more classes from each element in the set of
* matched elements, depending on either the class's presence or the
* value of the switch argument.
* @param state {Boolean} optional boolean to indicate whether class
* should be added or removed regardless of current state.
*/
toggleClass: function(selector, value, state) {
var isBool = S.isBoolean(state), has;
batch(selector, value, function(elem, classNames, cl) {
var j = 0, className;
for (; j < cl; j++) {
className = classNames[j];
has = isBool ? !state : DOM.hasClass(elem, className);
DOM[has ? 'removeClass' : 'addClass'](elem, className);
}
});
}
});
function batch(selector, value, fn, resultIsBool) {
if (!(value = S.trim(value))) return resultIsBool ? false : undefined;
var elems = S.query(selector),
i = 0, len = elems.length,
classNames = value.split(REG_SPLIT),
elem, ret;
for (; i < len; i++) {
elem = elems[i];
if (DOM._isElementNode(elem)) {
ret = fn(elem, classNames, classNames.length);
if (ret !== undefined) return ret;
}
}
if (resultIsBool) return false;
}
});
/**
* NOTES:
* - hasClass/addClass/removeClass 的逻辑和 jQuery 保持一致
* - toggleClass 不支持 value 为 undefined 的情形（jQuery 支持）
*/
/**
* @module dom-attr
* @author lifesinger@gmail.com
*/
KISSY.add('dom-attr', function(S, undefined) {
var UA = S.UA,
doc = document,
docElement = doc.documentElement,
oldIE = !docElement.hasAttribute,
TEXT = docElement.textContent !== undefined ? 'textContent' : 'innerText',
SELECT = 'select',
EMPTY = '',
CHECKED = 'checked',
STYLE = 'style',
DOM = S.DOM,
isElementNode = DOM._isElementNode,
isTextNode = function(elem) { return DOM._nodeTypeIs(elem, 3); },
RE_SPECIAL_ATTRS = /^(?:href|src|style)/,
RE_NORMALIZED_ATTRS = /^(?:href|src|colspan|rowspan)/,
RE_RETURN = /\r/g,
RE_RADIO_CHECK = /^(?:radio|checkbox)/,
CUSTOM_ATTRS = {
readonly: 'readOnly'
},
attrFn = {
val: 1,
css: 1,
html: 1,
text: 1,
data: 1,
width: 1,
height: 1,
offset: 1
};
if (oldIE) {
S.mix(CUSTOM_ATTRS, {
'for': 'htmlFor',
'class': 'className'
});
}
S.mix(DOM, {
/**
* Gets the value of an attribute for the first element in the set of matched elements or
* Sets an attribute for the set of matched elements.
*/
attr: function(selector, name, val, pass) {
// suports hash
if (S.isPlainObject(name)) {
pass = val; // 塌缩参数
for (var k in name) {
DOM.attr(selector, k, name[k], pass);
}
return;
}
if (!(name = S.trim(name))) return;
name = name.toLowerCase();
// attr functions
if (pass && attrFn[name]) {
return DOM[name](selector, val);
}
// custom attrs
name = CUSTOM_ATTRS[name] || name;
// getter
if (val === undefined) {
// supports css selector/Node/NodeList
var el = S.get(selector);
// only get attributes on element nodes
if (!isElementNode(el)) {
return undefined;
}
var ret;
// 优先用 el[name] 获取 mapping 属性值：
// - 可以正确获取 readonly, checked, selected 等特殊 mapping 属性值
// - 可以获取用 getAttribute 不一定能获取到的值，比如 tabindex 默认值
// - href, src 直接获取的是 normalized 后的值，排除掉
// - style 需要用 getAttribute 来获取字符串值，也排除掉
if (!RE_SPECIAL_ATTRS.test(name)) {
ret = el[name];
}
// 用 getAttribute 获取非 mapping 属性和 href/src/style 的值：
if (ret === undefined) {
ret = el.getAttribute(name);
}
// fix ie bugs
if (oldIE) {
// 不光是 href, src, 还有 rowspan 等非 mapping 属性，也需要用第 2 个参数来获取原始值
if (RE_NORMALIZED_ATTRS.test(name)) {
ret = el.getAttribute(name, 2);
}
// 在标准浏览器下，用 getAttribute 获取 style 值
// IE7- 下，需要用 cssText 来获取
else if (name === STYLE) {
ret = el[STYLE].cssText;
}
}
// 对于不存在的属性，统一返回 undefined
return ret === null ? undefined : ret;
}
// setter
S.each(S.query(selector), function(el) {
// only set attributes on element nodes
if (!isElementNode(el)) {
return;
}
// 不需要加 oldIE 判断，否则 IE8 的 IE7 兼容模式有问题
if (name === STYLE) {
el[STYLE].cssText = val;
}
else {
// checked 属性值，需要通过直接设置才能生效
if(name === CHECKED) {
el[name] = !!val;
}
// convert the value to a string (all browsers do this but IE)
el.setAttribute(name, EMPTY + val);
}
});
},
/**
* Removes the attribute of the matched elements.
*/
removeAttr: function(selector, name) {
S.each(S.query(selector), function(el) {
if (isElementNode(el)) {
DOM.attr(el, name, EMPTY); // 先置空
el.removeAttribute(name); // 再移除
}
});
},
/**
* Gets the current value of the first element in the set of matched or
* Sets the value of each element in the set of matched elements.
*/
val: function(selector, value) {
// getter
if (value === undefined) {
// supports css selector/Node/NodeList
var el = S.get(selector);
// only gets value on element nodes
if (!isElementNode(el)) {
return undefined;
}
// 当没有设定 value 时，标准浏览器 option.value === option.text
// ie7- 下，没有设定 value 时，option.value === '', 需要用 el.attributes.value 来判断是否有设定 value
if (nodeNameIs('option', el)) {
return (el.attributes.value || {}).specified ? el.value : el.text;
}
// 对于 select, 特别是 multiple type, 存在很严重的兼容性问题
if (nodeNameIs(SELECT, el)) {
var index = el.selectedIndex,
options = el.options;
if (index < 0) {
return null;
}
else if (el.type === 'select-one') {
return DOM.val(options[index]);
}
// Loop through all the selected options
var ret = [], i = 0, len = options.length;
for (; i < len; ++i) {
if (options[i].selected) {
ret.push(DOM.val(options[i]));
}
}
// Multi-Selects return an array
return ret;
}
// Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
if (UA.webkit && RE_RADIO_CHECK.test(el.type)) {
return el.getAttribute('value') === null ? 'on' : el.value;
}
// 普通元素的 value, 归一化掉 \r
return (el.value || EMPTY).replace(RE_RETURN, EMPTY);
}
// setter
S.each(S.query(selector), function(el) {
if (nodeNameIs(SELECT, el)) {
// 强制转换数值为字符串，以保证下面的 inArray 正常工作
if (S.isNumber(value)) {
value += EMPTY;
}
var vals = S.makeArray(value),
opts = el.options, opt;
for (i = 0,len = opts.length; i < len; ++i) {
opt = opts[i];
opt.selected = S.inArray(DOM.val(opt), vals);
}
if (!vals.length) {
el.selectedIndex = -1;
}
}
else if (isElementNode(el)) {
el.value = value;
}
});
},
/**
* Gets the text context of the first element in the set of matched elements or
* Sets the text content of the matched elements.
*/
text: function(selector, val) {
// getter
if (val === undefined) {
// supports css selector/Node/NodeList
var el = S.get(selector);
// only gets value on supported nodes
if (isElementNode(el)) {
return el[TEXT] || EMPTY;
}
else if (isTextNode(el)) {
return el.nodeValue;
}
}
// setter
else {
S.each(S.query(selector), function(el) {
if (isElementNode(el)) {
el[TEXT] = val;
}
else if (isTextNode(el)) {
el.nodeValue = val;
}
});
}
}
});
// 判断 el 的 nodeName 是否指定值
function nodeNameIs(val, el) {
return el && el.nodeName.toUpperCase() === val.toUpperCase();
}
});
/**
* NOTES:
*
* 2010.03
* - 在 jquery/support.js 中，special attrs 里还有 maxlength, cellspacing,
* rowspan, colspan, useap, frameboder, 但测试发现，在 Grade-A 级浏览器中
* 并无兼容性问题。
* - 当 colspan/rowspan 属性值设置有误时，ie7- 会自动纠正，和 href 一样，需要传递
* 第 2 个参数来解决。jQuery 未考虑，存在兼容性 bug.
* - jQuery 考虑了未显式设定 tabindex 时引发的兼容问题，kissy 里忽略（太不常用了）
* - jquery/attributes.js: Safari mis-reports the default selected
* property of an option 在 Safari 4 中已修复。
*
*/
/**
* @module dom
* @author lifesinger@gmail.com
*/
KISSY.add('dom-style', function(S, undefined) {
var DOM = S.DOM, UA = S.UA,
doc = document, docElem = doc.documentElement,
STYLE = 'style', FLOAT = 'float',
CSS_FLOAT = 'cssFloat', STYLE_FLOAT = 'styleFloat',
WIDTH = 'width', HEIGHT = 'height',
AUTO = 'auto',
DISPLAY = 'display', NONE = 'none',
PARSEINT = parseInt,
RE_LT = /^(?:left|top)/,
RE_NEED_UNIT = /^(?:width|height|top|left|right|bottom|margin|padding)/i,
RE_DASH = /-([a-z])/ig,
CAMELCASE_FN = function(all, letter) {
return letter.toUpperCase();
},
EMPTY = '',
DEFAULT_UNIT = 'px',
CUSTOM_STYLES = { },
defaultDisplay = { };
S.mix(DOM, {
_CUSTOM_STYLES: CUSTOM_STYLES,
_getComputedStyle: function(elem, name) {
var val = '', d = elem.ownerDocument;
if (elem[STYLE]) {
val = d.defaultView.getComputedStyle(elem, null)[name];
}
return val;
},
/**
* Gets or sets styles on the matches elements.
*/
css: function(selector, name, val) {
// suports hash
if (S.isPlainObject(name)) {
for (var k in name) {
DOM.css(selector, k, name[k]);
}
return;
}
if (name.indexOf('-') > 0) {
// webkit 认识 camel-case, 其它内核只认识 cameCase
name = name.replace(RE_DASH, CAMELCASE_FN);
}
name = CUSTOM_STYLES[name] || name;
// getter
if (val === undefined) {
// supports css selector/Node/NodeList
var elem = S.get(selector), ret = '';
if (elem && elem[STYLE]) {
ret = name.get ? name.get(elem) : elem[STYLE][name];
// 有 get 的直接用自定义函数的返回值
if (ret === '' && !name.get) {
ret = fixComputedStyle(elem, name, DOM._getComputedStyle(elem, name));
}
}
return ret === undefined ? '' : ret;
}
// setter
else {
// normalize unsetting
if (val === null || val === EMPTY) {
val = EMPTY;
}
// number values may need a unit
else if (!isNaN(new Number(val)) && RE_NEED_UNIT.test(name)) {
val += DEFAULT_UNIT;
}
// ignore negative width and height values
if ((name === WIDTH || name === HEIGHT) && parseFloat(val) < 0) {
return;
}
S.each(S.query(selector), function(elem) {
if (elem && elem[STYLE]) {
name.set ? name.set(elem, val) : (elem[STYLE][name] = val);
if (val === EMPTY) {
if (!elem[STYLE].cssText)
elem.removeAttribute(STYLE);
}
}
});
}
},
/**
* Get the current computed width for the first element in the set of matched elements or
* set the CSS width of each element in the set of matched elements.
*/
width: function(selector, value) {
// getter
if (value === undefined) {
return getWH(selector, WIDTH);
}
// setter
else {
DOM.css(selector, WIDTH, value);
}
},
/**
* Get the current computed height for the first element in the set of matched elements or
* set the CSS height of each element in the set of matched elements.
*/
height: function(selector, value) {
// getter
if (value === undefined) {
return getWH(selector, HEIGHT);
}
// setter
else {
DOM.css(selector, HEIGHT, value);
}
},
/**
* Show the matched elements.
*/
show: function(selector) {
S.query(selector).each(function(elem) {
if (!elem) return;
elem.style[DISPLAY] = DOM.data(elem, DISPLAY) || EMPTY;
// 可能元素还处于隐藏状态，比如 css 里设置了 display: none
if (DOM.css(elem, DISPLAY) === NONE) {
var tagName = elem.tagName,
old = defaultDisplay[tagName], tmp;
if (!old) {
tmp = doc.createElement(tagName);
doc.body.appendChild(tmp);
old = DOM.css(tmp, DISPLAY);
DOM.remove(tmp);
defaultDisplay[tagName] = old;
}
DOM.data(elem, DISPLAY, old);
elem.style[DISPLAY] = old;
}
});
},
/**
* Hide the matched elements.
*/
hide: function(selector) {
S.query(selector).each(function(elem) {
if (!elem) return;
var style = elem.style, old = style[DISPLAY];
if (old !== NONE) {
if (old) {
DOM.data(elem, DISPLAY, old);
}
style[DISPLAY] = NONE;
}
});
},
/**
* Display or hide the matched elements.
*/
toggle: function(selector) {
S.query(selector).each(function(elem) {
if (elem) {
if (elem.style[DISPLAY] === NONE) {
DOM.show(elem);
} else {
DOM.hide(elem);
}
}
});
},
/**
* Creates a stylesheet from a text blob of rules.
* These rules will be wrapped in a STYLE tag and appended to the HEAD of the document.
* @param {String} cssText The text containing the css rules
* @param {String} id An id to add to the stylesheet for later removal
*/
addStyleSheet: function(cssText, id) {
var elem;
if (id && (id = id.replace('#', EMPTY))) elem = S.get('#' + id);
if (elem) return; // 仅添加一次，不重复添加
elem = DOM.create('