it('does not ignore undefined value', function () {
var x = {
y: undefined
};
var z = util.mix({}, x);
expect(z.y).toBeUndefined();
expect('y' in z).toBe(true);
});
function enable(legend,item){
var o = legend.get("enablestyle"),
style = {
icon:{
"stroke":item.DEFAULT,
"fill":item.DEFAULT
},
text:{
"color":item.DEFAULT
}
};
if(Util.isFunction(o)){
style = Util.mix(style,o(this,this.index));
}else{
style = Util.mix(style,o)
}
var $icon = this.icon,
$text = this.des
$icon.attr(style.icon);
$text.css(style.text);
}
getter: function (v) {
var defaultChildCfg = null, i, c, self = this;
for (i = 0; i < v.length; i++) {
c = v[i];
if (!c.isControl) {
defaultChildCfg = defaultChildCfg || self.get('defaultChildCfg');
util.mix(c, defaultChildCfg, false);
v[i] = this.createComponent(c);
}
}
return v;
},
function drawTitle(chart, themeCls) {
if (!chart._cfg.title.isShow) return;
var paper = chart.htmlPaper,
cls = themeCls + "-title",
_cfg = chart._cfg,
ctn = chart.getInnerContainer(),
h = ctn.y * 0.6;
chart._title = paper.rect(ctn.x, 0, ctn.width, h).addClass(cls).css(Util.mix({
"line-height": h + "px"
}, _cfg.title.css)).html(_cfg.title.content);
}
Attribute.extend = function extend(px, sx) {
var SubClass, self = this;
sx = util.merge(sx); // px is shared among classes
// px is shared among classes
px = util.merge(px);
var hooks, sxHooks = sx.__hooks__;
if (hooks = self.__hooks__) {
sxHooks = sx.__hooks__ = sx.__hooks__ || {};
util.mix(sxHooks, hooks, false);
}
var name = sx.name || 'AttributeDerived';
if (px.hasOwnProperty('constructor')) {
SubClass = px.constructor;
} else {
// debug mode, give the right name for constructor
if ('@DEBUG@') {
/*jshint evil: true*/
SubClass = new Function('return function ' + util.camelCase(name) + '(){ ' + 'this.callSuper.apply(this, arguments);' + '}')();
} else {
SubClass = function () {
this.callSuper.apply(this, arguments);
};
}
}
px.constructor = SubClass;
SubClass.__hooks__ = sxHooks;
wrapProtoForSuper(px, SubClass);
var inheritedStatics, sxInheritedStatics = sx.inheritedStatics;
if (inheritedStatics = self.inheritedStatics) {
sxInheritedStatics = sx.inheritedStatics = sx.inheritedStatics || {};
util.mix(sxInheritedStatics, inheritedStatics, false);
}
util.extend(SubClass, self, px, sx);
if (sxInheritedStatics) {
util.mix(SubClass, sxInheritedStatics);
}
SubClass.extend = sx.extend || extend;
SubClass.addMembers = addMembers;
return SubClass;
};
function setInternal(self, name, value, opts, attrs) {
var path,
subVal,
prevVal,
pathNamePair = getPathNamePair(name),
fullName = name;
name = pathNamePair.name;
path = pathNamePair.path;
prevVal = self.get(name);
prepareDefaultSetFn(self, name);
if (path) {
subVal = getValueByPath(prevVal, path);
}
// if no change, just return
// pass equal check to fire change event
if (!opts.force) {
if (!path && prevVal === value) {
return undefined;
} else if (path && subVal === value) {
return undefined;
}
}
value = getValueBySubValue(prevVal, path, value);
var beforeEventObject = util.mix({
attrName: name,
subAttrName: fullName,
prevVal: prevVal,
newVal: value,
_opts: opts,
_attrs: attrs,
target: self
}, opts.data);
// check before event
if (opts.silent) {
if (FALSE === defaultSetFn.call(self, beforeEventObject)) {
return FALSE;
}
} else {
if (FALSE === self.fire(whenAttrChangeEventName('before', name), beforeEventObject)) {
return FALSE;
}
}
return self;
}
], function (S, require) {
var Target = require('./custom/target');
var util = require('util');
return {
Target: Target,
/**
* global event target
* @property {KISSY.Event.CustomEvent.Target} global
* @member KISSY.Event.CustomEvent
*/
global: util.mix({}, Target)
};
});
KISSY.add(function(S, require) {
_$jscoverage['/event.js'].functionData[0]++;
_$jscoverage['/event.js'].lineData[5]++;
var Event = S.Event = {};
_$jscoverage['/event.js'].lineData[6]++;
var util = require('util');
_$jscoverage['/event.js'].lineData[7]++;
util.mix(Event, require('event/dom'));
_$jscoverage['/event.js'].lineData[8]++;
Event.Target = require('event/custom').Target;
_$jscoverage['/event.js'].lineData[9]++;
return Event;
});
it("can bubble more than one level", function () {
var r1 = util.mix({}, EventTarget);
var r2 = util.mix({}, EventTarget);
var r3 = util.mix({}, EventTarget);
r2.addTarget(r1);
r3.addTarget(r2);
var ret = 0;
r1.on('click', function () {
ret = 1;
});
r3.fire('click');
expect(ret).to.be(1);
});
it('can bubble default', function () {
var a = util.mix({}, EventTarget),
c = util.mix({}, EventTarget),
b = util.mix({}, EventTarget);
a.id = 'a';
b.id = 'b';
c.id = 'c';
var ret = [];
a.addTarget(b);
b.addTarget(c);
c.on('click', function (e) {
ret.push(e.target.id);
ret.push(e.type);
ret.push(e.currentTarget.id);
});
a.fire('click');
expect(ret).to.eql(['a', 'click', 'c']);
});
var util = require('util'); /**
* Do not new by yourself.
*
* Custom event object.
* @private
* @class KISSY.Event.CustomEvent.Object
* @param {Object} data data which will be mixed into custom event instance
* @extends KISSY.Event.Object
*/
/**
* Do not new by yourself.
*
* Custom event object.
* @private
* @class KISSY.Event.CustomEvent.Object
* @param {Object} data data which will be mixed into custom event instance
* @extends KISSY.Event.Object
*/
function CustomEventObject(data) {
CustomEventObject.superclass.constructor.call(this);
util.mix(this, data); /**
* source target of current event
* @property target
* @type {KISSY.Event.CustomEvent.Target}
*/
/**
* current target which processes current event
* @property currentTarget
* @type {KISSY.Event.CustomEvent.Target}
*/
}
util.each(to, function (val, prop) {
if (!util.isPlainObject(val)) {
val = { value: val };
}
_propsData[prop] = util.mix({
// simulate css3
delay: defaultDelay,
//// timing-function
easing: config.easing,
frame: config.frame,
duration: defaultDuration
}, val);
});
it("works for any object", function () {
var r = 0;
var x = util.mix({
item: 1,
length: 10
}, EventTarget);
x.on("my", function () {
r = 1;
});
x.fire("my");
expect(r).to.be(1);
});
setter: function (m) {
if (m.isControl) {
m.setInternal('parent', this);
var align = {
node: this.$el,
points: ['bl', 'tl'],
overflow: {
adjustX: 1,
adjustY: 1
}
};
util.mix(m.get('align'), align, false);
}
}
init: function() {
var self = this;
self.__events = {};
var userConfig = self.userConfig = Util.mix({
scalable: false,
scrollbars: false
}, self.userConfig, undefined, undefined, true);
self.renderTo = document.getElementById(userConfig.renderTo.replace("#",""));
self.boundryCheckEnabled = true;
var clsPrefix = self.clsPrefix = userConfig.clsPrefix || "xs-";
self.SROLL_ACCELERATION = userConfig.SROLL_ACCELERATION || SROLL_ACCELERATION;
self.containerClsName = clsPrefix + "container";
self.contentClsName = clsPrefix + "content";
},
_onSetValue: function (value) {
var self = this;
var currentYear = value.getYear();
var startYear = parseInt(currentYear / 10, 10) * 10;
var endYear = startYear + 9;
util.mix(self.renderData, {
startYear: startYear,
endYear: endYear,
years: prepareYears(self),
year: value.getYear()
});
self.get('tbodyEl').html(this.renderTpl(YearsTpl));
self.get('decadeSelectContentEl').html(startYear + '-' + endYear);
}
barChange: function(barGroup, barIndex) {
var self = this,
currentBars = self._bars[barGroup],
e = Util.mix({
target: currentBars['bars'][barIndex],
currentTarget: currentBars['bars'][barIndex],
barGroup: Math.round(barGroup),
barIndex: Math.round(barIndex)
}, self._points[barGroup][barIndex]);
self.curBarIndex = barIndex;
self.curGroupIndex = barGroup;
self.fire("barChange", e);
},
pluginRenderUI: function (editor) {
cmd.init(editor);
function wrapFont(vs) {
var v = [];
util.each(vs, function (n) {
v.push({
content: n,
value: n
});
});
return v;
}
var fontSizeConfig = this.config;
fontSizeConfig.menu = util.mix({
children: wrapFont([
'8px',
'10px',
'12px',
'14px',
'18px',
'24px',
'36px',
'48px',
'60px',
'72px',
'84px',
'96px'
])
}, fontSizeConfig.menu);
editor.addSelect('fontSize', util.mix({
cmdType: 'fontSize',
defaultCaption: '\u5927\u5C0F',
width: '70px',
mode: Editor.Mode.WYSIWYG_MODE
}, fontSizeConfig), ui.Select);
}
addAttr: function (name, attrConfig, override) {
var self = this, attrs = self.getAttrs(), attr,
// shadow clone
cfg = util.merge(attrConfig);
if (cfg.value && typeof cfg.value === 'object') {
cfg.value = util.clone(cfg.value);
LoggerManger.log('please use valueFn instead of value for ' + name + ' attribute', 'warn');
}
if (attr = attrs[name]) {
util.mix(attr, cfg, override);
} else {
attrs[name] = cfg;
}
return self;
},
it('can get defaultFn value as final value', function () {
var o = util.mix({}, EventTarget);
o.publish('t', {
defaultFn: function () {
return 'x';
}
});
o.on('t', function () {
return 'y';
});
expect(o.fire('t')).to.be('x');
});
function setUpConfig(c) {
// deep mix,exclude context!
var context = c.context;
delete c.context;
c = util.mix(util.clone(defaultConfig), c, {
deep: true
});
c.context = context || c;
var data, uri,
type = c.type,
dataType = c.dataType;
uri = c.uri = simulatedLocation.resolve(c.url);
// see method _getUrlForSend
c.uri.setQuery('');
if (!('crossDomain' in c)) {
c.crossDomain = !c.uri.isSameOriginAs(simulatedLocation);
}
type = c.type = type.toUpperCase();
c.hasContent = !rnoContent.test(type);
if (c.processData && (data = c.data) && typeof data !== 'string') {
// normalize to string
c.data = util.param(data, undefined, undefined, c.serializeArray);
}
// 数据类型处理链，一步步将前面的数据类型转化成最后一个
dataType = c.dataType = util.trim(dataType || '*').split(rspace);
if (!('cache' in c) && util.inArray(dataType[0], ['script', 'jsonp'])) {
c.cache = false;
}
if (!c.hasContent) {
if (c.data) {
uri.query.add(util.unparam(c.data));
}
if (c.cache === false) {
uri.query.set('_ksTS', (util.now() + '_' + util.guid()));
}
}
return c;
}
it('support simple defaultFn', function () {
var ret = [],
t = util.mix({}, EventTarget);
t.publish('click', {
defaultFn: function (e) {
ret.push(e.dataX);
}
});
t.fire('click', {
dataX: 1
});
expect(ret).to.eql([1]);
});
it('can fire EventObject instance', function () {
var event = new CustomEventObject({
type: 'xx'
});
var node = util.mix({}, EventTarget);
var fired = 0;
node.on('xx', function (e) {
fired = 1;
expect(e.target).to.be(node);
e.preventDefault();
expect(e).to.be(event);
});
node.fire(event);
expect(fired).to.be(1);
expect(event.isDefaultPrevented()).to.be(true);
});
function processTarget(self, show) {
if (self.__effectGhost) {
self.__effectGhost.stop(1, 1);
}
var el = self.$el, $ = require('node'), effectCfg = self.get('effect'), target = $(effectCfg.target), duration = effectCfg.duration, targetBox = {
width: target.width(),
height: target.height()
}, targetOffset = target.offset(), elBox = {
width: el.width(),
height: el.height()
}, elOffset = el.offset(), from, to, fromOffset, toOffset, ghost = getGhost(self), easing = effectCfg.easing;
ghost.insertAfter(el);
if (show) {
from = targetBox;
fromOffset = targetOffset;
to = elBox;
toOffset = elOffset;
} else {
from = elBox;
fromOffset = elOffset;
to = targetBox;
toOffset = targetOffset;
} // get css left top value
// in case overlay is inside a relative container
// get css left top value
// in case overlay is inside a relative container
ghost.offset(toOffset);
util.mix(to, {
left: ghost.css('left'),
top: ghost.css('top')
});
el.css('visibility', 'hidden');
ghost.css(from);
ghost.offset(fromOffset);
self.__effectGhost = ghost;
ghost.css('visibility', 'visible');
ghost.animate(to, {
Anim: effectCfg.Anim,
duration: duration,
easing: easing,
complete: function () {
self.__effectGhost = null;
ghost.remove();
el.css('visibility', '');
}
});
}
Editor.prototype.addButton = function (id, cfg, ButtonType) {
if (ButtonType === undefined) {
ButtonType = Button;
}
var self = this,
prefixCls = self.get('prefixCls') + 'editor-toolbar-';
if (cfg.elCls) {
cfg.elCls = prefixCls + cfg.elCls;
}
cfg.elCls = prefixCls + 'button ' + (cfg.elCls || '');
var b = new ButtonType(util.mix({
render: self.get('toolBarEl'),
content: '<span ' +
'class="' + prefixCls + 'item ' +
prefixCls + id +
'"></span' +
'>',
prefixCls: self.get('prefixCls') + 'editor-',
editor: self
}, cfg)).render();
if (!cfg.content) {
var contentEl = b.get('el').one('span');
b.on('afterContentClsChange', function (e) {
contentEl[0].className = prefixCls + 'item ' +
prefixCls + e.newVal;
});
}
if (b.get('mode') === Editor.Mode.WYSIWYG_MODE) {
self.on('wysiwygMode', function () {
b.set('disabled', false);
});
self.on('sourceMode', function () {
b.set('disabled', true);
});
}
self.addControl(id + '/button', b);
return b;
};
beforeCreateDom: function (renderData) {
var self = this;
var value = self.get('value');
var currentYear = value.getYear();
var startYear = parseInt(currentYear / 10, 10) * 10;
var endYear = startYear + 9;
var locale = self.get('locale');
util.mix(renderData, {
decadeSelectLabel: locale.decadeSelect,
years: prepareYears(self),
startYear: startYear,
endYear: endYear,
year: value.getYear(),
previousDecadeLabel: locale.previousDecade,
nextDecadeLabel: locale.nextDecade
});
},
function showMenu() {
var self = this,
menu = self.get('menu');
// does not put this into setter
// in case set menu before submenu item is rendered
var align = {
node: this.$el,
points: ['tr', 'tl'],
overflow: {
adjustX: 1,
adjustY: 1
}
};
util.mix(menu.get('align'), align, false);
menu.show();
self.el.setAttribute('aria-haspopup', menu.get('el').attr('id'));
}
Editor.prototype.addSelect = function(id, cfg, SelectType) {
_$jscoverage['/menubutton.js'].functionData[1]++;
_$jscoverage['/menubutton.js'].lineData[18]++;
SelectType = visit1_18_1(SelectType || MenuButton.Select);
_$jscoverage['/menubutton.js'].lineData[20]++;
var self = this, prefixCls = self.get('prefixCls') + 'editor-';
_$jscoverage['/menubutton.js'].lineData[22]++;
if (visit2_22_1(cfg)) {
_$jscoverage['/menubutton.js'].lineData[23]++;
cfg.editor = self;
_$jscoverage['/menubutton.js'].lineData[24]++;
if (visit3_24_1(cfg.menu)) {
_$jscoverage['/menubutton.js'].lineData[25]++;
cfg.menu.zIndex = Editor.baseZIndex(Editor.ZIndexManager.SELECT);
}
_$jscoverage['/menubutton.js'].lineData[27]++;
if (visit4_27_1(cfg.elCls)) {
_$jscoverage['/menubutton.js'].lineData[28]++;
cfg.elCls = prefixCls + cfg.elCls;
}
}
_$jscoverage['/menubutton.js'].lineData[32]++;
var s = new SelectType(util.mix({
render: self.get('toolBarEl'),
prefixCls: prefixCls}, cfg)).render();
_$jscoverage['/menubutton.js'].lineData[37]++;
if (visit5_37_1(cfg.mode === Editor.Mode.WYSIWYG_MODE)) {
_$jscoverage['/menubutton.js'].lineData[38]++;
self.on('wysiwygMode', function() {
_$jscoverage['/menubutton.js'].functionData[2]++;
_$jscoverage['/menubutton.js'].lineData[39]++;
s.set('disabled', false);
});
_$jscoverage['/menubutton.js'].lineData[41]++;
self.on('sourceMode', function() {
_$jscoverage['/menubutton.js'].functionData[3]++;
_$jscoverage['/menubutton.js'].lineData[42]++;
s.set('disabled', true);
});
}
_$jscoverage['/menubutton.js'].lineData[45]++;
self.addControl(id + '/select', s);
_$jscoverage['/menubutton.js'].lineData[46]++;
return s;
};
drawLines: function(cb) {
var self = this,
_cfg = self._cfg,
len = POINTS_TYPE.length;
self._lines = {};
self._stocks = {};
for (var i in self._points) {
var path = BaseChart.Common.getLinePath.call(null, self, self._points[i]),
curColor = self.color.getColor(i),
pointsAttr = self.processAttr(self._cfg.points.attr, curColor.DEFAULT),
hoverAttr = self.processAttr(self._cfg.points.hoverAttr, curColor.HOVER),
line;
//保存点的信息
self._stocks[i] = {
points: self._points[i],
color: curColor,
attr: pointsAttr,
hoverAttr: hoverAttr,
type: pointsAttr.type == "auto" ? POINTS_TYPE[i % len] : pointsAttr.type
};
line = _cfg.anim ? self.animateLine(i, cb) : self.drawLine(i);
self._lines[i] = {
line: line,
path: path,
points: self._points[i],
color: curColor,
attr: Util.mix({
stroke: curColor.DEFAULT
}, self._cfg.line.attr),
isShow: true
};
if (self._finished.length == _cfg.series.length) {
cb && cb();
}
}
return self._lines;
},
function wrapFuncWithSpyStuff(func) {
var funcBackup = func;
var func = util.wrap(func, function(originFunc) {
var args = slice.call(arguments, 1);
var thisFunc = func;
var start = +new Date;
// If this function call is through "new" operator.
if (arguments.callee.prototype && this instanceof arguments.callee) {
// http://stackoverflow.com/questions/1606797/use-of-apply-with-new-operator-is-this-possible
function F(args2) {
return originFunc.apply(this, args2);
}
F.prototype = originFunc.prototype;
result = new F(args);
} else {
result = originFunc.apply(this, args);
}
var end = +new Date;
thisFunc._callShot = {
startTime: start,
endTime: end,
time: end - start,
args: args,
result: result,
stack: (new Error('-_-')).stack,
thisValue: this,
thisFunc: thisFunc
}
thisFunc.incrementCallCount();
spy.fire('call-' + thisFunc.fullname, thisFunc._callShot);
spy.fire('call', {
funcId: thisFunc.fullname,
callShot: thisFunc._callShot
});
return result;
});
//--原来方法的变量和原型
util.mix(func, funcBackup);
func.prototype = funcBackup.prototype;
return func;
}