6681 lines
256 KiB
JavaScript
6681 lines
256 KiB
JavaScript
|
|
|
|
|
|
! function(t) {
|
|
if ("object" == typeof exports && "undefined" != typeof module) module.exports = t();
|
|
else if ("function" == typeof define && define.amd) define([], t);
|
|
else {
|
|
("undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof self ? self : this).Chart = t()
|
|
}
|
|
}(function() {
|
|
return function t(e, n, i) {
|
|
function a(r, l) {
|
|
if (!n[r]) {
|
|
if (!e[r]) {
|
|
var s = "function" == typeof require && require;
|
|
if (!l && s) return s(r, !0);
|
|
if (o) return o(r, !0);
|
|
var u = new Error("Cannot find module '" + r + "'");
|
|
throw u.code = "MODULE_NOT_FOUND", u
|
|
}
|
|
var d = n[r] = {
|
|
exports: {}
|
|
};
|
|
e[r][0].call(d.exports, function(t) {
|
|
var n = e[r][1][t];
|
|
return a(n || t)
|
|
}, d, d.exports, t, e, n, i)
|
|
}
|
|
return n[r].exports
|
|
}
|
|
for (var o = "function" == typeof require && require, r = 0; r < i.length; r++) a(i[r]);
|
|
return a
|
|
}({
|
|
1: [function(t, e, n) {}, {}],
|
|
2: [function(t, e, n) {
|
|
function i(t) {
|
|
if (t) {
|
|
var e = /^#([a-fA-F0-9]{3})$/i,
|
|
n = /^#([a-fA-F0-9]{6})$/i,
|
|
i = /^rgba?\(\s*([+-]?\d+)\s*,\s*([+-]?\d+)\s*,\s*([+-]?\d+)\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)$/i,
|
|
a = /^rgba?\(\s*([+-]?[\d\.]+)\%\s*,\s*([+-]?[\d\.]+)\%\s*,\s*([+-]?[\d\.]+)\%\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)$/i,
|
|
o = /(\w+)/,
|
|
r = [0, 0, 0],
|
|
l = 1,
|
|
s = t.match(e);
|
|
if (s) {
|
|
s = s[1];
|
|
for (d = 0; d < r.length; d++) r[d] = parseInt(s[d] + s[d], 16)
|
|
} else if (s = t.match(n)) {
|
|
s = s[1];
|
|
for (d = 0; d < r.length; d++) r[d] = parseInt(s.slice(2 * d, 2 * d + 2), 16)
|
|
} else if (s = t.match(i)) {
|
|
for (d = 0; d < r.length; d++) r[d] = parseInt(s[d + 1]);
|
|
l = parseFloat(s[4])
|
|
} else if (s = t.match(a)) {
|
|
for (d = 0; d < r.length; d++) r[d] = Math.round(2.55 * parseFloat(s[d + 1]));
|
|
l = parseFloat(s[4])
|
|
} else if (s = t.match(o)) {
|
|
if ("transparent" == s[1]) return [0, 0, 0, 0];
|
|
if (!(r = c[s[1]])) return
|
|
}
|
|
for (var d = 0; d < r.length; d++) r[d] = u(r[d], 0, 255);
|
|
return l = l || 0 == l ? u(l, 0, 1) : 1, r[3] = l, r
|
|
}
|
|
}
|
|
|
|
function a(t) {
|
|
if (t) {
|
|
var e = /^hsla?\(\s*([+-]?\d+)(?:deg)?\s*,\s*([+-]?[\d\.]+)%\s*,\s*([+-]?[\d\.]+)%\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)/,
|
|
n = t.match(e);
|
|
if (n) {
|
|
var i = parseFloat(n[4]);
|
|
return [u(parseInt(n[1]), 0, 360), u(parseFloat(n[2]), 0, 100), u(parseFloat(n[3]), 0, 100), u(isNaN(i) ? 1 : i, 0, 1)]
|
|
}
|
|
}
|
|
}
|
|
|
|
function o(t) {
|
|
if (t) {
|
|
var e = /^hwb\(\s*([+-]?\d+)(?:deg)?\s*,\s*([+-]?[\d\.]+)%\s*,\s*([+-]?[\d\.]+)%\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)/,
|
|
n = t.match(e);
|
|
if (n) {
|
|
var i = parseFloat(n[4]);
|
|
return [u(parseInt(n[1]), 0, 360), u(parseFloat(n[2]), 0, 100), u(parseFloat(n[3]), 0, 100), u(isNaN(i) ? 1 : i, 0, 1)]
|
|
}
|
|
}
|
|
}
|
|
|
|
function r(t, e) {
|
|
return void 0 === e && (e = void 0 !== t[3] ? t[3] : 1), "rgba(" + t[0] + ", " + t[1] + ", " + t[2] + ", " + e + ")"
|
|
}
|
|
|
|
function l(t, e) {
|
|
return "rgba(" + Math.round(t[0] / 255 * 100) + "%, " + Math.round(t[1] / 255 * 100) + "%, " + Math.round(t[2] / 255 * 100) + "%, " + (e || t[3] || 1) + ")"
|
|
}
|
|
|
|
function s(t, e) {
|
|
return void 0 === e && (e = void 0 !== t[3] ? t[3] : 1), "hsla(" + t[0] + ", " + t[1] + "%, " + t[2] + "%, " + e + ")"
|
|
}
|
|
|
|
function u(t, e, n) {
|
|
return Math.min(Math.max(e, t), n)
|
|
}
|
|
|
|
function d(t) {
|
|
var e = t.toString(16).toUpperCase();
|
|
return e.length < 2 ? "0" + e : e
|
|
}
|
|
var c = t(6);
|
|
e.exports = {
|
|
getRgba: i,
|
|
getHsla: a,
|
|
getRgb: function(t) {
|
|
var e = i(t);
|
|
return e && e.slice(0, 3)
|
|
},
|
|
getHsl: function(t) {
|
|
var e = a(t);
|
|
return e && e.slice(0, 3)
|
|
},
|
|
getHwb: o,
|
|
getAlpha: function(t) {
|
|
var e = i(t);
|
|
return e ? e[3] : (e = a(t)) ? e[3] : (e = o(t)) ? e[3] : void 0
|
|
},
|
|
hexString: function(t) {
|
|
return "#" + d(t[0]) + d(t[1]) + d(t[2])
|
|
},
|
|
rgbString: function(t, e) {
|
|
return e < 1 || t[3] && t[3] < 1 ? r(t, e) : "rgb(" + t[0] + ", " + t[1] + ", " + t[2] + ")"
|
|
},
|
|
rgbaString: r,
|
|
percentString: function(t, e) {
|
|
return e < 1 || t[3] && t[3] < 1 ? l(t, e) : "rgb(" + Math.round(t[0] / 255 * 100) + "%, " + Math.round(t[1] / 255 * 100) + "%, " + Math.round(t[2] / 255 * 100) + "%)"
|
|
},
|
|
percentaString: l,
|
|
hslString: function(t, e) {
|
|
return e < 1 || t[3] && t[3] < 1 ? s(t, e) : "hsl(" + t[0] + ", " + t[1] + "%, " + t[2] + "%)"
|
|
},
|
|
hslaString: s,
|
|
hwbString: function(t, e) {
|
|
return void 0 === e && (e = void 0 !== t[3] ? t[3] : 1), "hwb(" + t[0] + ", " + t[1] + "%, " + t[2] + "%" + (void 0 !== e && 1 !== e ? ", " + e : "") + ")"
|
|
},
|
|
keyword: function(t) {
|
|
return h[t.slice(0, 3)]
|
|
}
|
|
};
|
|
var h = {};
|
|
for (var f in c) h[c[f]] = f
|
|
}, {
|
|
6: 6
|
|
}],
|
|
3: [function(t, e, n) {
|
|
var i = t(5),
|
|
a = t(2),
|
|
o = function(t) {
|
|
if (t instanceof o) return t;
|
|
if (!(this instanceof o)) return new o(t);
|
|
this.valid = !1, this.values = {
|
|
rgb: [0, 0, 0],
|
|
hsl: [0, 0, 0],
|
|
hsv: [0, 0, 0],
|
|
hwb: [0, 0, 0],
|
|
cmyk: [0, 0, 0, 0],
|
|
alpha: 1
|
|
};
|
|
var e;
|
|
"string" == typeof t ? (e = a.getRgba(t)) ? this.setValues("rgb", e) : (e = a.getHsla(t)) ? this.setValues("hsl", e) : (e = a.getHwb(t)) && this.setValues("hwb", e) : "object" == typeof t && (void 0 !== (e = t).r || void 0 !== e.red ? this.setValues("rgb", e) : void 0 !== e.l || void 0 !== e.lightness ? this.setValues("hsl", e) : void 0 !== e.v || void 0 !== e.value ? this.setValues("hsv", e) : void 0 !== e.w || void 0 !== e.whiteness ? this.setValues("hwb", e) : void 0 === e.c && void 0 === e.cyan || this.setValues("cmyk", e))
|
|
};
|
|
o.prototype = {
|
|
isValid: function() {
|
|
return this.valid
|
|
},
|
|
rgb: function() {
|
|
return this.setSpace("rgb", arguments)
|
|
},
|
|
hsl: function() {
|
|
return this.setSpace("hsl", arguments)
|
|
},
|
|
hsv: function() {
|
|
return this.setSpace("hsv", arguments)
|
|
},
|
|
hwb: function() {
|
|
return this.setSpace("hwb", arguments)
|
|
},
|
|
cmyk: function() {
|
|
return this.setSpace("cmyk", arguments)
|
|
},
|
|
rgbArray: function() {
|
|
return this.values.rgb
|
|
},
|
|
hslArray: function() {
|
|
return this.values.hsl
|
|
},
|
|
hsvArray: function() {
|
|
return this.values.hsv
|
|
},
|
|
hwbArray: function() {
|
|
var t = this.values;
|
|
return 1 !== t.alpha ? t.hwb.concat([t.alpha]) : t.hwb
|
|
},
|
|
cmykArray: function() {
|
|
return this.values.cmyk
|
|
},
|
|
rgbaArray: function() {
|
|
var t = this.values;
|
|
return t.rgb.concat([t.alpha])
|
|
},
|
|
hslaArray: function() {
|
|
var t = this.values;
|
|
return t.hsl.concat([t.alpha])
|
|
},
|
|
alpha: function(t) {
|
|
return void 0 === t ? this.values.alpha : (this.setValues("alpha", t), this)
|
|
},
|
|
red: function(t) {
|
|
return this.setChannel("rgb", 0, t)
|
|
},
|
|
green: function(t) {
|
|
return this.setChannel("rgb", 1, t)
|
|
},
|
|
blue: function(t) {
|
|
return this.setChannel("rgb", 2, t)
|
|
},
|
|
hue: function(t) {
|
|
return t && (t = (t %= 360) < 0 ? 360 + t : t), this.setChannel("hsl", 0, t)
|
|
},
|
|
saturation: function(t) {
|
|
return this.setChannel("hsl", 1, t)
|
|
},
|
|
lightness: function(t) {
|
|
return this.setChannel("hsl", 2, t)
|
|
},
|
|
saturationv: function(t) {
|
|
return this.setChannel("hsv", 1, t)
|
|
},
|
|
whiteness: function(t) {
|
|
return this.setChannel("hwb", 1, t)
|
|
},
|
|
blackness: function(t) {
|
|
return this.setChannel("hwb", 2, t)
|
|
},
|
|
value: function(t) {
|
|
return this.setChannel("hsv", 2, t)
|
|
},
|
|
cyan: function(t) {
|
|
return this.setChannel("cmyk", 0, t)
|
|
},
|
|
magenta: function(t) {
|
|
return this.setChannel("cmyk", 1, t)
|
|
},
|
|
yellow: function(t) {
|
|
return this.setChannel("cmyk", 2, t)
|
|
},
|
|
black: function(t) {
|
|
return this.setChannel("cmyk", 3, t)
|
|
},
|
|
hexString: function() {
|
|
return a.hexString(this.values.rgb)
|
|
},
|
|
rgbString: function() {
|
|
return a.rgbString(this.values.rgb, this.values.alpha)
|
|
},
|
|
rgbaString: function() {
|
|
return a.rgbaString(this.values.rgb, this.values.alpha)
|
|
},
|
|
percentString: function() {
|
|
return a.percentString(this.values.rgb, this.values.alpha)
|
|
},
|
|
hslString: function() {
|
|
return a.hslString(this.values.hsl, this.values.alpha)
|
|
},
|
|
hslaString: function() {
|
|
return a.hslaString(this.values.hsl, this.values.alpha)
|
|
},
|
|
hwbString: function() {
|
|
return a.hwbString(this.values.hwb, this.values.alpha)
|
|
},
|
|
keyword: function() {
|
|
return a.keyword(this.values.rgb, this.values.alpha)
|
|
},
|
|
rgbNumber: function() {
|
|
var t = this.values.rgb;
|
|
return t[0] << 16 | t[1] << 8 | t[2]
|
|
},
|
|
luminosity: function() {
|
|
for (var t = this.values.rgb, e = [], n = 0; n < t.length; n++) {
|
|
var i = t[n] / 255;
|
|
e[n] = i <= .03928 ? i / 12.92 : Math.pow((i + .055) / 1.055, 2.4)
|
|
}
|
|
return .2126 * e[0] + .7152 * e[1] + .0722 * e[2]
|
|
},
|
|
contrast: function(t) {
|
|
var e = this.luminosity(),
|
|
n = t.luminosity();
|
|
return e > n ? (e + .05) / (n + .05) : (n + .05) / (e + .05)
|
|
},
|
|
level: function(t) {
|
|
var e = this.contrast(t);
|
|
return e >= 7.1 ? "AAA" : e >= 4.5 ? "AA" : ""
|
|
},
|
|
dark: function() {
|
|
var t = this.values.rgb;
|
|
return (299 * t[0] + 587 * t[1] + 114 * t[2]) / 1e3 < 128
|
|
},
|
|
light: function() {
|
|
return !this.dark()
|
|
},
|
|
negate: function() {
|
|
for (var t = [], e = 0; e < 3; e++) t[e] = 255 - this.values.rgb[e];
|
|
return this.setValues("rgb", t), this
|
|
},
|
|
lighten: function(t) {
|
|
var e = this.values.hsl;
|
|
return e[2] += e[2] * t, this.setValues("hsl", e), this
|
|
},
|
|
darken: function(t) {
|
|
var e = this.values.hsl;
|
|
return e[2] -= e[2] * t, this.setValues("hsl", e), this
|
|
},
|
|
saturate: function(t) {
|
|
var e = this.values.hsl;
|
|
return e[1] += e[1] * t, this.setValues("hsl", e), this
|
|
},
|
|
desaturate: function(t) {
|
|
var e = this.values.hsl;
|
|
return e[1] -= e[1] * t, this.setValues("hsl", e), this
|
|
},
|
|
whiten: function(t) {
|
|
var e = this.values.hwb;
|
|
return e[1] += e[1] * t, this.setValues("hwb", e), this
|
|
},
|
|
blacken: function(t) {
|
|
var e = this.values.hwb;
|
|
return e[2] += e[2] * t, this.setValues("hwb", e), this
|
|
},
|
|
greyscale: function() {
|
|
var t = this.values.rgb,
|
|
e = .3 * t[0] + .59 * t[1] + .11 * t[2];
|
|
return this.setValues("rgb", [e, e, e]), this
|
|
},
|
|
clearer: function(t) {
|
|
var e = this.values.alpha;
|
|
return this.setValues("alpha", e - e * t), this
|
|
},
|
|
opaquer: function(t) {
|
|
var e = this.values.alpha;
|
|
return this.setValues("alpha", e + e * t), this
|
|
},
|
|
rotate: function(t) {
|
|
var e = this.values.hsl,
|
|
n = (e[0] + t) % 360;
|
|
return e[0] = n < 0 ? 360 + n : n, this.setValues("hsl", e), this
|
|
},
|
|
mix: function(t, e) {
|
|
var n = this,
|
|
i = t,
|
|
a = void 0 === e ? .5 : e,
|
|
o = 2 * a - 1,
|
|
r = n.alpha() - i.alpha(),
|
|
l = ((o * r == -1 ? o : (o + r) / (1 + o * r)) + 1) / 2,
|
|
s = 1 - l;
|
|
return this.rgb(l * n.red() + s * i.red(), l * n.green() + s * i.green(), l * n.blue() + s * i.blue()).alpha(n.alpha() * a + i.alpha() * (1 - a))
|
|
},
|
|
toJSON: function() {
|
|
return this.rgb()
|
|
},
|
|
clone: function() {
|
|
var t, e, n = new o,
|
|
i = this.values,
|
|
a = n.values;
|
|
for (var r in i) i.hasOwnProperty(r) && (t = i[r], "[object Array]" === (e = {}.toString.call(t)) ? a[r] = t.slice(0) : "[object Number]" === e ? a[r] = t : console.error("unexpected color value:", t));
|
|
return n
|
|
}
|
|
}, o.prototype.spaces = {
|
|
rgb: ["red", "green", "blue"],
|
|
hsl: ["hue", "saturation", "lightness"],
|
|
hsv: ["hue", "saturation", "value"],
|
|
hwb: ["hue", "whiteness", "blackness"],
|
|
cmyk: ["cyan", "magenta", "yellow", "black"]
|
|
}, o.prototype.maxes = {
|
|
rgb: [255, 255, 255],
|
|
hsl: [360, 100, 100],
|
|
hsv: [360, 100, 100],
|
|
hwb: [360, 100, 100],
|
|
cmyk: [100, 100, 100, 100]
|
|
}, o.prototype.getValues = function(t) {
|
|
for (var e = this.values, n = {}, i = 0; i < t.length; i++) n[t.charAt(i)] = e[t][i];
|
|
return 1 !== e.alpha && (n.a = e.alpha), n
|
|
}, o.prototype.setValues = function(t, e) {
|
|
var n, a = this.values,
|
|
o = this.spaces,
|
|
r = this.maxes,
|
|
l = 1;
|
|
if (this.valid = !0, "alpha" === t) l = e;
|
|
else if (e.length) a[t] = e.slice(0, t.length), l = e[t.length];
|
|
else if (void 0 !== e[t.charAt(0)]) {
|
|
for (n = 0; n < t.length; n++) a[t][n] = e[t.charAt(n)];
|
|
l = e.a
|
|
} else if (void 0 !== e[o[t][0]]) {
|
|
var s = o[t];
|
|
for (n = 0; n < t.length; n++) a[t][n] = e[s[n]];
|
|
l = e.alpha
|
|
}
|
|
if (a.alpha = Math.max(0, Math.min(1, void 0 === l ? a.alpha : l)), "alpha" === t) return !1;
|
|
var u;
|
|
for (n = 0; n < t.length; n++) u = Math.max(0, Math.min(r[t][n], a[t][n])), a[t][n] = Math.round(u);
|
|
for (var d in o) d !== t && (a[d] = i[t][d](a[t]));
|
|
return !0
|
|
}, o.prototype.setSpace = function(t, e) {
|
|
var n = e[0];
|
|
return void 0 === n ? this.getValues(t) : ("number" == typeof n && (n = Array.prototype.slice.call(e)), this.setValues(t, n), this)
|
|
}, o.prototype.setChannel = function(t, e, n) {
|
|
var i = this.values[t];
|
|
return void 0 === n ? i[e] : n === i[e] ? this : (i[e] = n, this.setValues(t, i), this)
|
|
}, "undefined" != typeof window && (window.Color = o), e.exports = o
|
|
}, {
|
|
2: 2,
|
|
5: 5
|
|
}],
|
|
4: [function(t, e, n) {
|
|
function i(t) {
|
|
var e, n, i, a = t[0] / 255,
|
|
o = t[1] / 255,
|
|
r = t[2] / 255,
|
|
l = Math.min(a, o, r),
|
|
s = Math.max(a, o, r),
|
|
u = s - l;
|
|
return s == l ? e = 0 : a == s ? e = (o - r) / u : o == s ? e = 2 + (r - a) / u : r == s && (e = 4 + (a - o) / u), (e = Math.min(60 * e, 360)) < 0 && (e += 360), i = (l + s) / 2, n = s == l ? 0 : i <= .5 ? u / (s + l) : u / (2 - s - l), [e, 100 * n, 100 * i]
|
|
}
|
|
|
|
function a(t) {
|
|
var e, n, i, a = t[0],
|
|
o = t[1],
|
|
r = t[2],
|
|
l = Math.min(a, o, r),
|
|
s = Math.max(a, o, r),
|
|
u = s - l;
|
|
return n = 0 == s ? 0 : u / s * 1e3 / 10, s == l ? e = 0 : a == s ? e = (o - r) / u : o == s ? e = 2 + (r - a) / u : r == s && (e = 4 + (a - o) / u), (e = Math.min(60 * e, 360)) < 0 && (e += 360), i = s / 255 * 1e3 / 10, [e, n, i]
|
|
}
|
|
|
|
function o(t) {
|
|
var e = t[0],
|
|
n = t[1],
|
|
a = t[2];
|
|
return [i(t)[0], 100 * (1 / 255 * Math.min(e, Math.min(n, a))), 100 * (a = 1 - 1 / 255 * Math.max(e, Math.max(n, a)))]
|
|
}
|
|
|
|
function l(t) {
|
|
var e, n, i, a, o = t[0] / 255,
|
|
r = t[1] / 255,
|
|
l = t[2] / 255;
|
|
return a = Math.min(1 - o, 1 - r, 1 - l), e = (1 - o - a) / (1 - a) || 0, n = (1 - r - a) / (1 - a) || 0, i = (1 - l - a) / (1 - a) || 0, [100 * e, 100 * n, 100 * i, 100 * a]
|
|
}
|
|
|
|
function s(t) {
|
|
return C[JSON.stringify(t)]
|
|
}
|
|
|
|
function u(t) {
|
|
var e = t[0] / 255,
|
|
n = t[1] / 255,
|
|
i = t[2] / 255;
|
|
return [100 * (.4124 * (e = e > .04045 ? Math.pow((e + .055) / 1.055, 2.4) : e / 12.92) + .3576 * (n = n > .04045 ? Math.pow((n + .055) / 1.055, 2.4) : n / 12.92) + .1805 * (i = i > .04045 ? Math.pow((i + .055) / 1.055, 2.4) : i / 12.92)), 100 * (.2126 * e + .7152 * n + .0722 * i), 100 * (.0193 * e + .1192 * n + .9505 * i)]
|
|
}
|
|
|
|
function d(t) {
|
|
var e, n, i, a = u(t),
|
|
o = a[0],
|
|
r = a[1],
|
|
l = a[2];
|
|
return o /= 95.047, r /= 100, l /= 108.883, o = o > .008856 ? Math.pow(o, 1 / 3) : 7.787 * o + 16 / 116, r = r > .008856 ? Math.pow(r, 1 / 3) : 7.787 * r + 16 / 116, l = l > .008856 ? Math.pow(l, 1 / 3) : 7.787 * l + 16 / 116, e = 116 * r - 16, n = 500 * (o - r), i = 200 * (r - l), [e, n, i]
|
|
}
|
|
|
|
function c(t) {
|
|
var e, n, i, a, o, r = t[0] / 360,
|
|
l = t[1] / 100,
|
|
s = t[2] / 100;
|
|
if (0 == l) return o = 255 * s, [o, o, o];
|
|
e = 2 * s - (n = s < .5 ? s * (1 + l) : s + l - s * l), a = [0, 0, 0];
|
|
for (var u = 0; u < 3; u++)(i = r + 1 / 3 * -(u - 1)) < 0 && i++, i > 1 && i--, o = 6 * i < 1 ? e + 6 * (n - e) * i : 2 * i < 1 ? n : 3 * i < 2 ? e + (n - e) * (2 / 3 - i) * 6 : e, a[u] = 255 * o;
|
|
return a
|
|
}
|
|
|
|
function h(t) {
|
|
var e = t[0] / 60,
|
|
n = t[1] / 100,
|
|
i = t[2] / 100,
|
|
a = Math.floor(e) % 6,
|
|
o = e - Math.floor(e),
|
|
r = 255 * i * (1 - n),
|
|
l = 255 * i * (1 - n * o),
|
|
s = 255 * i * (1 - n * (1 - o)),
|
|
i = 255 * i;
|
|
switch (a) {
|
|
case 0:
|
|
return [i, s, r];
|
|
case 1:
|
|
return [l, i, r];
|
|
case 2:
|
|
return [r, i, s];
|
|
case 3:
|
|
return [r, l, i];
|
|
case 4:
|
|
return [s, r, i];
|
|
case 5:
|
|
return [i, r, l]
|
|
}
|
|
}
|
|
|
|
function f(t) {
|
|
var e, n, i, a, o = t[0] / 360,
|
|
l = t[1] / 100,
|
|
s = t[2] / 100,
|
|
u = l + s;
|
|
switch (u > 1 && (l /= u, s /= u), e = Math.floor(6 * o), n = 1 - s, i = 6 * o - e, 0 != (1 & e) && (i = 1 - i), a = l + i * (n - l), e) {
|
|
default:
|
|
case 6:
|
|
case 0:
|
|
r = n,
|
|
g = a,
|
|
b = l;
|
|
break;
|
|
case 1:
|
|
r = a,
|
|
g = n,
|
|
b = l;
|
|
break;
|
|
case 2:
|
|
r = l,
|
|
g = n,
|
|
b = a;
|
|
break;
|
|
case 3:
|
|
r = l,
|
|
g = a,
|
|
b = n;
|
|
break;
|
|
case 4:
|
|
r = a,
|
|
g = l,
|
|
b = n;
|
|
break;
|
|
case 5:
|
|
r = n,
|
|
g = l,
|
|
b = a
|
|
}
|
|
return [255 * r, 255 * g, 255 * b]
|
|
}
|
|
|
|
function p(t) {
|
|
var e, n, i, a = t[0] / 100,
|
|
o = t[1] / 100,
|
|
r = t[2] / 100,
|
|
l = t[3] / 100;
|
|
return e = 1 - Math.min(1, a * (1 - l) + l), n = 1 - Math.min(1, o * (1 - l) + l), i = 1 - Math.min(1, r * (1 - l) + l), [255 * e, 255 * n, 255 * i]
|
|
}
|
|
|
|
function v(t) {
|
|
var e, n, i, a = t[0] / 100,
|
|
o = t[1] / 100,
|
|
r = t[2] / 100;
|
|
return e = 3.2406 * a + -1.5372 * o + -.4986 * r, n = -.9689 * a + 1.8758 * o + .0415 * r, i = .0557 * a + -.204 * o + 1.057 * r, e = e > .0031308 ? 1.055 * Math.pow(e, 1 / 2.4) - .055 : e *= 12.92, n = n > .0031308 ? 1.055 * Math.pow(n, 1 / 2.4) - .055 : n *= 12.92, i = i > .0031308 ? 1.055 * Math.pow(i, 1 / 2.4) - .055 : i *= 12.92, e = Math.min(Math.max(0, e), 1), n = Math.min(Math.max(0, n), 1), i = Math.min(Math.max(0, i), 1), [255 * e, 255 * n, 255 * i]
|
|
}
|
|
|
|
function m(t) {
|
|
var e, n, i, a = t[0],
|
|
o = t[1],
|
|
r = t[2];
|
|
return a /= 95.047, o /= 100, r /= 108.883, a = a > .008856 ? Math.pow(a, 1 / 3) : 7.787 * a + 16 / 116, o = o > .008856 ? Math.pow(o, 1 / 3) : 7.787 * o + 16 / 116, r = r > .008856 ? Math.pow(r, 1 / 3) : 7.787 * r + 16 / 116, e = 116 * o - 16, n = 500 * (a - o), i = 200 * (o - r), [e, n, i]
|
|
}
|
|
|
|
function x(t) {
|
|
var e, n, i, a, o = t[0],
|
|
r = t[1],
|
|
l = t[2];
|
|
return o <= 8 ? a = (n = 100 * o / 903.3) / 100 * 7.787 + 16 / 116 : (n = 100 * Math.pow((o + 16) / 116, 3), a = Math.pow(n / 100, 1 / 3)), e = e / 95.047 <= .008856 ? e = 95.047 * (r / 500 + a - 16 / 116) / 7.787 : 95.047 * Math.pow(r / 500 + a, 3), i = i / 108.883 <= .008859 ? i = 108.883 * (a - l / 200 - 16 / 116) / 7.787 : 108.883 * Math.pow(a - l / 200, 3), [e, n, i]
|
|
}
|
|
|
|
function y(t) {
|
|
var e, n, i, a = t[0],
|
|
o = t[1],
|
|
r = t[2];
|
|
return e = Math.atan2(r, o), (n = 360 * e / 2 / Math.PI) < 0 && (n += 360), i = Math.sqrt(o * o + r * r), [a, i, n]
|
|
}
|
|
|
|
function k(t) {
|
|
return v(x(t))
|
|
}
|
|
|
|
function w(t) {
|
|
var e, n, i, a = t[0],
|
|
o = t[1];
|
|
return i = t[2] / 360 * 2 * Math.PI, e = o * Math.cos(i), n = o * Math.sin(i), [a, e, n]
|
|
}
|
|
|
|
function M(t) {
|
|
return S[t]
|
|
}
|
|
e.exports = {
|
|
rgb2hsl: i,
|
|
rgb2hsv: a,
|
|
rgb2hwb: o,
|
|
rgb2cmyk: l,
|
|
rgb2keyword: s,
|
|
rgb2xyz: u,
|
|
rgb2lab: d,
|
|
rgb2lch: function(t) {
|
|
return y(d(t))
|
|
},
|
|
hsl2rgb: c,
|
|
hsl2hsv: function(t) {
|
|
var e, n, i = t[0],
|
|
a = t[1] / 100,
|
|
o = t[2] / 100;
|
|
return 0 === o ? [0, 0, 0] : (o *= 2, a *= o <= 1 ? o : 2 - o, n = (o + a) / 2, e = 2 * a / (o + a), [i, 100 * e, 100 * n])
|
|
},
|
|
hsl2hwb: function(t) {
|
|
return o(c(t))
|
|
},
|
|
hsl2cmyk: function(t) {
|
|
return l(c(t))
|
|
},
|
|
hsl2keyword: function(t) {
|
|
return s(c(t))
|
|
},
|
|
hsv2rgb: h,
|
|
hsv2hsl: function(t) {
|
|
var e, n, i = t[0],
|
|
a = t[1] / 100,
|
|
o = t[2] / 100;
|
|
return n = (2 - a) * o, e = a * o, e /= n <= 1 ? n : 2 - n, e = e || 0, n /= 2, [i, 100 * e, 100 * n]
|
|
},
|
|
hsv2hwb: function(t) {
|
|
return o(h(t))
|
|
},
|
|
hsv2cmyk: function(t) {
|
|
return l(h(t))
|
|
},
|
|
hsv2keyword: function(t) {
|
|
return s(h(t))
|
|
},
|
|
hwb2rgb: f,
|
|
hwb2hsl: function(t) {
|
|
return i(f(t))
|
|
},
|
|
hwb2hsv: function(t) {
|
|
return a(f(t))
|
|
},
|
|
hwb2cmyk: function(t) {
|
|
return l(f(t))
|
|
},
|
|
hwb2keyword: function(t) {
|
|
return s(f(t))
|
|
},
|
|
cmyk2rgb: p,
|
|
cmyk2hsl: function(t) {
|
|
return i(p(t))
|
|
},
|
|
cmyk2hsv: function(t) {
|
|
return a(p(t))
|
|
},
|
|
cmyk2hwb: function(t) {
|
|
return o(p(t))
|
|
},
|
|
cmyk2keyword: function(t) {
|
|
return s(p(t))
|
|
},
|
|
keyword2rgb: M,
|
|
keyword2hsl: function(t) {
|
|
return i(M(t))
|
|
},
|
|
keyword2hsv: function(t) {
|
|
return a(M(t))
|
|
},
|
|
keyword2hwb: function(t) {
|
|
return o(M(t))
|
|
},
|
|
keyword2cmyk: function(t) {
|
|
return l(M(t))
|
|
},
|
|
keyword2lab: function(t) {
|
|
return d(M(t))
|
|
},
|
|
keyword2xyz: function(t) {
|
|
return u(M(t))
|
|
},
|
|
xyz2rgb: v,
|
|
xyz2lab: m,
|
|
xyz2lch: function(t) {
|
|
return y(m(t))
|
|
},
|
|
lab2xyz: x,
|
|
lab2rgb: k,
|
|
lab2lch: y,
|
|
lch2lab: w,
|
|
lch2xyz: function(t) {
|
|
return x(w(t))
|
|
},
|
|
lch2rgb: function(t) {
|
|
return k(w(t))
|
|
}
|
|
};
|
|
var S = {
|
|
aliceblue: [240, 248, 255],
|
|
antiquewhite: [250, 235, 215],
|
|
aqua: [0, 255, 255],
|
|
aquamarine: [127, 255, 212],
|
|
azure: [240, 255, 255],
|
|
beige: [245, 245, 220],
|
|
bisque: [255, 228, 196],
|
|
black: [0, 0, 0],
|
|
blanchedalmond: [255, 235, 205],
|
|
blue: [0, 0, 255],
|
|
blueviolet: [138, 43, 226],
|
|
brown: [165, 42, 42],
|
|
burlywood: [222, 184, 135],
|
|
cadetblue: [95, 158, 160],
|
|
chartreuse: [127, 255, 0],
|
|
chocolate: [210, 105, 30],
|
|
coral: [255, 127, 80],
|
|
cornflowerblue: [100, 149, 237],
|
|
cornsilk: [255, 248, 220],
|
|
crimson: [220, 20, 60],
|
|
cyan: [0, 255, 255],
|
|
darkblue: [0, 0, 139],
|
|
darkcyan: [0, 139, 139],
|
|
darkgoldenrod: [184, 134, 11],
|
|
darkgray: [169, 169, 169],
|
|
darkgreen: [0, 100, 0],
|
|
darkgrey: [169, 169, 169],
|
|
darkkhaki: [189, 183, 107],
|
|
darkmagenta: [139, 0, 139],
|
|
darkolivegreen: [85, 107, 47],
|
|
darkorange: [255, 140, 0],
|
|
darkorchid: [153, 50, 204],
|
|
darkred: [139, 0, 0],
|
|
darksalmon: [233, 150, 122],
|
|
darkseagreen: [143, 188, 143],
|
|
darkslateblue: [72, 61, 139],
|
|
darkslategray: [47, 79, 79],
|
|
darkslategrey: [47, 79, 79],
|
|
darkturquoise: [0, 206, 209],
|
|
darkviolet: [148, 0, 211],
|
|
deeppink: [255, 20, 147],
|
|
deepskyblue: [0, 191, 255],
|
|
dimgray: [105, 105, 105],
|
|
dimgrey: [105, 105, 105],
|
|
dodgerblue: [30, 144, 255],
|
|
firebrick: [178, 34, 34],
|
|
floralwhite: [255, 250, 240],
|
|
forestgreen: [34, 139, 34],
|
|
fuchsia: [255, 0, 255],
|
|
gainsboro: [220, 220, 220],
|
|
ghostwhite: [248, 248, 255],
|
|
gold: [255, 215, 0],
|
|
goldenrod: [218, 165, 32],
|
|
gray: [128, 128, 128],
|
|
green: [0, 128, 0],
|
|
greenyellow: [173, 255, 47],
|
|
grey: [128, 128, 128],
|
|
honeydew: [240, 255, 240],
|
|
hotpink: [255, 105, 180],
|
|
indianred: [205, 92, 92],
|
|
indigo: [75, 0, 130],
|
|
ivory: [255, 255, 240],
|
|
khaki: [240, 230, 140],
|
|
lavender: [230, 230, 250],
|
|
lavenderblush: [255, 240, 245],
|
|
lawngreen: [124, 252, 0],
|
|
lemonchiffon: [255, 250, 205],
|
|
lightblue: [173, 216, 230],
|
|
lightcoral: [240, 128, 128],
|
|
lightcyan: [224, 255, 255],
|
|
lightgoldenrodyellow: [250, 250, 210],
|
|
lightgray: [211, 211, 211],
|
|
lightgreen: [144, 238, 144],
|
|
lightgrey: [211, 211, 211],
|
|
lightpink: [255, 182, 193],
|
|
lightsalmon: [255, 160, 122],
|
|
lightseagreen: [32, 178, 170],
|
|
lightskyblue: [135, 206, 250],
|
|
lightslategray: [119, 136, 153],
|
|
lightslategrey: [119, 136, 153],
|
|
lightsteelblue: [176, 196, 222],
|
|
lightyellow: [255, 255, 224],
|
|
lime: [0, 255, 0],
|
|
limegreen: [50, 205, 50],
|
|
linen: [250, 240, 230],
|
|
magenta: [255, 0, 255],
|
|
maroon: [128, 0, 0],
|
|
mediumaquamarine: [102, 205, 170],
|
|
mediumblue: [0, 0, 205],
|
|
mediumorchid: [186, 85, 211],
|
|
mediumpurple: [147, 112, 219],
|
|
mediumseagreen: [60, 179, 113],
|
|
mediumslateblue: [123, 104, 238],
|
|
mediumspringgreen: [0, 250, 154],
|
|
mediumturquoise: [72, 209, 204],
|
|
mediumvioletred: [199, 21, 133],
|
|
midnightblue: [25, 25, 112],
|
|
mintcream: [245, 255, 250],
|
|
mistyrose: [255, 228, 225],
|
|
moccasin: [255, 228, 181],
|
|
navajowhite: [255, 222, 173],
|
|
navy: [0, 0, 128],
|
|
oldlace: [253, 245, 230],
|
|
olive: [128, 128, 0],
|
|
olivedrab: [107, 142, 35],
|
|
orange: [255, 165, 0],
|
|
orangered: [255, 69, 0],
|
|
orchid: [218, 112, 214],
|
|
palegoldenrod: [238, 232, 170],
|
|
palegreen: [152, 251, 152],
|
|
paleturquoise: [175, 238, 238],
|
|
palevioletred: [219, 112, 147],
|
|
papayawhip: [255, 239, 213],
|
|
peachpuff: [255, 218, 185],
|
|
peru: [205, 133, 63],
|
|
pink: [255, 192, 203],
|
|
plum: [221, 160, 221],
|
|
powderblue: [176, 224, 230],
|
|
purple: [128, 0, 128],
|
|
rebeccapurple: [102, 51, 153],
|
|
red: [255, 0, 0],
|
|
rosybrown: [188, 143, 143],
|
|
royalblue: [65, 105, 225],
|
|
saddlebrown: [139, 69, 19],
|
|
salmon: [250, 128, 114],
|
|
sandybrown: [244, 164, 96],
|
|
seagreen: [46, 139, 87],
|
|
seashell: [255, 245, 238],
|
|
sienna: [160, 82, 45],
|
|
silver: [192, 192, 192],
|
|
skyblue: [135, 206, 235],
|
|
slateblue: [106, 90, 205],
|
|
slategray: [112, 128, 144],
|
|
slategrey: [112, 128, 144],
|
|
snow: [255, 250, 250],
|
|
springgreen: [0, 255, 127],
|
|
steelblue: [70, 130, 180],
|
|
tan: [210, 180, 140],
|
|
teal: [0, 128, 128],
|
|
thistle: [216, 191, 216],
|
|
tomato: [255, 99, 71],
|
|
turquoise: [64, 224, 208],
|
|
violet: [238, 130, 238],
|
|
wheat: [245, 222, 179],
|
|
white: [255, 255, 255],
|
|
whitesmoke: [245, 245, 245],
|
|
yellow: [255, 255, 0],
|
|
yellowgreen: [154, 205, 50]
|
|
},
|
|
C = {};
|
|
for (var _ in S) C[JSON.stringify(S[_])] = _
|
|
}, {}],
|
|
5: [function(t, e, n) {
|
|
var i = t(4),
|
|
a = function() {
|
|
return new u
|
|
};
|
|
for (var o in i) {
|
|
a[o + "Raw"] = function(t) {
|
|
return function(e) {
|
|
return "number" == typeof e && (e = Array.prototype.slice.call(arguments)), i[t](e)
|
|
}
|
|
}(o);
|
|
var r = /(\w+)2(\w+)/.exec(o),
|
|
l = r[1],
|
|
s = r[2];
|
|
(a[l] = a[l] || {})[s] = a[o] = function(t) {
|
|
return function(e) {
|
|
"number" == typeof e && (e = Array.prototype.slice.call(arguments));
|
|
var n = i[t](e);
|
|
if ("string" == typeof n || void 0 === n) return n;
|
|
for (var a = 0; a < n.length; a++) n[a] = Math.round(n[a]);
|
|
return n
|
|
}
|
|
}(o)
|
|
}
|
|
var u = function() {
|
|
this.convs = {}
|
|
};
|
|
u.prototype.routeSpace = function(t, e) {
|
|
var n = e[0];
|
|
return void 0 === n ? this.getValues(t) : ("number" == typeof n && (n = Array.prototype.slice.call(e)), this.setValues(t, n))
|
|
}, u.prototype.setValues = function(t, e) {
|
|
return this.space = t, this.convs = {}, this.convs[t] = e, this
|
|
}, u.prototype.getValues = function(t) {
|
|
var e = this.convs[t];
|
|
if (!e) {
|
|
var n = this.space,
|
|
i = this.convs[n];
|
|
e = a[n][t](i), this.convs[t] = e
|
|
}
|
|
return e
|
|
}, ["rgb", "hsl", "hsv", "cmyk", "keyword"].forEach(function(t) {
|
|
u.prototype[t] = function(e) {
|
|
return this.routeSpace(t, arguments)
|
|
}
|
|
}), e.exports = a
|
|
}, {
|
|
4: 4
|
|
}],
|
|
6: [function(t, e, n) {
|
|
"use strict";
|
|
e.exports = {
|
|
aliceblue: [240, 248, 255],
|
|
antiquewhite: [250, 235, 215],
|
|
aqua: [0, 255, 255],
|
|
aquamarine: [127, 255, 212],
|
|
azure: [240, 255, 255],
|
|
beige: [245, 245, 220],
|
|
bisque: [255, 228, 196],
|
|
black: [0, 0, 0],
|
|
blanchedalmond: [255, 235, 205],
|
|
blue: [0, 0, 255],
|
|
blueviolet: [138, 43, 226],
|
|
brown: [165, 42, 42],
|
|
burlywood: [222, 184, 135],
|
|
cadetblue: [95, 158, 160],
|
|
chartreuse: [127, 255, 0],
|
|
chocolate: [210, 105, 30],
|
|
coral: [255, 127, 80],
|
|
cornflowerblue: [100, 149, 237],
|
|
cornsilk: [255, 248, 220],
|
|
crimson: [220, 20, 60],
|
|
cyan: [0, 255, 255],
|
|
darkblue: [0, 0, 139],
|
|
darkcyan: [0, 139, 139],
|
|
darkgoldenrod: [184, 134, 11],
|
|
darkgray: [169, 169, 169],
|
|
darkgreen: [0, 100, 0],
|
|
darkgrey: [169, 169, 169],
|
|
darkkhaki: [189, 183, 107],
|
|
darkmagenta: [139, 0, 139],
|
|
darkolivegreen: [85, 107, 47],
|
|
darkorange: [255, 140, 0],
|
|
darkorchid: [153, 50, 204],
|
|
darkred: [139, 0, 0],
|
|
darksalmon: [233, 150, 122],
|
|
darkseagreen: [143, 188, 143],
|
|
darkslateblue: [72, 61, 139],
|
|
darkslategray: [47, 79, 79],
|
|
darkslategrey: [47, 79, 79],
|
|
darkturquoise: [0, 206, 209],
|
|
darkviolet: [148, 0, 211],
|
|
deeppink: [255, 20, 147],
|
|
deepskyblue: [0, 191, 255],
|
|
dimgray: [105, 105, 105],
|
|
dimgrey: [105, 105, 105],
|
|
dodgerblue: [30, 144, 255],
|
|
firebrick: [178, 34, 34],
|
|
floralwhite: [255, 250, 240],
|
|
forestgreen: [34, 139, 34],
|
|
fuchsia: [255, 0, 255],
|
|
gainsboro: [220, 220, 220],
|
|
ghostwhite: [248, 248, 255],
|
|
gold: [255, 215, 0],
|
|
goldenrod: [218, 165, 32],
|
|
gray: [128, 128, 128],
|
|
green: [0, 128, 0],
|
|
greenyellow: [173, 255, 47],
|
|
grey: [128, 128, 128],
|
|
honeydew: [240, 255, 240],
|
|
hotpink: [255, 105, 180],
|
|
indianred: [205, 92, 92],
|
|
indigo: [75, 0, 130],
|
|
ivory: [255, 255, 240],
|
|
khaki: [240, 230, 140],
|
|
lavender: [230, 230, 250],
|
|
lavenderblush: [255, 240, 245],
|
|
lawngreen: [124, 252, 0],
|
|
lemonchiffon: [255, 250, 205],
|
|
lightblue: [173, 216, 230],
|
|
lightcoral: [240, 128, 128],
|
|
lightcyan: [224, 255, 255],
|
|
lightgoldenrodyellow: [250, 250, 210],
|
|
lightgray: [211, 211, 211],
|
|
lightgreen: [144, 238, 144],
|
|
lightgrey: [211, 211, 211],
|
|
lightpink: [255, 182, 193],
|
|
lightsalmon: [255, 160, 122],
|
|
lightseagreen: [32, 178, 170],
|
|
lightskyblue: [135, 206, 250],
|
|
lightslategray: [119, 136, 153],
|
|
lightslategrey: [119, 136, 153],
|
|
lightsteelblue: [176, 196, 222],
|
|
lightyellow: [255, 255, 224],
|
|
lime: [0, 255, 0],
|
|
limegreen: [50, 205, 50],
|
|
linen: [250, 240, 230],
|
|
magenta: [255, 0, 255],
|
|
maroon: [128, 0, 0],
|
|
mediumaquamarine: [102, 205, 170],
|
|
mediumblue: [0, 0, 205],
|
|
mediumorchid: [186, 85, 211],
|
|
mediumpurple: [147, 112, 219],
|
|
mediumseagreen: [60, 179, 113],
|
|
mediumslateblue: [123, 104, 238],
|
|
mediumspringgreen: [0, 250, 154],
|
|
mediumturquoise: [72, 209, 204],
|
|
mediumvioletred: [199, 21, 133],
|
|
midnightblue: [25, 25, 112],
|
|
mintcream: [245, 255, 250],
|
|
mistyrose: [255, 228, 225],
|
|
moccasin: [255, 228, 181],
|
|
navajowhite: [255, 222, 173],
|
|
navy: [0, 0, 128],
|
|
oldlace: [253, 245, 230],
|
|
olive: [128, 128, 0],
|
|
olivedrab: [107, 142, 35],
|
|
orange: [255, 165, 0],
|
|
orangered: [255, 69, 0],
|
|
orchid: [218, 112, 214],
|
|
palegoldenrod: [238, 232, 170],
|
|
palegreen: [152, 251, 152],
|
|
paleturquoise: [175, 238, 238],
|
|
palevioletred: [219, 112, 147],
|
|
papayawhip: [255, 239, 213],
|
|
peachpuff: [255, 218, 185],
|
|
peru: [205, 133, 63],
|
|
pink: [255, 192, 203],
|
|
plum: [221, 160, 221],
|
|
powderblue: [176, 224, 230],
|
|
purple: [128, 0, 128],
|
|
rebeccapurple: [102, 51, 153],
|
|
red: [255, 0, 0],
|
|
rosybrown: [188, 143, 143],
|
|
royalblue: [65, 105, 225],
|
|
saddlebrown: [139, 69, 19],
|
|
salmon: [250, 128, 114],
|
|
sandybrown: [244, 164, 96],
|
|
seagreen: [46, 139, 87],
|
|
seashell: [255, 245, 238],
|
|
sienna: [160, 82, 45],
|
|
silver: [192, 192, 192],
|
|
skyblue: [135, 206, 235],
|
|
slateblue: [106, 90, 205],
|
|
slategray: [112, 128, 144],
|
|
slategrey: [112, 128, 144],
|
|
snow: [255, 250, 250],
|
|
springgreen: [0, 255, 127],
|
|
steelblue: [70, 130, 180],
|
|
tan: [210, 180, 140],
|
|
teal: [0, 128, 128],
|
|
thistle: [216, 191, 216],
|
|
tomato: [255, 99, 71],
|
|
turquoise: [64, 224, 208],
|
|
violet: [238, 130, 238],
|
|
wheat: [245, 222, 179],
|
|
white: [255, 255, 255],
|
|
whitesmoke: [245, 245, 245],
|
|
yellow: [255, 255, 0],
|
|
yellowgreen: [154, 205, 50]
|
|
}
|
|
}, {}],
|
|
7: [function(t, e, n) {
|
|
var i = t(29)();
|
|
i.helpers = t(45), t(27)(i), i.defaults = t(25), i.Element = t(26), i.elements = t(40), i.Interaction = t(28), i.platform = t(48), t(31)(i), t(22)(i), t(23)(i), t(24)(i), t(30)(i), t(33)(i), t(32)(i), t(35)(i), t(54)(i), t(52)(i), t(53)(i), t(55)(i), t(56)(i), t(57)(i), t(15)(i), t(16)(i), t(17)(i), t(18)(i), t(19)(i), t(20)(i), t(21)(i), t(8)(i), t(9)(i), t(10)(i), t(11)(i), t(12)(i), t(13)(i), t(14)(i);
|
|
var a = [];
|
|
a.push(t(49)(i), t(50)(i), t(51)(i)), i.plugins.register(a), i.platform.initialize(), e.exports = i, "undefined" != typeof window && (window.Chart = i), i.canvasHelpers = i.helpers.canvas
|
|
}, {
|
|
10: 10,
|
|
11: 11,
|
|
12: 12,
|
|
13: 13,
|
|
14: 14,
|
|
15: 15,
|
|
16: 16,
|
|
17: 17,
|
|
18: 18,
|
|
19: 19,
|
|
20: 20,
|
|
21: 21,
|
|
22: 22,
|
|
23: 23,
|
|
24: 24,
|
|
25: 25,
|
|
26: 26,
|
|
27: 27,
|
|
28: 28,
|
|
29: 29,
|
|
30: 30,
|
|
31: 31,
|
|
32: 32,
|
|
33: 33,
|
|
35: 35,
|
|
40: 40,
|
|
45: 45,
|
|
48: 48,
|
|
49: 49,
|
|
50: 50,
|
|
51: 51,
|
|
52: 52,
|
|
53: 53,
|
|
54: 54,
|
|
55: 55,
|
|
56: 56,
|
|
57: 57,
|
|
8: 8,
|
|
9: 9
|
|
}],
|
|
8: [function(t, e, n) {
|
|
"use strict";
|
|
e.exports = function(t) {
|
|
t.Bar = function(e, n) {
|
|
return n.type = "bar", new t(e, n)
|
|
}
|
|
}
|
|
}, {}],
|
|
9: [function(t, e, n) {
|
|
"use strict";
|
|
e.exports = function(t) {
|
|
t.Bubble = function(e, n) {
|
|
return n.type = "bubble", new t(e, n)
|
|
}
|
|
}
|
|
}, {}],
|
|
10: [function(t, e, n) {
|
|
"use strict";
|
|
e.exports = function(t) {
|
|
t.Doughnut = function(e, n) {
|
|
return n.type = "doughnut", new t(e, n)
|
|
}
|
|
}
|
|
}, {}],
|
|
11: [function(t, e, n) {
|
|
"use strict";
|
|
e.exports = function(t) {
|
|
t.Line = function(e, n) {
|
|
return n.type = "line", new t(e, n)
|
|
}
|
|
}
|
|
}, {}],
|
|
12: [function(t, e, n) {
|
|
"use strict";
|
|
e.exports = function(t) {
|
|
t.PolarArea = function(e, n) {
|
|
return n.type = "polarArea", new t(e, n)
|
|
}
|
|
}
|
|
}, {}],
|
|
13: [function(t, e, n) {
|
|
"use strict";
|
|
e.exports = function(t) {
|
|
t.Radar = function(e, n) {
|
|
return n.type = "radar", new t(e, n)
|
|
}
|
|
}
|
|
}, {}],
|
|
14: [function(t, e, n) {
|
|
"use strict";
|
|
e.exports = function(t) {
|
|
t.Scatter = function(e, n) {
|
|
return n.type = "scatter", new t(e, n)
|
|
}
|
|
}
|
|
}, {}],
|
|
15: [function(t, e, n) {
|
|
"use strict";
|
|
var i = t(25),
|
|
a = t(40),
|
|
o = t(45);
|
|
i._set("bar", {
|
|
hover: {
|
|
mode: "label"
|
|
},
|
|
scales: {
|
|
xAxes: [{
|
|
type: "category",
|
|
categoryPercentage: .8,
|
|
barPercentage: .9,
|
|
offset: !0,
|
|
gridLines: {
|
|
offsetGridLines: !0
|
|
}
|
|
}],
|
|
yAxes: [{
|
|
type: "linear"
|
|
}]
|
|
}
|
|
}), i._set("horizontalBar", {
|
|
hover: {
|
|
mode: "index",
|
|
axis: "y"
|
|
},
|
|
scales: {
|
|
xAxes: [{
|
|
type: "linear",
|
|
position: "bottom"
|
|
}],
|
|
yAxes: [{
|
|
position: "left",
|
|
type: "category",
|
|
categoryPercentage: .8,
|
|
barPercentage: .9,
|
|
offset: !0,
|
|
gridLines: {
|
|
offsetGridLines: !0
|
|
}
|
|
}]
|
|
},
|
|
elements: {
|
|
rectangle: {
|
|
borderSkipped: "left"
|
|
}
|
|
},
|
|
tooltips: {
|
|
callbacks: {
|
|
title: function(t, e) {
|
|
var n = "";
|
|
return t.length > 0 && (t[0].yLabel ? n = t[0].yLabel : e.labels.length > 0 && t[0].index < e.labels.length && (n = e.labels[t[0].index])), n
|
|
},
|
|
label: function(t, e) {
|
|
return (e.datasets[t.datasetIndex].label || "") + ": " + t.xLabel
|
|
}
|
|
},
|
|
mode: "index",
|
|
axis: "y"
|
|
}
|
|
}), e.exports = function(t) {
|
|
t.controllers.bar = t.DatasetController.extend({
|
|
dataElementType: a.Rectangle,
|
|
initialize: function() {
|
|
var e, n = this;
|
|
t.DatasetController.prototype.initialize.apply(n, arguments), (e = n.getMeta()).stack = n.getDataset().stack, e.bar = !0
|
|
},
|
|
update: function(t) {
|
|
var e, n, i = this,
|
|
a = i.getMeta().data;
|
|
for (i._ruler = i.getRuler(), e = 0, n = a.length; e < n; ++e) i.updateElement(a[e], e, t)
|
|
},
|
|
updateElement: function(t, e, n) {
|
|
var i = this,
|
|
a = i.chart,
|
|
r = i.getMeta(),
|
|
l = i.getDataset(),
|
|
s = t.custom || {},
|
|
u = a.options.elements.rectangle;
|
|
t._xScale = i.getScaleForId(r.xAxisID), t._yScale = i.getScaleForId(r.yAxisID), t._datasetIndex = i.index, t._index = e, t._model = {
|
|
datasetLabel: l.label,
|
|
label: a.data.labels[e],
|
|
borderSkipped: s.borderSkipped ? s.borderSkipped : u.borderSkipped,
|
|
backgroundColor: s.backgroundColor ? s.backgroundColor : o.valueAtIndexOrDefault(l.backgroundColor, e, u.backgroundColor),
|
|
borderColor: s.borderColor ? s.borderColor : o.valueAtIndexOrDefault(l.borderColor, e, u.borderColor),
|
|
borderWidth: s.borderWidth ? s.borderWidth : o.valueAtIndexOrDefault(l.borderWidth, e, u.borderWidth)
|
|
}, i.updateElementGeometry(t, e, n), t.pivot()
|
|
},
|
|
updateElementGeometry: function(t, e, n) {
|
|
var i = this,
|
|
a = t._model,
|
|
o = i.getValueScale(),
|
|
r = o.getBasePixel(),
|
|
l = o.isHorizontal(),
|
|
s = i._ruler || i.getRuler(),
|
|
u = i.calculateBarValuePixels(i.index, e),
|
|
d = i.calculateBarIndexPixels(i.index, e, s);
|
|
a.horizontal = l, a.base = n ? r : u.base, a.x = l ? n ? r : u.head : d.center, a.y = l ? d.center : n ? r : u.head, a.height = l ? d.size : void 0, a.width = l ? void 0 : d.size
|
|
},
|
|
getValueScaleId: function() {
|
|
return this.getMeta().yAxisID
|
|
},
|
|
getIndexScaleId: function() {
|
|
return this.getMeta().xAxisID
|
|
},
|
|
getValueScale: function() {
|
|
return this.getScaleForId(this.getValueScaleId())
|
|
},
|
|
getIndexScale: function() {
|
|
return this.getScaleForId(this.getIndexScaleId())
|
|
},
|
|
getStackCount: function(t) {
|
|
var e, n, i = this,
|
|
a = i.chart,
|
|
o = i.getIndexScale().options.stacked,
|
|
r = void 0 === t ? a.data.datasets.length : t + 1,
|
|
l = [];
|
|
for (e = 0; e < r; ++e)(n = a.getDatasetMeta(e)).bar && a.isDatasetVisible(e) && (!1 === o || !0 === o && -1 === l.indexOf(n.stack) || void 0 === o && (void 0 === n.stack || -1 === l.indexOf(n.stack))) && l.push(n.stack);
|
|
return l.length
|
|
},
|
|
getStackIndex: function(t) {
|
|
return this.getStackCount(t) - 1
|
|
},
|
|
getRuler: function() {
|
|
var t, e, n = this,
|
|
i = n.getIndexScale(),
|
|
a = n.getStackCount(),
|
|
o = n.index,
|
|
r = [],
|
|
l = i.isHorizontal(),
|
|
s = l ? i.left : i.top,
|
|
u = s + (l ? i.width : i.height);
|
|
for (t = 0, e = n.getMeta().data.length; t < e; ++t) r.push(i.getPixelForValue(null, t, o));
|
|
return {
|
|
pixels: r,
|
|
start: s,
|
|
end: u,
|
|
stackCount: a,
|
|
scale: i
|
|
}
|
|
},
|
|
calculateBarValuePixels: function(t, e) {
|
|
var n, i, a, o, r, l, s = this,
|
|
u = s.chart,
|
|
d = s.getMeta(),
|
|
c = s.getValueScale(),
|
|
h = u.data.datasets,
|
|
f = c.getRightValue(h[t].data[e]),
|
|
g = c.options.stacked,
|
|
p = d.stack,
|
|
v = 0;
|
|
if (g || void 0 === g && void 0 !== p)
|
|
for (n = 0; n < t; ++n)(i = u.getDatasetMeta(n)).bar && i.stack === p && i.controller.getValueScaleId() === c.id && u.isDatasetVisible(n) && (a = c.getRightValue(h[n].data[e]), (f < 0 && a < 0 || f >= 0 && a > 0) && (v += a));
|
|
return o = c.getPixelForValue(v), r = c.getPixelForValue(v + f), l = (r - o) / 2, {
|
|
size: l,
|
|
base: o,
|
|
head: r,
|
|
center: r + l / 2
|
|
}
|
|
},
|
|
calculateBarIndexPixels: function(t, e, n) {
|
|
var i, a, r, l, s, u, d = this,
|
|
c = n.scale.options,
|
|
h = d.getStackIndex(t),
|
|
f = n.pixels,
|
|
g = f[e],
|
|
p = f.length,
|
|
v = n.start,
|
|
m = n.end;
|
|
return 1 === p ? (i = g > v ? g - v : m - g, a = g < m ? m - g : g - v) : (e > 0 && (i = (g - f[e - 1]) / 2, e === p - 1 && (a = i)), e < p - 1 && (a = (f[e + 1] - g) / 2, 0 === e && (i = a))), r = i * c.categoryPercentage, l = a * c.categoryPercentage, s = (r + l) / n.stackCount, u = s * c.barPercentage, u = Math.min(o.valueOrDefault(c.barThickness, u), o.valueOrDefault(c.maxBarThickness, 1 / 0)), g -= r, g += s * h, g += (s - u) / 2, {
|
|
size: u,
|
|
base: g,
|
|
head: g + u,
|
|
center: g + u / 2
|
|
}
|
|
},
|
|
draw: function() {
|
|
var t = this,
|
|
e = t.chart,
|
|
n = t.getValueScale(),
|
|
i = t.getMeta().data,
|
|
a = t.getDataset(),
|
|
r = i.length,
|
|
l = 0;
|
|
for (o.canvas.clipArea(e.ctx, e.chartArea); l < r; ++l) isNaN(n.getRightValue(a.data[l])) || i[l].draw();
|
|
o.canvas.unclipArea(e.ctx)
|
|
},
|
|
setHoverStyle: function(t) {
|
|
var e = this.chart.data.datasets[t._datasetIndex],
|
|
n = t._index,
|
|
i = t.custom || {},
|
|
a = t._model;
|
|
a.backgroundColor = i.hoverBackgroundColor ? i.hoverBackgroundColor : o.valueAtIndexOrDefault(e.hoverBackgroundColor, n, o.getHoverColor(a.backgroundColor)), a.borderColor = i.hoverBorderColor ? i.hoverBorderColor : o.valueAtIndexOrDefault(e.hoverBorderColor, n, o.getHoverColor(a.borderColor)), a.borderWidth = i.hoverBorderWidth ? i.hoverBorderWidth : o.valueAtIndexOrDefault(e.hoverBorderWidth, n, a.borderWidth)
|
|
},
|
|
removeHoverStyle: function(t) {
|
|
var e = this.chart.data.datasets[t._datasetIndex],
|
|
n = t._index,
|
|
i = t.custom || {},
|
|
a = t._model,
|
|
r = this.chart.options.elements.rectangle;
|
|
a.backgroundColor = i.backgroundColor ? i.backgroundColor : o.valueAtIndexOrDefault(e.backgroundColor, n, r.backgroundColor), a.borderColor = i.borderColor ? i.borderColor : o.valueAtIndexOrDefault(e.borderColor, n, r.borderColor), a.borderWidth = i.borderWidth ? i.borderWidth : o.valueAtIndexOrDefault(e.borderWidth, n, r.borderWidth)
|
|
}
|
|
}), t.controllers.horizontalBar = t.controllers.bar.extend({
|
|
getValueScaleId: function() {
|
|
return this.getMeta().xAxisID
|
|
},
|
|
getIndexScaleId: function() {
|
|
return this.getMeta().yAxisID
|
|
}
|
|
})
|
|
}
|
|
}, {
|
|
25: 25,
|
|
40: 40,
|
|
45: 45
|
|
}],
|
|
16: [function(t, e, n) {
|
|
"use strict";
|
|
var i = t(25),
|
|
a = t(40),
|
|
o = t(45);
|
|
i._set("bubble", {
|
|
hover: {
|
|
mode: "single"
|
|
},
|
|
scales: {
|
|
xAxes: [{
|
|
type: "linear",
|
|
position: "bottom",
|
|
id: "x-axis-0"
|
|
}],
|
|
yAxes: [{
|
|
type: "linear",
|
|
position: "left",
|
|
id: "y-axis-0"
|
|
}]
|
|
},
|
|
tooltips: {
|
|
callbacks: {
|
|
title: function() {
|
|
return ""
|
|
},
|
|
label: function(t, e) {
|
|
var n = e.datasets[t.datasetIndex].label || "",
|
|
i = e.datasets[t.datasetIndex].data[t.index];
|
|
return n + ": (" + t.xLabel + ", " + t.yLabel + ", " + i.r + ")"
|
|
}
|
|
}
|
|
}
|
|
}), e.exports = function(t) {
|
|
t.controllers.bubble = t.DatasetController.extend({
|
|
dataElementType: a.Point,
|
|
update: function(t) {
|
|
var e = this,
|
|
n = e.getMeta().data;
|
|
o.each(n, function(n, i) {
|
|
e.updateElement(n, i, t)
|
|
})
|
|
},
|
|
updateElement: function(t, e, n) {
|
|
var i = this,
|
|
a = i.getMeta(),
|
|
o = t.custom || {},
|
|
r = i.getScaleForId(a.xAxisID),
|
|
l = i.getScaleForId(a.yAxisID),
|
|
s = i._resolveElementOptions(t, e),
|
|
u = i.getDataset().data[e],
|
|
d = i.index,
|
|
c = n ? r.getPixelForDecimal(.5) : r.getPixelForValue("object" == typeof u ? u : NaN, e, d),
|
|
h = n ? l.getBasePixel() : l.getPixelForValue(u, e, d);
|
|
t._xScale = r, t._yScale = l, t._options = s, t._datasetIndex = d, t._index = e, t._model = {
|
|
backgroundColor: s.backgroundColor,
|
|
borderColor: s.borderColor,
|
|
borderWidth: s.borderWidth,
|
|
hitRadius: s.hitRadius,
|
|
pointStyle: s.pointStyle,
|
|
radius: n ? 0 : s.radius,
|
|
skip: o.skip || isNaN(c) || isNaN(h),
|
|
x: c,
|
|
y: h
|
|
}, t.pivot()
|
|
},
|
|
setHoverStyle: function(t) {
|
|
var e = t._model,
|
|
n = t._options;
|
|
e.backgroundColor = o.valueOrDefault(n.hoverBackgroundColor, o.getHoverColor(n.backgroundColor)), e.borderColor = o.valueOrDefault(n.hoverBorderColor, o.getHoverColor(n.borderColor)), e.borderWidth = o.valueOrDefault(n.hoverBorderWidth, n.borderWidth), e.radius = n.radius + n.hoverRadius
|
|
},
|
|
removeHoverStyle: function(t) {
|
|
var e = t._model,
|
|
n = t._options;
|
|
e.backgroundColor = n.backgroundColor, e.borderColor = n.borderColor, e.borderWidth = n.borderWidth, e.radius = n.radius
|
|
},
|
|
_resolveElementOptions: function(t, e) {
|
|
var n, i, a, r = this,
|
|
l = r.chart,
|
|
s = l.data.datasets[r.index],
|
|
u = t.custom || {},
|
|
d = l.options.elements.point,
|
|
c = o.options.resolve,
|
|
h = s.data[e],
|
|
f = {},
|
|
g = {
|
|
chart: l,
|
|
dataIndex: e,
|
|
dataset: s,
|
|
datasetIndex: r.index
|
|
},
|
|
p = ["backgroundColor", "borderColor", "borderWidth", "hoverBackgroundColor", "hoverBorderColor", "hoverBorderWidth", "hoverRadius", "hitRadius", "pointStyle"];
|
|
for (n = 0, i = p.length; n < i; ++n) f[a = p[n]] = c([u[a], s[a], d[a]], g, e);
|
|
return f.radius = c([u.radius, h ? h.r : void 0, s.radius, d.radius], g, e), f
|
|
}
|
|
})
|
|
}
|
|
}, {
|
|
25: 25,
|
|
40: 40,
|
|
45: 45
|
|
}],
|
|
17: [function(t, e, n) {
|
|
"use strict";
|
|
var i = t(25),
|
|
a = t(40),
|
|
o = t(45);
|
|
i._set("doughnut", {
|
|
animation: {
|
|
animateRotate: !0,
|
|
animateScale: !1
|
|
},
|
|
hover: {
|
|
mode: "single"
|
|
},
|
|
legendCallback: function(t) {
|
|
var e = [];
|
|
e.push('<ul class="' + t.id + '-legend">');
|
|
var n = t.data,
|
|
i = n.datasets,
|
|
a = n.labels;
|
|
if (i.length)
|
|
for (var o = 0; o < i[0].data.length; ++o) e.push('<li><span style="background-color:' + i[0].backgroundColor[o] + '"></span>'), a[o] && e.push(a[o]), e.push("</li>");
|
|
return e.push("</ul>"), e.join("")
|
|
},
|
|
legend: {
|
|
labels: {
|
|
generateLabels: function(t) {
|
|
var e = t.data;
|
|
return e.labels.length && e.datasets.length ? e.labels.map(function(n, i) {
|
|
var a = t.getDatasetMeta(0),
|
|
r = e.datasets[0],
|
|
l = a.data[i],
|
|
s = l && l.custom || {},
|
|
u = o.valueAtIndexOrDefault,
|
|
d = t.options.elements.arc;
|
|
return {
|
|
text: n,
|
|
fillStyle: s.backgroundColor ? s.backgroundColor : u(r.backgroundColor, i, d.backgroundColor),
|
|
strokeStyle: s.borderColor ? s.borderColor : u(r.borderColor, i, d.borderColor),
|
|
lineWidth: s.borderWidth ? s.borderWidth : u(r.borderWidth, i, d.borderWidth),
|
|
hidden: isNaN(r.data[i]) || a.data[i].hidden,
|
|
index: i
|
|
}
|
|
}) : []
|
|
}
|
|
},
|
|
onClick: function(t, e) {
|
|
var n, i, a, o = e.index,
|
|
r = this.chart;
|
|
for (n = 0, i = (r.data.datasets || []).length; n < i; ++n)(a = r.getDatasetMeta(n)).data[o] && (a.data[o].hidden = !a.data[o].hidden);
|
|
r.update()
|
|
}
|
|
},
|
|
cutoutPercentage: 50,
|
|
rotation: -.5 * Math.PI,
|
|
circumference: 2 * Math.PI,
|
|
tooltips: {
|
|
callbacks: {
|
|
title: function() {
|
|
return ""
|
|
},
|
|
label: function(t, e) {
|
|
var n = e.labels[t.index],
|
|
i = ": " + e.datasets[t.datasetIndex].data[t.index];
|
|
return o.isArray(n) ? (n = n.slice())[0] += i : n += i, n
|
|
}
|
|
}
|
|
}
|
|
}), i._set("pie", o.clone(i.doughnut)), i._set("pie", {
|
|
cutoutPercentage: 0
|
|
}), e.exports = function(t) {
|
|
t.controllers.doughnut = t.controllers.pie = t.DatasetController.extend({
|
|
dataElementType: a.Arc,
|
|
linkScales: o.noop,
|
|
getRingIndex: function(t) {
|
|
for (var e = 0, n = 0; n < t; ++n) this.chart.isDatasetVisible(n) && ++e;
|
|
return e
|
|
},
|
|
update: function(t) {
|
|
var e = this,
|
|
n = e.chart,
|
|
i = n.chartArea,
|
|
a = n.options,
|
|
r = a.elements.arc,
|
|
l = i.right - i.left - r.borderWidth,
|
|
s = i.bottom - i.top - r.borderWidth,
|
|
u = Math.min(l, s),
|
|
d = {
|
|
x: 0,
|
|
y: 0
|
|
},
|
|
c = e.getMeta(),
|
|
h = a.cutoutPercentage,
|
|
f = a.circumference;
|
|
if (f < 2 * Math.PI) {
|
|
var g = a.rotation % (2 * Math.PI),
|
|
p = (g += 2 * Math.PI * (g >= Math.PI ? -1 : g < -Math.PI ? 1 : 0)) + f,
|
|
v = {
|
|
x: Math.cos(g),
|
|
y: Math.sin(g)
|
|
},
|
|
m = {
|
|
x: Math.cos(p),
|
|
y: Math.sin(p)
|
|
},
|
|
b = g <= 0 && p >= 0 || g <= 2 * Math.PI && 2 * Math.PI <= p,
|
|
x = g <= .5 * Math.PI && .5 * Math.PI <= p || g <= 2.5 * Math.PI && 2.5 * Math.PI <= p,
|
|
y = g <= -Math.PI && -Math.PI <= p || g <= Math.PI && Math.PI <= p,
|
|
k = g <= .5 * -Math.PI && .5 * -Math.PI <= p || g <= 1.5 * Math.PI && 1.5 * Math.PI <= p,
|
|
w = h / 100,
|
|
M = {
|
|
x: y ? -1 : Math.min(v.x * (v.x < 0 ? 1 : w), m.x * (m.x < 0 ? 1 : w)),
|
|
y: k ? -1 : Math.min(v.y * (v.y < 0 ? 1 : w), m.y * (m.y < 0 ? 1 : w))
|
|
},
|
|
S = {
|
|
x: b ? 1 : Math.max(v.x * (v.x > 0 ? 1 : w), m.x * (m.x > 0 ? 1 : w)),
|
|
y: x ? 1 : Math.max(v.y * (v.y > 0 ? 1 : w), m.y * (m.y > 0 ? 1 : w))
|
|
},
|
|
C = {
|
|
width: .5 * (S.x - M.x),
|
|
height: .5 * (S.y - M.y)
|
|
};
|
|
u = Math.min(l / C.width, s / C.height), d = {
|
|
x: -.5 * (S.x + M.x),
|
|
y: -.5 * (S.y + M.y)
|
|
}
|
|
}
|
|
n.borderWidth = e.getMaxBorderWidth(c.data), n.outerRadius = Math.max((u - n.borderWidth) / 2, 0), n.innerRadius = Math.max(h ? n.outerRadius / 100 * h : 0, 0), n.radiusLength = (n.outerRadius - n.innerRadius) / n.getVisibleDatasetCount(), n.offsetX = d.x * n.outerRadius, n.offsetY = d.y * n.outerRadius, c.total = e.calculateTotal(), e.outerRadius = n.outerRadius - n.radiusLength * e.getRingIndex(e.index), e.innerRadius = Math.max(e.outerRadius - n.radiusLength, 0), o.each(c.data, function(n, i) {
|
|
e.updateElement(n, i, t)
|
|
})
|
|
},
|
|
updateElement: function(t, e, n) {
|
|
var i = this,
|
|
a = i.chart,
|
|
r = a.chartArea,
|
|
l = a.options,
|
|
s = l.animation,
|
|
u = (r.left + r.right) / 2,
|
|
d = (r.top + r.bottom) / 2,
|
|
c = l.rotation,
|
|
h = l.rotation,
|
|
f = i.getDataset(),
|
|
g = n && s.animateRotate ? 0 : t.hidden ? 0 : i.calculateCircumference(f.data[e]) * (l.circumference / (2 * Math.PI)),
|
|
p = n && s.animateScale ? 0 : i.innerRadius,
|
|
v = n && s.animateScale ? 0 : i.outerRadius,
|
|
m = o.valueAtIndexOrDefault;
|
|
o.extend(t, {
|
|
_datasetIndex: i.index,
|
|
_index: e,
|
|
_model: {
|
|
x: u + a.offsetX,
|
|
y: d + a.offsetY,
|
|
startAngle: c,
|
|
endAngle: h,
|
|
circumference: g,
|
|
outerRadius: v,
|
|
innerRadius: p,
|
|
label: m(f.label, e, a.data.labels[e])
|
|
}
|
|
});
|
|
var b = t._model;
|
|
this.removeHoverStyle(t), n && s.animateRotate || (b.startAngle = 0 === e ? l.rotation : i.getMeta().data[e - 1]._model.endAngle, b.endAngle = b.startAngle + b.circumference), t.pivot()
|
|
},
|
|
removeHoverStyle: function(e) {
|
|
t.DatasetController.prototype.removeHoverStyle.call(this, e, this.chart.options.elements.arc)
|
|
},
|
|
calculateTotal: function() {
|
|
var t, e = this.getDataset(),
|
|
n = this.getMeta(),
|
|
i = 0;
|
|
return o.each(n.data, function(n, a) {
|
|
t = e.data[a], isNaN(t) || n.hidden || (i += Math.abs(t))
|
|
}), i
|
|
},
|
|
calculateCircumference: function(t) {
|
|
var e = this.getMeta().total;
|
|
return e > 0 && !isNaN(t) ? 2 * Math.PI * (t / e) : 0
|
|
},
|
|
getMaxBorderWidth: function(t) {
|
|
for (var e, n, i = 0, a = this.index, o = t.length, r = 0; r < o; r++) e = t[r]._model ? t[r]._model.borderWidth : 0, i = (n = t[r]._chart ? t[r]._chart.config.data.datasets[a].hoverBorderWidth : 0) > (i = e > i ? e : i) ? n : i;
|
|
return i
|
|
}
|
|
})
|
|
}
|
|
}, {
|
|
25: 25,
|
|
40: 40,
|
|
45: 45
|
|
}],
|
|
18: [function(t, e, n) {
|
|
"use strict";
|
|
var i = t(25),
|
|
a = t(40),
|
|
o = t(45);
|
|
i._set("line", {
|
|
showLines: !0,
|
|
spanGaps: !1,
|
|
hover: {
|
|
mode: "label"
|
|
},
|
|
scales: {
|
|
xAxes: [{
|
|
type: "category",
|
|
id: "x-axis-0"
|
|
}],
|
|
yAxes: [{
|
|
type: "linear",
|
|
id: "y-axis-0"
|
|
}]
|
|
}
|
|
}), e.exports = function(t) {
|
|
function e(t, e) {
|
|
return o.valueOrDefault(t.showLine, e.showLines)
|
|
}
|
|
t.controllers.line = t.DatasetController.extend({
|
|
datasetElementType: a.Line,
|
|
dataElementType: a.Point,
|
|
update: function(t) {
|
|
var n, i, a, r = this,
|
|
l = r.getMeta(),
|
|
s = l.dataset,
|
|
u = l.data || [],
|
|
d = r.chart.options,
|
|
c = d.elements.line,
|
|
h = r.getScaleForId(l.yAxisID),
|
|
f = r.getDataset(),
|
|
g = e(f, d);
|
|
for (g && (a = s.custom || {}, void 0 !== f.tension && void 0 === f.lineTension && (f.lineTension = f.tension), s._scale = h, s._datasetIndex = r.index, s._children = u, s._model = {
|
|
spanGaps: f.spanGaps ? f.spanGaps : d.spanGaps,
|
|
tension: a.tension ? a.tension : o.valueOrDefault(f.lineTension, c.tension),
|
|
backgroundColor: a.backgroundColor ? a.backgroundColor : f.backgroundColor || c.backgroundColor,
|
|
borderWidth: a.borderWidth ? a.borderWidth : f.borderWidth || c.borderWidth,
|
|
borderColor: a.borderColor ? a.borderColor : f.borderColor || c.borderColor,
|
|
borderCapStyle: a.borderCapStyle ? a.borderCapStyle : f.borderCapStyle || c.borderCapStyle,
|
|
borderDash: a.borderDash ? a.borderDash : f.borderDash || c.borderDash,
|
|
borderDashOffset: a.borderDashOffset ? a.borderDashOffset : f.borderDashOffset || c.borderDashOffset,
|
|
borderJoinStyle: a.borderJoinStyle ? a.borderJoinStyle : f.borderJoinStyle || c.borderJoinStyle,
|
|
fill: a.fill ? a.fill : void 0 !== f.fill ? f.fill : c.fill,
|
|
steppedLine: a.steppedLine ? a.steppedLine : o.valueOrDefault(f.steppedLine, c.stepped),
|
|
cubicInterpolationMode: a.cubicInterpolationMode ? a.cubicInterpolationMode : o.valueOrDefault(f.cubicInterpolationMode, c.cubicInterpolationMode)
|
|
}, s.pivot()), n = 0, i = u.length; n < i; ++n) r.updateElement(u[n], n, t);
|
|
for (g && 0 !== s._model.tension && r.updateBezierControlPoints(), n = 0, i = u.length; n < i; ++n) u[n].pivot()
|
|
},
|
|
getPointBackgroundColor: function(t, e) {
|
|
var n = this.chart.options.elements.point.backgroundColor,
|
|
i = this.getDataset(),
|
|
a = t.custom || {};
|
|
return a.backgroundColor ? n = a.backgroundColor : i.pointBackgroundColor ? n = o.valueAtIndexOrDefault(i.pointBackgroundColor, e, n) : i.backgroundColor && (n = i.backgroundColor), n
|
|
},
|
|
getPointBorderColor: function(t, e) {
|
|
var n = this.chart.options.elements.point.borderColor,
|
|
i = this.getDataset(),
|
|
a = t.custom || {};
|
|
return a.borderColor ? n = a.borderColor : i.pointBorderColor ? n = o.valueAtIndexOrDefault(i.pointBorderColor, e, n) : i.borderColor && (n = i.borderColor), n
|
|
},
|
|
getPointBorderWidth: function(t, e) {
|
|
var n = this.chart.options.elements.point.borderWidth,
|
|
i = this.getDataset(),
|
|
a = t.custom || {};
|
|
return isNaN(a.borderWidth) ? !isNaN(i.pointBorderWidth) || o.isArray(i.pointBorderWidth) ? n = o.valueAtIndexOrDefault(i.pointBorderWidth, e, n) : isNaN(i.borderWidth) || (n = i.borderWidth) : n = a.borderWidth, n
|
|
},
|
|
updateElement: function(t, e, n) {
|
|
var i, a, r = this,
|
|
l = r.getMeta(),
|
|
s = t.custom || {},
|
|
u = r.getDataset(),
|
|
d = r.index,
|
|
c = u.data[e],
|
|
h = r.getScaleForId(l.yAxisID),
|
|
f = r.getScaleForId(l.xAxisID),
|
|
g = r.chart.options.elements.point;
|
|
void 0 !== u.radius && void 0 === u.pointRadius && (u.pointRadius = u.radius), void 0 !== u.hitRadius && void 0 === u.pointHitRadius && (u.pointHitRadius = u.hitRadius), i = f.getPixelForValue("object" == typeof c ? c : NaN, e, d), a = n ? h.getBasePixel() : r.calculatePointY(c, e, d), t._xScale = f, t._yScale = h, t._datasetIndex = d, t._index = e, t._model = {
|
|
x: i,
|
|
y: a,
|
|
skip: s.skip || isNaN(i) || isNaN(a),
|
|
radius: s.radius || o.valueAtIndexOrDefault(u.pointRadius, e, g.radius),
|
|
pointStyle: s.pointStyle || o.valueAtIndexOrDefault(u.pointStyle, e, g.pointStyle),
|
|
backgroundColor: r.getPointBackgroundColor(t, e),
|
|
borderColor: r.getPointBorderColor(t, e),
|
|
borderWidth: r.getPointBorderWidth(t, e),
|
|
tension: l.dataset._model ? l.dataset._model.tension : 0,
|
|
steppedLine: !!l.dataset._model && l.dataset._model.steppedLine,
|
|
hitRadius: s.hitRadius || o.valueAtIndexOrDefault(u.pointHitRadius, e, g.hitRadius)
|
|
}
|
|
},
|
|
calculatePointY: function(t, e, n) {
|
|
var i, a, o, r = this,
|
|
l = r.chart,
|
|
s = r.getMeta(),
|
|
u = r.getScaleForId(s.yAxisID),
|
|
d = 0,
|
|
c = 0;
|
|
if (u.options.stacked) {
|
|
for (i = 0; i < n; i++)
|
|
if (a = l.data.datasets[i], "line" === (o = l.getDatasetMeta(i)).type && o.yAxisID === u.id && l.isDatasetVisible(i)) {
|
|
var h = Number(u.getRightValue(a.data[e]));
|
|
h < 0 ? c += h || 0 : d += h || 0
|
|
}
|
|
var f = Number(u.getRightValue(t));
|
|
return f < 0 ? u.getPixelForValue(c + f) : u.getPixelForValue(d + f)
|
|
}
|
|
return u.getPixelForValue(t)
|
|
},
|
|
updateBezierControlPoints: function() {
|
|
function t(t, e, n) {
|
|
return Math.max(Math.min(t, n), e)
|
|
}
|
|
var e, n, i, a, r = this,
|
|
l = r.getMeta(),
|
|
s = r.chart.chartArea,
|
|
u = l.data || [];
|
|
if (l.dataset._model.spanGaps && (u = u.filter(function(t) {
|
|
return !t._model.skip
|
|
})), "monotone" === l.dataset._model.cubicInterpolationMode) o.splineCurveMonotone(u);
|
|
else
|
|
for (e = 0, n = u.length; e < n; ++e) i = u[e]._model, a = o.splineCurve(o.previousItem(u, e)._model, i, o.nextItem(u, e)._model, l.dataset._model.tension), i.controlPointPreviousX = a.previous.x, i.controlPointPreviousY = a.previous.y, i.controlPointNextX = a.next.x, i.controlPointNextY = a.next.y;
|
|
if (r.chart.options.elements.line.capBezierPoints)
|
|
for (e = 0, n = u.length; e < n; ++e)(i = u[e]._model).controlPointPreviousX = t(i.controlPointPreviousX, s.left, s.right), i.controlPointPreviousY = t(i.controlPointPreviousY, s.top, s.bottom), i.controlPointNextX = t(i.controlPointNextX, s.left, s.right), i.controlPointNextY = t(i.controlPointNextY, s.top, s.bottom)
|
|
},
|
|
draw: function() {
|
|
var t = this,
|
|
n = t.chart,
|
|
i = t.getMeta(),
|
|
a = i.data || [],
|
|
r = n.chartArea,
|
|
l = a.length,
|
|
s = 0;
|
|
for (o.canvas.clipArea(n.ctx, r), e(t.getDataset(), n.options) && i.dataset.draw(), o.canvas.unclipArea(n.ctx); s < l; ++s) a[s].draw(r)
|
|
},
|
|
setHoverStyle: function(t) {
|
|
var e = this.chart.data.datasets[t._datasetIndex],
|
|
n = t._index,
|
|
i = t.custom || {},
|
|
a = t._model;
|
|
a.radius = i.hoverRadius || o.valueAtIndexOrDefault(e.pointHoverRadius, n, this.chart.options.elements.point.hoverRadius), a.backgroundColor = i.hoverBackgroundColor || o.valueAtIndexOrDefault(e.pointHoverBackgroundColor, n, o.getHoverColor(a.backgroundColor)), a.borderColor = i.hoverBorderColor || o.valueAtIndexOrDefault(e.pointHoverBorderColor, n, o.getHoverColor(a.borderColor)), a.borderWidth = i.hoverBorderWidth || o.valueAtIndexOrDefault(e.pointHoverBorderWidth, n, a.borderWidth)
|
|
},
|
|
removeHoverStyle: function(t) {
|
|
var e = this,
|
|
n = e.chart.data.datasets[t._datasetIndex],
|
|
i = t._index,
|
|
a = t.custom || {},
|
|
r = t._model;
|
|
void 0 !== n.radius && void 0 === n.pointRadius && (n.pointRadius = n.radius), r.radius = a.radius || o.valueAtIndexOrDefault(n.pointRadius, i, e.chart.options.elements.point.radius), r.backgroundColor = e.getPointBackgroundColor(t, i), r.borderColor = e.getPointBorderColor(t, i), r.borderWidth = e.getPointBorderWidth(t, i)
|
|
}
|
|
})
|
|
}
|
|
}, {
|
|
25: 25,
|
|
40: 40,
|
|
45: 45
|
|
}],
|
|
19: [function(t, e, n) {
|
|
"use strict";
|
|
var i = t(25),
|
|
a = t(40),
|
|
o = t(45);
|
|
i._set("polarArea", {
|
|
scale: {
|
|
type: "radialLinear",
|
|
angleLines: {
|
|
display: !1
|
|
},
|
|
gridLines: {
|
|
circular: !0
|
|
},
|
|
pointLabels: {
|
|
display: !1
|
|
},
|
|
ticks: {
|
|
beginAtZero: !0
|
|
}
|
|
},
|
|
animation: {
|
|
animateRotate: !0,
|
|
animateScale: !0
|
|
},
|
|
startAngle: -.5 * Math.PI,
|
|
legendCallback: function(t) {
|
|
var e = [];
|
|
e.push('<ul class="' + t.id + '-legend">');
|
|
var n = t.data,
|
|
i = n.datasets,
|
|
a = n.labels;
|
|
if (i.length)
|
|
for (var o = 0; o < i[0].data.length; ++o) e.push('<li><span style="background-color:' + i[0].backgroundColor[o] + '"></span>'), a[o] && e.push(a[o]), e.push("</li>");
|
|
return e.push("</ul>"), e.join("")
|
|
},
|
|
legend: {
|
|
labels: {
|
|
generateLabels: function(t) {
|
|
var e = t.data;
|
|
return e.labels.length && e.datasets.length ? e.labels.map(function(n, i) {
|
|
var a = t.getDatasetMeta(0),
|
|
r = e.datasets[0],
|
|
l = a.data[i].custom || {},
|
|
s = o.valueAtIndexOrDefault,
|
|
u = t.options.elements.arc;
|
|
return {
|
|
text: n,
|
|
fillStyle: l.backgroundColor ? l.backgroundColor : s(r.backgroundColor, i, u.backgroundColor),
|
|
strokeStyle: l.borderColor ? l.borderColor : s(r.borderColor, i, u.borderColor),
|
|
lineWidth: l.borderWidth ? l.borderWidth : s(r.borderWidth, i, u.borderWidth),
|
|
hidden: isNaN(r.data[i]) || a.data[i].hidden,
|
|
index: i
|
|
}
|
|
}) : []
|
|
}
|
|
},
|
|
onClick: function(t, e) {
|
|
var n, i, a, o = e.index,
|
|
r = this.chart;
|
|
for (n = 0, i = (r.data.datasets || []).length; n < i; ++n)(a = r.getDatasetMeta(n)).data[o].hidden = !a.data[o].hidden;
|
|
r.update()
|
|
}
|
|
},
|
|
tooltips: {
|
|
callbacks: {
|
|
title: function() {
|
|
return ""
|
|
},
|
|
label: function(t, e) {
|
|
return e.labels[t.index] + ": " + t.yLabel
|
|
}
|
|
}
|
|
}
|
|
}), e.exports = function(t) {
|
|
t.controllers.polarArea = t.DatasetController.extend({
|
|
dataElementType: a.Arc,
|
|
linkScales: o.noop,
|
|
update: function(t) {
|
|
var e = this,
|
|
n = e.chart,
|
|
i = n.chartArea,
|
|
a = e.getMeta(),
|
|
r = n.options,
|
|
l = r.elements.arc,
|
|
s = Math.min(i.right - i.left, i.bottom - i.top);
|
|
n.outerRadius = Math.max((s - l.borderWidth / 2) / 2, 0), n.innerRadius = Math.max(r.cutoutPercentage ? n.outerRadius / 100 * r.cutoutPercentage : 1, 0), n.radiusLength = (n.outerRadius - n.innerRadius) / n.getVisibleDatasetCount(), e.outerRadius = n.outerRadius - n.radiusLength * e.index, e.innerRadius = e.outerRadius - n.radiusLength, a.count = e.countVisibleElements(), o.each(a.data, function(n, i) {
|
|
e.updateElement(n, i, t)
|
|
})
|
|
},
|
|
updateElement: function(t, e, n) {
|
|
for (var i = this, a = i.chart, r = i.getDataset(), l = a.options, s = l.animation, u = a.scale, d = a.data.labels, c = i.calculateCircumference(r.data[e]), h = u.xCenter, f = u.yCenter, g = 0, p = i.getMeta(), v = 0; v < e; ++v) isNaN(r.data[v]) || p.data[v].hidden || ++g;
|
|
var m = l.startAngle,
|
|
b = t.hidden ? 0 : u.getDistanceFromCenterForValue(r.data[e]),
|
|
x = m + c * g,
|
|
y = x + (t.hidden ? 0 : c),
|
|
k = s.animateScale ? 0 : u.getDistanceFromCenterForValue(r.data[e]);
|
|
o.extend(t, {
|
|
_datasetIndex: i.index,
|
|
_index: e,
|
|
_scale: u,
|
|
_model: {
|
|
x: h,
|
|
y: f,
|
|
innerRadius: 0,
|
|
outerRadius: n ? k : b,
|
|
startAngle: n && s.animateRotate ? m : x,
|
|
endAngle: n && s.animateRotate ? m : y,
|
|
label: o.valueAtIndexOrDefault(d, e, d[e])
|
|
}
|
|
}), i.removeHoverStyle(t), t.pivot()
|
|
},
|
|
removeHoverStyle: function(e) {
|
|
t.DatasetController.prototype.removeHoverStyle.call(this, e, this.chart.options.elements.arc)
|
|
},
|
|
countVisibleElements: function() {
|
|
var t = this.getDataset(),
|
|
e = this.getMeta(),
|
|
n = 0;
|
|
return o.each(e.data, function(e, i) {
|
|
isNaN(t.data[i]) || e.hidden || n++
|
|
}), n
|
|
},
|
|
calculateCircumference: function(t) {
|
|
var e = this.getMeta().count;
|
|
return e > 0 && !isNaN(t) ? 2 * Math.PI / e : 0
|
|
}
|
|
})
|
|
}
|
|
}, {
|
|
25: 25,
|
|
40: 40,
|
|
45: 45
|
|
}],
|
|
20: [function(t, e, n) {
|
|
"use strict";
|
|
var i = t(25),
|
|
a = t(40),
|
|
o = t(45);
|
|
i._set("radar", {
|
|
scale: {
|
|
type: "radialLinear"
|
|
},
|
|
elements: {
|
|
line: {
|
|
tension: 0
|
|
}
|
|
}
|
|
}), e.exports = function(t) {
|
|
t.controllers.radar = t.DatasetController.extend({
|
|
datasetElementType: a.Line,
|
|
dataElementType: a.Point,
|
|
linkScales: o.noop,
|
|
update: function(t) {
|
|
var e = this,
|
|
n = e.getMeta(),
|
|
i = n.dataset,
|
|
a = n.data,
|
|
r = i.custom || {},
|
|
l = e.getDataset(),
|
|
s = e.chart.options.elements.line,
|
|
u = e.chart.scale;
|
|
void 0 !== l.tension && void 0 === l.lineTension && (l.lineTension = l.tension), o.extend(n.dataset, {
|
|
_datasetIndex: e.index,
|
|
_scale: u,
|
|
_children: a,
|
|
_loop: !0,
|
|
_model: {
|
|
tension: r.tension ? r.tension : o.valueOrDefault(l.lineTension, s.tension),
|
|
backgroundColor: r.backgroundColor ? r.backgroundColor : l.backgroundColor || s.backgroundColor,
|
|
borderWidth: r.borderWidth ? r.borderWidth : l.borderWidth || s.borderWidth,
|
|
borderColor: r.borderColor ? r.borderColor : l.borderColor || s.borderColor,
|
|
fill: r.fill ? r.fill : void 0 !== l.fill ? l.fill : s.fill,
|
|
borderCapStyle: r.borderCapStyle ? r.borderCapStyle : l.borderCapStyle || s.borderCapStyle,
|
|
borderDash: r.borderDash ? r.borderDash : l.borderDash || s.borderDash,
|
|
borderDashOffset: r.borderDashOffset ? r.borderDashOffset : l.borderDashOffset || s.borderDashOffset,
|
|
borderJoinStyle: r.borderJoinStyle ? r.borderJoinStyle : l.borderJoinStyle || s.borderJoinStyle
|
|
}
|
|
}), n.dataset.pivot(), o.each(a, function(n, i) {
|
|
e.updateElement(n, i, t)
|
|
}, e), e.updateBezierControlPoints()
|
|
},
|
|
updateElement: function(t, e, n) {
|
|
var i = this,
|
|
a = t.custom || {},
|
|
r = i.getDataset(),
|
|
l = i.chart.scale,
|
|
s = i.chart.options.elements.point,
|
|
u = l.getPointPositionForValue(e, r.data[e]);
|
|
void 0 !== r.radius && void 0 === r.pointRadius && (r.pointRadius = r.radius), void 0 !== r.hitRadius && void 0 === r.pointHitRadius && (r.pointHitRadius = r.hitRadius), o.extend(t, {
|
|
_datasetIndex: i.index,
|
|
_index: e,
|
|
_scale: l,
|
|
_model: {
|
|
x: n ? l.xCenter : u.x,
|
|
y: n ? l.yCenter : u.y,
|
|
tension: a.tension ? a.tension : o.valueOrDefault(r.lineTension, i.chart.options.elements.line.tension),
|
|
radius: a.radius ? a.radius : o.valueAtIndexOrDefault(r.pointRadius, e, s.radius),
|
|
backgroundColor: a.backgroundColor ? a.backgroundColor : o.valueAtIndexOrDefault(r.pointBackgroundColor, e, s.backgroundColor),
|
|
borderColor: a.borderColor ? a.borderColor : o.valueAtIndexOrDefault(r.pointBorderColor, e, s.borderColor),
|
|
borderWidth: a.borderWidth ? a.borderWidth : o.valueAtIndexOrDefault(r.pointBorderWidth, e, s.borderWidth),
|
|
pointStyle: a.pointStyle ? a.pointStyle : o.valueAtIndexOrDefault(r.pointStyle, e, s.pointStyle),
|
|
hitRadius: a.hitRadius ? a.hitRadius : o.valueAtIndexOrDefault(r.pointHitRadius, e, s.hitRadius)
|
|
}
|
|
}), t._model.skip = a.skip ? a.skip : isNaN(t._model.x) || isNaN(t._model.y)
|
|
},
|
|
updateBezierControlPoints: function() {
|
|
var t = this.chart.chartArea,
|
|
e = this.getMeta();
|
|
o.each(e.data, function(n, i) {
|
|
var a = n._model,
|
|
r = o.splineCurve(o.previousItem(e.data, i, !0)._model, a, o.nextItem(e.data, i, !0)._model, a.tension);
|
|
a.controlPointPreviousX = Math.max(Math.min(r.previous.x, t.right), t.left), a.controlPointPreviousY = Math.max(Math.min(r.previous.y, t.bottom), t.top), a.controlPointNextX = Math.max(Math.min(r.next.x, t.right), t.left), a.controlPointNextY = Math.max(Math.min(r.next.y, t.bottom), t.top), n.pivot()
|
|
})
|
|
},
|
|
setHoverStyle: function(t) {
|
|
var e = this.chart.data.datasets[t._datasetIndex],
|
|
n = t.custom || {},
|
|
i = t._index,
|
|
a = t._model;
|
|
a.radius = n.hoverRadius ? n.hoverRadius : o.valueAtIndexOrDefault(e.pointHoverRadius, i, this.chart.options.elements.point.hoverRadius), a.backgroundColor = n.hoverBackgroundColor ? n.hoverBackgroundColor : o.valueAtIndexOrDefault(e.pointHoverBackgroundColor, i, o.getHoverColor(a.backgroundColor)), a.borderColor = n.hoverBorderColor ? n.hoverBorderColor : o.valueAtIndexOrDefault(e.pointHoverBorderColor, i, o.getHoverColor(a.borderColor)), a.borderWidth = n.hoverBorderWidth ? n.hoverBorderWidth : o.valueAtIndexOrDefault(e.pointHoverBorderWidth, i, a.borderWidth)
|
|
},
|
|
removeHoverStyle: function(t) {
|
|
var e = this.chart.data.datasets[t._datasetIndex],
|
|
n = t.custom || {},
|
|
i = t._index,
|
|
a = t._model,
|
|
r = this.chart.options.elements.point;
|
|
a.radius = n.radius ? n.radius : o.valueAtIndexOrDefault(e.pointRadius, i, r.radius), a.backgroundColor = n.backgroundColor ? n.backgroundColor : o.valueAtIndexOrDefault(e.pointBackgroundColor, i, r.backgroundColor), a.borderColor = n.borderColor ? n.borderColor : o.valueAtIndexOrDefault(e.pointBorderColor, i, r.borderColor), a.borderWidth = n.borderWidth ? n.borderWidth : o.valueAtIndexOrDefault(e.pointBorderWidth, i, r.borderWidth)
|
|
}
|
|
})
|
|
}
|
|
}, {
|
|
25: 25,
|
|
40: 40,
|
|
45: 45
|
|
}],
|
|
21: [function(t, e, n) {
|
|
"use strict";
|
|
t(25)._set("scatter", {
|
|
hover: {
|
|
mode: "single"
|
|
},
|
|
scales: {
|
|
xAxes: [{
|
|
id: "x-axis-1",
|
|
type: "linear",
|
|
position: "bottom"
|
|
}],
|
|
yAxes: [{
|
|
id: "y-axis-1",
|
|
type: "linear",
|
|
position: "left"
|
|
}]
|
|
},
|
|
showLines: !1,
|
|
tooltips: {
|
|
callbacks: {
|
|
title: function() {
|
|
return ""
|
|
},
|
|
label: function(t) {
|
|
return "(" + t.xLabel + ", " + t.yLabel + ")"
|
|
}
|
|
}
|
|
}
|
|
}), e.exports = function(t) {
|
|
t.controllers.scatter = t.controllers.line
|
|
}
|
|
}, {
|
|
25: 25
|
|
}],
|
|
22: [function(t, e, n) {
|
|
"use strict";
|
|
var i = t(25),
|
|
a = t(26),
|
|
o = t(45);
|
|
i._set("global", {
|
|
animation: {
|
|
duration: 1e3,
|
|
easing: "easeOutQuart",
|
|
onProgress: o.noop,
|
|
onComplete: o.noop
|
|
}
|
|
}), e.exports = function(t) {
|
|
t.Animation = a.extend({
|
|
chart: null,
|
|
currentStep: 0,
|
|
numSteps: 60,
|
|
easing: "",
|
|
render: null,
|
|
onAnimationProgress: null,
|
|
onAnimationComplete: null
|
|
}), t.animationService = {
|
|
frameDuration: 17,
|
|
animations: [],
|
|
dropFrames: 0,
|
|
request: null,
|
|
addAnimation: function(t, e, n, i) {
|
|
var a, o, r = this.animations;
|
|
for (e.chart = t, i || (t.animating = !0), a = 0, o = r.length; a < o; ++a)
|
|
if (r[a].chart === t) return void(r[a] = e);
|
|
r.push(e), 1 === r.length && this.requestAnimationFrame()
|
|
},
|
|
cancelAnimation: function(t) {
|
|
var e = o.findIndex(this.animations, function(e) {
|
|
return e.chart === t
|
|
}); - 1 !== e && (this.animations.splice(e, 1), t.animating = !1)
|
|
},
|
|
requestAnimationFrame: function() {
|
|
var t = this;
|
|
null === t.request && (t.request = o.requestAnimFrame.call(window, function() {
|
|
t.request = null, t.startDigest()
|
|
}))
|
|
},
|
|
startDigest: function() {
|
|
var t = this,
|
|
e = Date.now(),
|
|
n = 0;
|
|
t.dropFrames > 1 && (n = Math.floor(t.dropFrames), t.dropFrames = t.dropFrames % 1), t.advance(1 + n);
|
|
var i = Date.now();
|
|
t.dropFrames += (i - e) / t.frameDuration, t.animations.length > 0 && t.requestAnimationFrame()
|
|
},
|
|
advance: function(t) {
|
|
for (var e, n, i = this.animations, a = 0; a < i.length;) n = (e = i[a]).chart, e.currentStep = (e.currentStep || 0) + t, e.currentStep = Math.min(e.currentStep, e.numSteps), o.callback(e.render, [n, e], n), o.callback(e.onAnimationProgress, [e], n), e.currentStep >= e.numSteps ? (o.callback(e.onAnimationComplete, [e], n), n.animating = !1, i.splice(a, 1)) : ++a
|
|
}
|
|
}, Object.defineProperty(t.Animation.prototype, "animationObject", {
|
|
get: function() {
|
|
return this
|
|
}
|
|
}), Object.defineProperty(t.Animation.prototype, "chartInstance", {
|
|
get: function() {
|
|
return this.chart
|
|
},
|
|
set: function(t) {
|
|
this.chart = t
|
|
}
|
|
})
|
|
}
|
|
}, {
|
|
25: 25,
|
|
26: 26,
|
|
45: 45
|
|
}],
|
|
23: [function(t, e, n) {
|
|
"use strict";
|
|
var i = t(25),
|
|
a = t(45),
|
|
o = t(28),
|
|
r = t(48);
|
|
e.exports = function(t) {
|
|
function e(t) {
|
|
var e = (t = t || {}).data = t.data || {};
|
|
return e.datasets = e.datasets || [], e.labels = e.labels || [], t.options = a.configMerge(i.global, i[t.type], t.options || {}), t
|
|
}
|
|
|
|
function n(t) {
|
|
var e = t.options;
|
|
e.scale ? t.scale.options = e.scale : e.scales && e.scales.xAxes.concat(e.scales.yAxes).forEach(function(e) {
|
|
t.scales[e.id].options = e
|
|
}), t.tooltip._options = e.tooltips
|
|
}
|
|
|
|
function l(t) {
|
|
return "top" === t || "bottom" === t
|
|
}
|
|
var s = t.plugins;
|
|
t.types = {}, t.instances = {}, t.controllers = {}, a.extend(t.prototype, {
|
|
construct: function(n, i) {
|
|
var o = this;
|
|
i = e(i);
|
|
var l = r.acquireContext(n, i),
|
|
s = l && l.canvas,
|
|
u = s && s.height,
|
|
d = s && s.width;
|
|
o.id = a.uid(), o.ctx = l, o.canvas = s, o.config = i, o.width = d, o.height = u, o.aspectRatio = u ? d / u : null, o.options = i.options, o._bufferedRender = !1, o.chart = o, o.controller = o, t.instances[o.id] = o, Object.defineProperty(o, "data", {
|
|
get: function() {
|
|
return o.config.data
|
|
},
|
|
set: function(t) {
|
|
o.config.data = t
|
|
}
|
|
}), l && s ? (o.initialize(), o.update()) : console.error("Failed to create chart: can't acquire context from the given item")
|
|
},
|
|
initialize: function() {
|
|
var t = this;
|
|
return s.notify(t, "beforeInit"), a.retinaScale(t, t.options.devicePixelRatio), t.bindEvents(), t.options.responsive && t.resize(!0), t.ensureScalesHaveIDs(), t.buildScales(), t.initToolTip(), s.notify(t, "afterInit"), t
|
|
},
|
|
clear: function() {
|
|
return a.canvas.clear(this), this
|
|
},
|
|
stop: function() {
|
|
return t.animationService.cancelAnimation(this), this
|
|
},
|
|
resize: function(t) {
|
|
var e = this,
|
|
n = e.options,
|
|
i = e.canvas,
|
|
o = n.maintainAspectRatio && e.aspectRatio || null,
|
|
r = Math.max(0, Math.floor(a.getMaximumWidth(i))),
|
|
l = Math.max(0, Math.floor(o ? r / o : a.getMaximumHeight(i)));
|
|
if ((e.width !== r || e.height !== l) && (i.width = e.width = r, i.height = e.height = l, i.style.width = r + "px", i.style.height = l + "px", a.retinaScale(e, n.devicePixelRatio), !t)) {
|
|
var u = {
|
|
width: r,
|
|
height: l
|
|
};
|
|
s.notify(e, "resize", [u]), e.options.onResize && e.options.onResize(e, u), e.stop(), e.update(e.options.responsiveAnimationDuration)
|
|
}
|
|
},
|
|
ensureScalesHaveIDs: function() {
|
|
var t = this.options,
|
|
e = t.scales || {},
|
|
n = t.scale;
|
|
a.each(e.xAxes, function(t, e) {
|
|
t.id = t.id || "x-axis-" + e
|
|
}), a.each(e.yAxes, function(t, e) {
|
|
t.id = t.id || "y-axis-" + e
|
|
}), n && (n.id = n.id || "scale")
|
|
},
|
|
buildScales: function() {
|
|
var e = this,
|
|
n = e.options,
|
|
i = e.scales = {},
|
|
o = [];
|
|
n.scales && (o = o.concat((n.scales.xAxes || []).map(function(t) {
|
|
return {
|
|
options: t,
|
|
dtype: "category",
|
|
dposition: "bottom"
|
|
}
|
|
}), (n.scales.yAxes || []).map(function(t) {
|
|
return {
|
|
options: t,
|
|
dtype: "linear",
|
|
dposition: "left"
|
|
}
|
|
}))), n.scale && o.push({
|
|
options: n.scale,
|
|
dtype: "radialLinear",
|
|
isDefault: !0,
|
|
dposition: "chartArea"
|
|
}), a.each(o, function(n) {
|
|
var o = n.options,
|
|
r = a.valueOrDefault(o.type, n.dtype),
|
|
s = t.scaleService.getScaleConstructor(r);
|
|
if (s) {
|
|
l(o.position) !== l(n.dposition) && (o.position = n.dposition);
|
|
var u = new s({
|
|
id: o.id,
|
|
options: o,
|
|
ctx: e.ctx,
|
|
chart: e
|
|
});
|
|
i[u.id] = u, u.mergeTicksOptions(), n.isDefault && (e.scale = u)
|
|
}
|
|
}), t.scaleService.addScalesToLayout(this)
|
|
},
|
|
buildOrUpdateControllers: function() {
|
|
var e = this,
|
|
n = [],
|
|
i = [];
|
|
return a.each(e.data.datasets, function(a, o) {
|
|
var r = e.getDatasetMeta(o),
|
|
l = a.type || e.config.type;
|
|
if (r.type && r.type !== l && (e.destroyDatasetMeta(o), r = e.getDatasetMeta(o)), r.type = l, n.push(r.type), r.controller) r.controller.updateIndex(o);
|
|
else {
|
|
var s = t.controllers[r.type];
|
|
if (void 0 === s) throw new Error('"' + r.type + '" is not a chart type.');
|
|
r.controller = new s(e, o), i.push(r.controller)
|
|
}
|
|
}, e), i
|
|
},
|
|
resetElements: function() {
|
|
var t = this;
|
|
a.each(t.data.datasets, function(e, n) {
|
|
t.getDatasetMeta(n).controller.reset()
|
|
}, t)
|
|
},
|
|
reset: function() {
|
|
this.resetElements(), this.tooltip.initialize()
|
|
},
|
|
update: function(t) {
|
|
var e = this;
|
|
if (t && "object" == typeof t || (t = {
|
|
duration: t,
|
|
lazy: arguments[1]
|
|
}), n(e), !1 !== s.notify(e, "beforeUpdate")) {
|
|
e.tooltip._data = e.data;
|
|
var i = e.buildOrUpdateControllers();
|
|
a.each(e.data.datasets, function(t, n) {
|
|
e.getDatasetMeta(n).controller.buildOrUpdateElements()
|
|
}, e), e.updateLayout(), a.each(i, function(t) {
|
|
t.reset()
|
|
}), e.updateDatasets(), s.notify(e, "afterUpdate"), e._bufferedRender ? e._bufferedRequest = {
|
|
duration: t.duration,
|
|
easing: t.easing,
|
|
lazy: t.lazy
|
|
} : e.render(t)
|
|
}
|
|
},
|
|
updateLayout: function() {
|
|
var e = this;
|
|
!1 !== s.notify(e, "beforeLayout") && (t.layoutService.update(this, this.width, this.height), s.notify(e, "afterScaleUpdate"), s.notify(e, "afterLayout"))
|
|
},
|
|
updateDatasets: function() {
|
|
var t = this;
|
|
if (!1 !== s.notify(t, "beforeDatasetsUpdate")) {
|
|
for (var e = 0, n = t.data.datasets.length; e < n; ++e) t.updateDataset(e);
|
|
s.notify(t, "afterDatasetsUpdate")
|
|
}
|
|
},
|
|
updateDataset: function(t) {
|
|
var e = this,
|
|
n = e.getDatasetMeta(t),
|
|
i = {
|
|
meta: n,
|
|
index: t
|
|
};
|
|
!1 !== s.notify(e, "beforeDatasetUpdate", [i]) && (n.controller.update(), s.notify(e, "afterDatasetUpdate", [i]))
|
|
},
|
|
render: function(e) {
|
|
var n = this;
|
|
e && "object" == typeof e || (e = {
|
|
duration: e,
|
|
lazy: arguments[1]
|
|
});
|
|
var i = e.duration,
|
|
o = e.lazy;
|
|
if (!1 !== s.notify(n, "beforeRender")) {
|
|
var r = n.options.animation,
|
|
l = function(t) {
|
|
s.notify(n, "afterRender"), a.callback(r && r.onComplete, [t], n)
|
|
};
|
|
if (r && (void 0 !== i && 0 !== i || void 0 === i && 0 !== r.duration)) {
|
|
var u = new t.Animation({
|
|
numSteps: (i || r.duration) / 16.66,
|
|
easing: e.easing || r.easing,
|
|
render: function(t, e) {
|
|
var n = a.easing.effects[e.easing],
|
|
i = e.currentStep,
|
|
o = i / e.numSteps;
|
|
t.draw(n(o), o, i)
|
|
},
|
|
onAnimationProgress: r.onProgress,
|
|
onAnimationComplete: l
|
|
});
|
|
t.animationService.addAnimation(n, u, i, o)
|
|
} else n.draw(), l(new t.Animation({
|
|
numSteps: 0,
|
|
chart: n
|
|
}));
|
|
return n
|
|
}
|
|
},
|
|
draw: function(t) {
|
|
var e = this;
|
|
e.clear(), a.isNullOrUndef(t) && (t = 1), e.transition(t), !1 !== s.notify(e, "beforeDraw", [t]) && (a.each(e.boxes, function(t) {
|
|
t.draw(e.chartArea)
|
|
}, e), e.scale && e.scale.draw(), e.drawDatasets(t), e.tooltip.draw(), s.notify(e, "afterDraw", [t]))
|
|
},
|
|
transition: function(t) {
|
|
for (var e = this, n = 0, i = (e.data.datasets || []).length; n < i; ++n) e.isDatasetVisible(n) && e.getDatasetMeta(n).controller.transition(t);
|
|
e.tooltip.transition(t)
|
|
},
|
|
drawDatasets: function(t) {
|
|
var e = this;
|
|
if (!1 !== s.notify(e, "beforeDatasetsDraw", [t])) {
|
|
for (var n = (e.data.datasets || []).length - 1; n >= 0; --n) e.isDatasetVisible(n) && e.drawDataset(n, t);
|
|
s.notify(e, "afterDatasetsDraw", [t])
|
|
}
|
|
},
|
|
drawDataset: function(t, e) {
|
|
var n = this,
|
|
i = n.getDatasetMeta(t),
|
|
a = {
|
|
meta: i,
|
|
index: t,
|
|
easingValue: e
|
|
};
|
|
!1 !== s.notify(n, "beforeDatasetDraw", [a]) && (i.controller.draw(e), s.notify(n, "afterDatasetDraw", [a]))
|
|
},
|
|
getElementAtEvent: function(t) {
|
|
return o.modes.single(this, t)
|
|
},
|
|
getElementsAtEvent: function(t) {
|
|
return o.modes.label(this, t, {
|
|
intersect: !0
|
|
})
|
|
},
|
|
getElementsAtXAxis: function(t) {
|
|
return o.modes["x-axis"](this, t, {
|
|
intersect: !0
|
|
})
|
|
},
|
|
getElementsAtEventForMode: function(t, e, n) {
|
|
var i = o.modes[e];
|
|
return "function" == typeof i ? i(this, t, n) : []
|
|
},
|
|
getDatasetAtEvent: function(t) {
|
|
return o.modes.dataset(this, t, {
|
|
intersect: !0
|
|
})
|
|
},
|
|
getDatasetMeta: function(t) {
|
|
var e = this,
|
|
n = e.data.datasets[t];
|
|
n._meta || (n._meta = {});
|
|
var i = n._meta[e.id];
|
|
return i || (i = n._meta[e.id] = {
|
|
type: null,
|
|
data: [],
|
|
dataset: null,
|
|
controller: null,
|
|
hidden: null,
|
|
xAxisID: null,
|
|
yAxisID: null
|
|
}), i
|
|
},
|
|
getVisibleDatasetCount: function() {
|
|
for (var t = 0, e = 0, n = this.data.datasets.length; e < n; ++e) this.isDatasetVisible(e) && t++;
|
|
return t
|
|
},
|
|
isDatasetVisible: function(t) {
|
|
var e = this.getDatasetMeta(t);
|
|
return "boolean" == typeof e.hidden ? !e.hidden : !this.data.datasets[t].hidden
|
|
},
|
|
generateLegend: function() {
|
|
return this.options.legendCallback(this)
|
|
},
|
|
destroyDatasetMeta: function(t) {
|
|
var e = this.id,
|
|
n = this.data.datasets[t],
|
|
i = n._meta && n._meta[e];
|
|
i && (i.controller.destroy(), delete n._meta[e])
|
|
},
|
|
destroy: function() {
|
|
var e, n, i = this,
|
|
o = i.canvas;
|
|
for (i.stop(), e = 0, n = i.data.datasets.length; e < n; ++e) i.destroyDatasetMeta(e);
|
|
o && (i.unbindEvents(), a.canvas.clear(i), r.releaseContext(i.ctx), i.canvas = null, i.ctx = null), s.notify(i, "destroy"), delete t.instances[i.id]
|
|
},
|
|
toBase64Image: function() {
|
|
return this.canvas.toDataURL.apply(this.canvas, arguments)
|
|
},
|
|
initToolTip: function() {
|
|
var e = this;
|
|
e.tooltip = new t.Tooltip({
|
|
_chart: e,
|
|
_chartInstance: e,
|
|
_data: e.data,
|
|
_options: e.options.tooltips
|
|
}, e)
|
|
},
|
|
bindEvents: function() {
|
|
var t = this,
|
|
e = t._listeners = {},
|
|
n = function() {
|
|
t.eventHandler.apply(t, arguments)
|
|
};
|
|
a.each(t.options.events, function(i) {
|
|
r.addEventListener(t, i, n), e[i] = n
|
|
}), t.options.responsive && (n = function() {
|
|
t.resize()
|
|
}, r.addEventListener(t, "resize", n), e.resize = n)
|
|
},
|
|
unbindEvents: function() {
|
|
var t = this,
|
|
e = t._listeners;
|
|
e && (delete t._listeners, a.each(e, function(e, n) {
|
|
r.removeEventListener(t, n, e)
|
|
}))
|
|
},
|
|
updateHoverStyle: function(t, e, n) {
|
|
var i, a, o, r = n ? "setHoverStyle" : "removeHoverStyle";
|
|
for (a = 0, o = t.length; a < o; ++a)(i = t[a]) && this.getDatasetMeta(i._datasetIndex).controller[r](i)
|
|
},
|
|
eventHandler: function(t) {
|
|
var e = this,
|
|
n = e.tooltip;
|
|
if (!1 !== s.notify(e, "beforeEvent", [t])) {
|
|
e._bufferedRender = !0, e._bufferedRequest = null;
|
|
var i = e.handleEvent(t);
|
|
i |= n && n.handleEvent(t), s.notify(e, "afterEvent", [t]);
|
|
var a = e._bufferedRequest;
|
|
return a ? e.render(a) : i && !e.animating && (e.stop(), e.render(e.options.hover.animationDuration, !0)), e._bufferedRender = !1, e._bufferedRequest = null, e
|
|
}
|
|
},
|
|
handleEvent: function(t) {
|
|
var e = this,
|
|
n = e.options || {},
|
|
i = n.hover,
|
|
o = !1;
|
|
return e.lastActive = e.lastActive || [], "mouseout" === t.type ? e.active = [] : e.active = e.getElementsAtEventForMode(t, i.mode, i), a.callback(n.onHover || n.hover.onHover, [t.native, e.active], e), "mouseup" !== t.type && "click" !== t.type || n.onClick && n.onClick.call(e, t.native, e.active), e.lastActive.length && e.updateHoverStyle(e.lastActive, i.mode, !1), e.active.length && i.mode && e.updateHoverStyle(e.active, i.mode, !0), o = !a.arrayEquals(e.active, e.lastActive), e.lastActive = e.active, o
|
|
}
|
|
}), t.Controller = t
|
|
}
|
|
}, {
|
|
25: 25,
|
|
28: 28,
|
|
45: 45,
|
|
48: 48
|
|
}],
|
|
24: [function(t, e, n) {
|
|
"use strict";
|
|
var i = t(45);
|
|
e.exports = function(t) {
|
|
function e(t, e) {
|
|
t._chartjs ? t._chartjs.listeners.push(e) : (Object.defineProperty(t, "_chartjs", {
|
|
configurable: !0,
|
|
enumerable: !1,
|
|
value: {
|
|
listeners: [e]
|
|
}
|
|
}), a.forEach(function(e) {
|
|
var n = "onData" + e.charAt(0).toUpperCase() + e.slice(1),
|
|
a = t[e];
|
|
Object.defineProperty(t, e, {
|
|
configurable: !0,
|
|
enumerable: !1,
|
|
value: function() {
|
|
var e = Array.prototype.slice.call(arguments),
|
|
o = a.apply(this, e);
|
|
return i.each(t._chartjs.listeners, function(t) {
|
|
"function" == typeof t[n] && t[n].apply(t, e)
|
|
}), o
|
|
}
|
|
})
|
|
}))
|
|
}
|
|
|
|
function n(t, e) {
|
|
var n = t._chartjs;
|
|
if (n) {
|
|
var i = n.listeners,
|
|
o = i.indexOf(e); - 1 !== o && i.splice(o, 1), i.length > 0 || (a.forEach(function(e) {
|
|
delete t[e]
|
|
}), delete t._chartjs)
|
|
}
|
|
}
|
|
var a = ["push", "pop", "shift", "splice", "unshift"];
|
|
t.DatasetController = function(t, e) {
|
|
this.initialize(t, e)
|
|
}, i.extend(t.DatasetController.prototype, {
|
|
datasetElementType: null,
|
|
dataElementType: null,
|
|
initialize: function(t, e) {
|
|
var n = this;
|
|
n.chart = t, n.index = e, n.linkScales(), n.addElements()
|
|
},
|
|
updateIndex: function(t) {
|
|
this.index = t
|
|
},
|
|
linkScales: function() {
|
|
var t = this,
|
|
e = t.getMeta(),
|
|
n = t.getDataset();
|
|
null === e.xAxisID && (e.xAxisID = n.xAxisID || t.chart.options.scales.xAxes[0].id), null === e.yAxisID && (e.yAxisID = n.yAxisID || t.chart.options.scales.yAxes[0].id)
|
|
},
|
|
getDataset: function() {
|
|
return this.chart.data.datasets[this.index]
|
|
},
|
|
getMeta: function() {
|
|
return this.chart.getDatasetMeta(this.index)
|
|
},
|
|
getScaleForId: function(t) {
|
|
return this.chart.scales[t]
|
|
},
|
|
reset: function() {
|
|
this.update(!0)
|
|
},
|
|
destroy: function() {
|
|
this._data && n(this._data, this)
|
|
},
|
|
createMetaDataset: function() {
|
|
var t = this,
|
|
e = t.datasetElementType;
|
|
return e && new e({
|
|
_chart: t.chart,
|
|
_datasetIndex: t.index
|
|
})
|
|
},
|
|
createMetaData: function(t) {
|
|
var e = this,
|
|
n = e.dataElementType;
|
|
return n && new n({
|
|
_chart: e.chart,
|
|
_datasetIndex: e.index,
|
|
_index: t
|
|
})
|
|
},
|
|
addElements: function() {
|
|
var t, e, n = this,
|
|
i = n.getMeta(),
|
|
a = n.getDataset().data || [],
|
|
o = i.data;
|
|
for (t = 0, e = a.length; t < e; ++t) o[t] = o[t] || n.createMetaData(t);
|
|
i.dataset = i.dataset || n.createMetaDataset()
|
|
},
|
|
addElementAndReset: function(t) {
|
|
var e = this.createMetaData(t);
|
|
this.getMeta().data.splice(t, 0, e), this.updateElement(e, t, !0)
|
|
},
|
|
buildOrUpdateElements: function() {
|
|
var t = this,
|
|
i = t.getDataset(),
|
|
a = i.data || (i.data = []);
|
|
t._data !== a && (t._data && n(t._data, t), e(a, t), t._data = a), t.resyncElements()
|
|
},
|
|
update: i.noop,
|
|
transition: function(t) {
|
|
for (var e = this.getMeta(), n = e.data || [], i = n.length, a = 0; a < i; ++a) n[a].transition(t);
|
|
e.dataset && e.dataset.transition(t)
|
|
},
|
|
draw: function() {
|
|
var t = this.getMeta(),
|
|
e = t.data || [],
|
|
n = e.length,
|
|
i = 0;
|
|
for (t.dataset && t.dataset.draw(); i < n; ++i) e[i].draw()
|
|
},
|
|
removeHoverStyle: function(t, e) {
|
|
var n = this.chart.data.datasets[t._datasetIndex],
|
|
a = t._index,
|
|
o = t.custom || {},
|
|
r = i.valueAtIndexOrDefault,
|
|
l = t._model;
|
|
l.backgroundColor = o.backgroundColor ? o.backgroundColor : r(n.backgroundColor, a, e.backgroundColor), l.borderColor = o.borderColor ? o.borderColor : r(n.borderColor, a, e.borderColor), l.borderWidth = o.borderWidth ? o.borderWidth : r(n.borderWidth, a, e.borderWidth)
|
|
},
|
|
setHoverStyle: function(t) {
|
|
var e = this.chart.data.datasets[t._datasetIndex],
|
|
n = t._index,
|
|
a = t.custom || {},
|
|
o = i.valueAtIndexOrDefault,
|
|
r = i.getHoverColor,
|
|
l = t._model;
|
|
l.backgroundColor = a.hoverBackgroundColor ? a.hoverBackgroundColor : o(e.hoverBackgroundColor, n, r(l.backgroundColor)), l.borderColor = a.hoverBorderColor ? a.hoverBorderColor : o(e.hoverBorderColor, n, r(l.borderColor)), l.borderWidth = a.hoverBorderWidth ? a.hoverBorderWidth : o(e.hoverBorderWidth, n, l.borderWidth)
|
|
},
|
|
resyncElements: function() {
|
|
var t = this,
|
|
e = t.getMeta(),
|
|
n = t.getDataset().data,
|
|
i = e.data.length,
|
|
a = n.length;
|
|
a < i ? e.data.splice(a, i - a) : a > i && t.insertElements(i, a - i)
|
|
},
|
|
insertElements: function(t, e) {
|
|
for (var n = 0; n < e; ++n) this.addElementAndReset(t + n)
|
|
},
|
|
onDataPush: function() {
|
|
this.insertElements(this.getDataset().data.length - 1, arguments.length)
|
|
},
|
|
onDataPop: function() {
|
|
this.getMeta().data.pop()
|
|
},
|
|
onDataShift: function() {
|
|
this.getMeta().data.shift()
|
|
},
|
|
onDataSplice: function(t, e) {
|
|
this.getMeta().data.splice(t, e), this.insertElements(t, arguments.length - 2)
|
|
},
|
|
onDataUnshift: function() {
|
|
this.insertElements(0, arguments.length)
|
|
}
|
|
}), t.DatasetController.extend = i.inherits
|
|
}
|
|
}, {
|
|
45: 45
|
|
}],
|
|
25: [function(t, e, n) {
|
|
"use strict";
|
|
var i = t(45);
|
|
e.exports = {
|
|
_set: function(t, e) {
|
|
return i.merge(this[t] || (this[t] = {}), e)
|
|
}
|
|
}
|
|
}, {
|
|
45: 45
|
|
}],
|
|
26: [function(t, e, n) {
|
|
"use strict";
|
|
|
|
function i(t, e, n, i) {
|
|
var o, r, l, s, u, d, c, h, f, g = Object.keys(n);
|
|
for (o = 0, r = g.length; o < r; ++o)
|
|
if (l = g[o], d = n[l], e.hasOwnProperty(l) || (e[l] = d), (s = e[l]) !== d && "_" !== l[0]) {
|
|
if (t.hasOwnProperty(l) || (t[l] = s), u = t[l], (c = typeof d) === typeof u)
|
|
if ("string" === c) {
|
|
if ((h = a(u)).valid && (f = a(d)).valid) {
|
|
e[l] = f.mix(h, i).rgbString();
|
|
continue
|
|
}
|
|
} else if ("number" === c && isFinite(u) && isFinite(d)) {
|
|
e[l] = u + (d - u) * i;
|
|
continue
|
|
}
|
|
e[l] = d
|
|
}
|
|
}
|
|
var a = t(3),
|
|
o = t(45),
|
|
r = function(t) {
|
|
o.extend(this, t), this.initialize.apply(this, arguments)
|
|
};
|
|
o.extend(r.prototype, {
|
|
initialize: function() {
|
|
this.hidden = !1
|
|
},
|
|
pivot: function() {
|
|
var t = this;
|
|
return t._view || (t._view = o.clone(t._model)), t._start = {}, t
|
|
},
|
|
transition: function(t) {
|
|
var e = this,
|
|
n = e._model,
|
|
a = e._start,
|
|
o = e._view;
|
|
return n && 1 !== t ? (o || (o = e._view = {}), a || (a = e._start = {}), i(a, o, n, t), e) : (e._view = n, e._start = null, e)
|
|
},
|
|
tooltipPosition: function() {
|
|
return {
|
|
x: this._model.x,
|
|
y: this._model.y
|
|
}
|
|
},
|
|
hasValue: function() {
|
|
return o.isNumber(this._model.x) && o.isNumber(this._model.y)
|
|
}
|
|
}), r.extend = o.inherits, e.exports = r
|
|
}, {
|
|
3: 3,
|
|
45: 45
|
|
}],
|
|
27: [function(t, e, n) {
|
|
"use strict";
|
|
var i = t(3),
|
|
a = t(25),
|
|
o = t(45);
|
|
e.exports = function(t) {
|
|
function e(t, e, n) {
|
|
var i;
|
|
return "string" == typeof t ? (i = parseInt(t, 10), -1 !== t.indexOf("%") && (i = i / 100 * e.parentNode[n])) : i = t, i
|
|
}
|
|
|
|
function n(t) {
|
|
return void 0 !== t && null !== t && "none" !== t
|
|
}
|
|
|
|
function r(t, i, a) {
|
|
var o = document.defaultView,
|
|
r = t.parentNode,
|
|
l = o.getComputedStyle(t)[i],
|
|
s = o.getComputedStyle(r)[i],
|
|
u = n(l),
|
|
d = n(s),
|
|
c = Number.POSITIVE_INFINITY;
|
|
return u || d ? Math.min(u ? e(l, t, a) : c, d ? e(s, r, a) : c) : "none"
|
|
}
|
|
o.extend = function(t) {
|
|
for (var e = 1, n = arguments.length; e < n; e++) o.each(arguments[e], function(e, n) {
|
|
t[n] = e
|
|
});
|
|
return t
|
|
}, o.configMerge = function() {
|
|
return o.merge(o.clone(arguments[0]), [].slice.call(arguments, 1), {
|
|
merger: function(e, n, i, a) {
|
|
var r = n[e] || {},
|
|
l = i[e];
|
|
"scales" === e ? n[e] = o.scaleMerge(r, l) : "scale" === e ? n[e] = o.merge(r, [t.scaleService.getScaleDefaults(l.type), l]) : o._merger(e, n, i, a)
|
|
}
|
|
})
|
|
}, o.scaleMerge = function() {
|
|
return o.merge(o.clone(arguments[0]), [].slice.call(arguments, 1), {
|
|
merger: function(e, n, i, a) {
|
|
if ("xAxes" === e || "yAxes" === e) {
|
|
var r, l, s, u = i[e].length;
|
|
for (n[e] || (n[e] = []), r = 0; r < u; ++r) s = i[e][r], l = o.valueOrDefault(s.type, "xAxes" === e ? "category" : "linear"), r >= n[e].length && n[e].push({}), !n[e][r].type || s.type && s.type !== n[e][r].type ? o.merge(n[e][r], [t.scaleService.getScaleDefaults(l), s]) : o.merge(n[e][r], s)
|
|
} else o._merger(e, n, i, a)
|
|
}
|
|
})
|
|
}, o.where = function(t, e) {
|
|
if (o.isArray(t) && Array.prototype.filter) return t.filter(e);
|
|
var n = [];
|
|
return o.each(t, function(t) {
|
|
e(t) && n.push(t)
|
|
}), n
|
|
}, o.findIndex = Array.prototype.findIndex ? function(t, e, n) {
|
|
return t.findIndex(e, n)
|
|
} : function(t, e, n) {
|
|
n = void 0 === n ? t : n;
|
|
for (var i = 0, a = t.length; i < a; ++i)
|
|
if (e.call(n, t[i], i, t)) return i;
|
|
return -1
|
|
}, o.findNextWhere = function(t, e, n) {
|
|
o.isNullOrUndef(n) && (n = -1);
|
|
for (var i = n + 1; i < t.length; i++) {
|
|
var a = t[i];
|
|
if (e(a)) return a
|
|
}
|
|
}, o.findPreviousWhere = function(t, e, n) {
|
|
o.isNullOrUndef(n) && (n = t.length);
|
|
for (var i = n - 1; i >= 0; i--) {
|
|
var a = t[i];
|
|
if (e(a)) return a
|
|
}
|
|
}, o.inherits = function(t) {
|
|
var e = this,
|
|
n = t && t.hasOwnProperty("constructor") ? t.constructor : function() {
|
|
return e.apply(this, arguments)
|
|
},
|
|
i = function() {
|
|
this.constructor = n
|
|
};
|
|
return i.prototype = e.prototype, n.prototype = new i, n.extend = o.inherits, t && o.extend(n.prototype, t), n.__super__ = e.prototype, n
|
|
}, o.isNumber = function(t) {
|
|
return !isNaN(parseFloat(t)) && isFinite(t)
|
|
}, o.almostEquals = function(t, e, n) {
|
|
return Math.abs(t - e) < n
|
|
}, o.almostWhole = function(t, e) {
|
|
var n = Math.round(t);
|
|
return n - e < t && n + e > t
|
|
}, o.max = function(t) {
|
|
return t.reduce(function(t, e) {
|
|
return isNaN(e) ? t : Math.max(t, e)
|
|
}, Number.NEGATIVE_INFINITY)
|
|
}, o.min = function(t) {
|
|
return t.reduce(function(t, e) {
|
|
return isNaN(e) ? t : Math.min(t, e)
|
|
}, Number.POSITIVE_INFINITY)
|
|
}, o.sign = Math.sign ? function(t) {
|
|
return Math.sign(t)
|
|
} : function(t) {
|
|
return 0 == (t = +t) || isNaN(t) ? t : t > 0 ? 1 : -1
|
|
}, o.log10 = Math.log10 ? function(t) {
|
|
return Math.log10(t)
|
|
} : function(t) {
|
|
return Math.log(t) / Math.LN10
|
|
}, o.toRadians = function(t) {
|
|
return t * (Math.PI / 180)
|
|
}, o.toDegrees = function(t) {
|
|
return t * (180 / Math.PI)
|
|
}, o.getAngleFromPoint = function(t, e) {
|
|
var n = e.x - t.x,
|
|
i = e.y - t.y,
|
|
a = Math.sqrt(n * n + i * i),
|
|
o = Math.atan2(i, n);
|
|
return o < -.5 * Math.PI && (o += 2 * Math.PI), {
|
|
angle: o,
|
|
distance: a
|
|
}
|
|
}, o.distanceBetweenPoints = function(t, e) {
|
|
return Math.sqrt(Math.pow(e.x - t.x, 2) + Math.pow(e.y - t.y, 2))
|
|
}, o.aliasPixel = function(t) {
|
|
return t % 2 == 0 ? 0 : .5
|
|
}, o.splineCurve = function(t, e, n, i) {
|
|
var a = t.skip ? e : t,
|
|
o = e,
|
|
r = n.skip ? e : n,
|
|
l = Math.sqrt(Math.pow(o.x - a.x, 2) + Math.pow(o.y - a.y, 2)),
|
|
s = Math.sqrt(Math.pow(r.x - o.x, 2) + Math.pow(r.y - o.y, 2)),
|
|
u = l / (l + s),
|
|
d = s / (l + s),
|
|
c = i * (u = isNaN(u) ? 0 : u),
|
|
h = i * (d = isNaN(d) ? 0 : d);
|
|
return {
|
|
previous: {
|
|
x: o.x - c * (r.x - a.x),
|
|
y: o.y - c * (r.y - a.y)
|
|
},
|
|
next: {
|
|
x: o.x + h * (r.x - a.x),
|
|
y: o.y + h * (r.y - a.y)
|
|
}
|
|
}
|
|
}, o.EPSILON = Number.EPSILON || 1e-14, o.splineCurveMonotone = function(t) {
|
|
var e, n, i, a, r = (t || []).map(function(t) {
|
|
return {
|
|
model: t._model,
|
|
deltaK: 0,
|
|
mK: 0
|
|
}
|
|
}),
|
|
l = r.length;
|
|
for (e = 0; e < l; ++e)
|
|
if (!(i = r[e]).model.skip) {
|
|
if (n = e > 0 ? r[e - 1] : null, (a = e < l - 1 ? r[e + 1] : null) && !a.model.skip) {
|
|
var s = a.model.x - i.model.x;
|
|
i.deltaK = 0 !== s ? (a.model.y - i.model.y) / s : 0
|
|
}!n || n.model.skip ? i.mK = i.deltaK : !a || a.model.skip ? i.mK = n.deltaK : this.sign(n.deltaK) !== this.sign(i.deltaK) ? i.mK = 0 : i.mK = (n.deltaK + i.deltaK) / 2
|
|
}
|
|
var u, d, c, h;
|
|
for (e = 0; e < l - 1; ++e) i = r[e], a = r[e + 1], i.model.skip || a.model.skip || (o.almostEquals(i.deltaK, 0, this.EPSILON) ? i.mK = a.mK = 0 : (u = i.mK / i.deltaK, d = a.mK / i.deltaK, (h = Math.pow(u, 2) + Math.pow(d, 2)) <= 9 || (c = 3 / Math.sqrt(h), i.mK = u * c * i.deltaK, a.mK = d * c * i.deltaK)));
|
|
var f;
|
|
for (e = 0; e < l; ++e)(i = r[e]).model.skip || (n = e > 0 ? r[e - 1] : null, a = e < l - 1 ? r[e + 1] : null, n && !n.model.skip && (f = (i.model.x - n.model.x) / 3, i.model.controlPointPreviousX = i.model.x - f, i.model.controlPointPreviousY = i.model.y - f * i.mK), a && !a.model.skip && (f = (a.model.x - i.model.x) / 3, i.model.controlPointNextX = i.model.x + f, i.model.controlPointNextY = i.model.y + f * i.mK))
|
|
}, o.nextItem = function(t, e, n) {
|
|
return n ? e >= t.length - 1 ? t[0] : t[e + 1] : e >= t.length - 1 ? t[t.length - 1] : t[e + 1]
|
|
}, o.previousItem = function(t, e, n) {
|
|
return n ? e <= 0 ? t[t.length - 1] : t[e - 1] : e <= 0 ? t[0] : t[e - 1]
|
|
}, o.niceNum = function(t, e) {
|
|
var n = Math.floor(o.log10(t)),
|
|
i = t / Math.pow(10, n);
|
|
return (e ? i < 1.5 ? 1 : i < 3 ? 2 : i < 7 ? 5 : 10 : i <= 1 ? 1 : i <= 2 ? 2 : i <= 5 ? 5 : 10) * Math.pow(10, n)
|
|
}, o.requestAnimFrame = "undefined" == typeof window ? function(t) {
|
|
t()
|
|
} : window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || window.oRequestAnimationFrame || window.msRequestAnimationFrame || function(t) {
|
|
return window.setTimeout(t, 1e3 / 60)
|
|
}, o.getRelativePosition = function(t, e) {
|
|
var n, i, a = t.originalEvent || t,
|
|
r = t.currentTarget || t.srcElement,
|
|
l = r.getBoundingClientRect(),
|
|
s = a.touches;
|
|
s && s.length > 0 ? (n = s[0].clientX, i = s[0].clientY) : (n = a.clientX, i = a.clientY);
|
|
var u = parseFloat(o.getStyle(r, "padding-left")),
|
|
d = parseFloat(o.getStyle(r, "padding-top")),
|
|
c = parseFloat(o.getStyle(r, "padding-right")),
|
|
h = parseFloat(o.getStyle(r, "padding-bottom")),
|
|
f = l.right - l.left - u - c,
|
|
g = l.bottom - l.top - d - h;
|
|
return n = Math.round((n - l.left - u) / f * r.width / e.currentDevicePixelRatio), i = Math.round((i - l.top - d) / g * r.height / e.currentDevicePixelRatio), {
|
|
x: n,
|
|
y: i
|
|
}
|
|
}, o.getConstraintWidth = function(t) {
|
|
return r(t, "max-width", "clientWidth")
|
|
}, o.getConstraintHeight = function(t) {
|
|
return r(t, "max-height", "clientHeight")
|
|
}, o.getMaximumWidth = function(t) {
|
|
var e = t.parentNode;
|
|
if (!e) return t.clientWidth;
|
|
var n = parseInt(o.getStyle(e, "padding-left"), 10),
|
|
i = parseInt(o.getStyle(e, "padding-right"), 10),
|
|
a = e.clientWidth - n - i,
|
|
r = o.getConstraintWidth(t);
|
|
return isNaN(r) ? a : Math.min(a, r)
|
|
}, o.getMaximumHeight = function(t) {
|
|
var e = t.parentNode;
|
|
if (!e) return t.clientHeight;
|
|
var n = parseInt(o.getStyle(e, "padding-top"), 10),
|
|
i = parseInt(o.getStyle(e, "padding-bottom"), 10),
|
|
a = e.clientHeight - n - i,
|
|
r = o.getConstraintHeight(t);
|
|
return isNaN(r) ? a : Math.min(a, r)
|
|
}, o.getStyle = function(t, e) {
|
|
return t.currentStyle ? t.currentStyle[e] : document.defaultView.getComputedStyle(t, null).getPropertyValue(e)
|
|
}, o.retinaScale = function(t, e) {
|
|
var n = t.currentDevicePixelRatio = e || window.devicePixelRatio || 1;
|
|
if (1 !== n) {
|
|
var i = t.canvas,
|
|
a = t.height,
|
|
o = t.width;
|
|
i.height = a * n, i.width = o * n, t.ctx.scale(n, n), i.style.height = a + "px", i.style.width = o + "px"
|
|
}
|
|
}, o.fontString = function(t, e, n) {
|
|
return e + " " + t + "px " + n
|
|
}, o.longestText = function(t, e, n, i) {
|
|
var a = (i = i || {}).data = i.data || {},
|
|
r = i.garbageCollect = i.garbageCollect || [];
|
|
i.font !== e && (a = i.data = {}, r = i.garbageCollect = [], i.font = e), t.font = e;
|
|
var l = 0;
|
|
o.each(n, function(e) {
|
|
void 0 !== e && null !== e && !0 !== o.isArray(e) ? l = o.measureText(t, a, r, l, e) : o.isArray(e) && o.each(e, function(e) {
|
|
void 0 === e || null === e || o.isArray(e) || (l = o.measureText(t, a, r, l, e))
|
|
})
|
|
});
|
|
var s = r.length / 2;
|
|
if (s > n.length) {
|
|
for (var u = 0; u < s; u++) delete a[r[u]];
|
|
r.splice(0, s)
|
|
}
|
|
return l
|
|
}, o.measureText = function(t, e, n, i, a) {
|
|
var o = e[a];
|
|
return o || (o = e[a] = t.measureText(a).width, n.push(a)), o > i && (i = o), i
|
|
}, o.numberOfLabelLines = function(t) {
|
|
var e = 1;
|
|
return o.each(t, function(t) {
|
|
o.isArray(t) && t.length > e && (e = t.length)
|
|
}), e
|
|
}, o.color = i ? function(t) {
|
|
return t instanceof CanvasGradient && (t = a.global.defaultColor), i(t)
|
|
} : function(t) {
|
|
return console.error("Color.js not found!"), t
|
|
}, o.getHoverColor = function(t) {
|
|
return t instanceof CanvasPattern ? t : o.color(t).saturate(.5).darken(.1).rgbString()
|
|
}
|
|
}
|
|
}, {
|
|
25: 25,
|
|
3: 3,
|
|
45: 45
|
|
}],
|
|
28: [function(t, e, n) {
|
|
"use strict";
|
|
|
|
function i(t, e) {
|
|
return t.native ? {
|
|
x: t.x,
|
|
y: t.y
|
|
} : u.getRelativePosition(t, e)
|
|
}
|
|
|
|
function a(t, e) {
|
|
var n, i, a, o, r;
|
|
for (i = 0, o = t.data.datasets.length; i < o; ++i)
|
|
if (t.isDatasetVisible(i))
|
|
for (a = 0, r = (n = t.getDatasetMeta(i)).data.length; a < r; ++a) {
|
|
var l = n.data[a];
|
|
l._view.skip || e(l)
|
|
}
|
|
}
|
|
|
|
function o(t, e) {
|
|
var n = [];
|
|
return a(t, function(t) {
|
|
t.inRange(e.x, e.y) && n.push(t)
|
|
}), n
|
|
}
|
|
|
|
function r(t, e, n, i) {
|
|
var o = Number.POSITIVE_INFINITY,
|
|
r = [];
|
|
return a(t, function(t) {
|
|
if (!n || t.inRange(e.x, e.y)) {
|
|
var a = t.getCenterPoint(),
|
|
l = i(e, a);
|
|
l < o ? (r = [t], o = l) : l === o && r.push(t)
|
|
}
|
|
}), r
|
|
}
|
|
|
|
function l(t) {
|
|
var e = -1 !== t.indexOf("x"),
|
|
n = -1 !== t.indexOf("y");
|
|
return function(t, i) {
|
|
var a = e ? Math.abs(t.x - i.x) : 0,
|
|
o = n ? Math.abs(t.y - i.y) : 0;
|
|
return Math.sqrt(Math.pow(a, 2) + Math.pow(o, 2))
|
|
}
|
|
}
|
|
|
|
function s(t, e, n) {
|
|
var a = i(e, t);
|
|
n.axis = n.axis || "x";
|
|
var s = l(n.axis),
|
|
u = n.intersect ? o(t, a) : r(t, a, !1, s),
|
|
d = [];
|
|
return u.length ? (t.data.datasets.forEach(function(e, n) {
|
|
if (t.isDatasetVisible(n)) {
|
|
var i = t.getDatasetMeta(n).data[u[0]._index];
|
|
i && !i._view.skip && d.push(i)
|
|
}
|
|
}), d) : []
|
|
}
|
|
var u = t(45);
|
|
e.exports = {
|
|
modes: {
|
|
single: function(t, e) {
|
|
var n = i(e, t),
|
|
o = [];
|
|
return a(t, function(t) {
|
|
if (t.inRange(n.x, n.y)) return o.push(t), o
|
|
}), o.slice(0, 1)
|
|
},
|
|
label: s,
|
|
index: s,
|
|
dataset: function(t, e, n) {
|
|
var a = i(e, t);
|
|
n.axis = n.axis || "xy";
|
|
var s = l(n.axis),
|
|
u = n.intersect ? o(t, a) : r(t, a, !1, s);
|
|
return u.length > 0 && (u = t.getDatasetMeta(u[0]._datasetIndex).data), u
|
|
},
|
|
"x-axis": function(t, e) {
|
|
return s(t, e, {
|
|
intersect: !0
|
|
})
|
|
},
|
|
point: function(t, e) {
|
|
return o(t, i(e, t))
|
|
},
|
|
nearest: function(t, e, n) {
|
|
var a = i(e, t);
|
|
n.axis = n.axis || "xy";
|
|
var o = l(n.axis),
|
|
s = r(t, a, n.intersect, o);
|
|
return s.length > 1 && s.sort(function(t, e) {
|
|
var n = t.getArea() - e.getArea();
|
|
return 0 === n && (n = t._datasetIndex - e._datasetIndex), n
|
|
}), s.slice(0, 1)
|
|
},
|
|
x: function(t, e, n) {
|
|
var o = i(e, t),
|
|
r = [],
|
|
l = !1;
|
|
return a(t, function(t) {
|
|
t.inXRange(o.x) && r.push(t), t.inRange(o.x, o.y) && (l = !0)
|
|
}), n.intersect && !l && (r = []), r
|
|
},
|
|
y: function(t, e, n) {
|
|
var o = i(e, t),
|
|
r = [],
|
|
l = !1;
|
|
return a(t, function(t) {
|
|
t.inYRange(o.y) && r.push(t), t.inRange(o.x, o.y) && (l = !0)
|
|
}), n.intersect && !l && (r = []), r
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
45: 45
|
|
}],
|
|
29: [function(t, e, n) {
|
|
"use strict";
|
|
t(25)._set("global", {
|
|
responsive: !0,
|
|
responsiveAnimationDuration: 0,
|
|
maintainAspectRatio: !0,
|
|
events: ["mousemove", "mouseout", "click", "touchstart", "touchmove"],
|
|
hover: {
|
|
onHover: null,
|
|
mode: "nearest",
|
|
intersect: !0,
|
|
animationDuration: 400
|
|
},
|
|
onClick: null,
|
|
defaultColor: "rgba(0,0,0,0.1)",
|
|
defaultFontColor: "#666",
|
|
defaultFontFamily: "'Helvetica Neue', 'Helvetica', 'Arial', sans-serif",
|
|
defaultFontSize: 12,
|
|
defaultFontStyle: "normal",
|
|
showLines: !0,
|
|
elements: {},
|
|
layout: {
|
|
padding: {
|
|
top: 0,
|
|
right: 0,
|
|
bottom: 0,
|
|
left: 0
|
|
}
|
|
}
|
|
}), e.exports = function() {
|
|
var t = function(t, e) {
|
|
return this.construct(t, e), this
|
|
};
|
|
return t.Chart = t, t
|
|
}
|
|
}, {
|
|
25: 25
|
|
}],
|
|
30: [function(t, e, n) {
|
|
"use strict";
|
|
var i = t(45);
|
|
e.exports = function(t) {
|
|
function e(t, e) {
|
|
return i.where(t, function(t) {
|
|
return t.position === e
|
|
})
|
|
}
|
|
|
|
function n(t, e) {
|
|
t.forEach(function(t, e) {
|
|
return t._tmpIndex_ = e, t
|
|
}), t.sort(function(t, n) {
|
|
var i = e ? n : t,
|
|
a = e ? t : n;
|
|
return i.weight === a.weight ? i._tmpIndex_ - a._tmpIndex_ : i.weight - a.weight
|
|
}), t.forEach(function(t) {
|
|
delete t._tmpIndex_
|
|
})
|
|
}
|
|
t.layoutService = {
|
|
defaults: {},
|
|
addBox: function(t, e) {
|
|
t.boxes || (t.boxes = []), e.fullWidth = e.fullWidth || !1, e.position = e.position || "top", e.weight = e.weight || 0, t.boxes.push(e)
|
|
},
|
|
removeBox: function(t, e) {
|
|
var n = t.boxes ? t.boxes.indexOf(e) : -1; - 1 !== n && t.boxes.splice(n, 1)
|
|
},
|
|
configure: function(t, e, n) {
|
|
for (var i, a = ["fullWidth", "position", "weight"], o = a.length, r = 0; r < o; ++r) i = a[r], n.hasOwnProperty(i) && (e[i] = n[i])
|
|
},
|
|
update: function(t, a, o) {
|
|
function r(t) {
|
|
var e = i.findNextWhere(_, function(e) {
|
|
return e.box === t
|
|
});
|
|
if (e)
|
|
if (t.isHorizontal()) {
|
|
var n = {
|
|
left: Math.max(T, D),
|
|
right: Math.max(F, I),
|
|
top: 0,
|
|
bottom: 0
|
|
};
|
|
t.update(t.fullWidth ? x : S, y / 2, n)
|
|
} else t.update(e.minSize.width, C)
|
|
}
|
|
|
|
function l(t) {
|
|
t.isHorizontal() ? (t.left = t.fullWidth ? d : T, t.right = t.fullWidth ? a - c : T + S, t.top = V, t.bottom = V + t.height, V = t.bottom) : (t.left = N, t.right = N + t.width, t.top = O, t.bottom = O + C, N = t.right)
|
|
}
|
|
if (t) {
|
|
var s = t.options.layout || {},
|
|
u = i.options.toPadding(s.padding),
|
|
d = u.left,
|
|
c = u.right,
|
|
h = u.top,
|
|
f = u.bottom,
|
|
g = e(t.boxes, "left"),
|
|
p = e(t.boxes, "right"),
|
|
v = e(t.boxes, "top"),
|
|
m = e(t.boxes, "bottom"),
|
|
b = e(t.boxes, "chartArea");
|
|
n(g, !0), n(p, !1), n(v, !0), n(m, !1);
|
|
var x = a - d - c,
|
|
y = o - h - f,
|
|
k = y / 2,
|
|
w = (a - x / 2) / (g.length + p.length),
|
|
M = (o - k) / (v.length + m.length),
|
|
S = x,
|
|
C = y,
|
|
_ = [];
|
|
i.each(g.concat(p, v, m), function(t) {
|
|
var e, n = t.isHorizontal();
|
|
n ? (e = t.update(t.fullWidth ? x : S, M), C -= e.height) : (e = t.update(w, k), S -= e.width), _.push({
|
|
horizontal: n,
|
|
minSize: e,
|
|
box: t
|
|
})
|
|
});
|
|
var D = 0,
|
|
I = 0,
|
|
P = 0,
|
|
A = 0;
|
|
i.each(v.concat(m), function(t) {
|
|
if (t.getPadding) {
|
|
var e = t.getPadding();
|
|
D = Math.max(D, e.left), I = Math.max(I, e.right)
|
|
}
|
|
}), i.each(g.concat(p), function(t) {
|
|
if (t.getPadding) {
|
|
var e = t.getPadding();
|
|
P = Math.max(P, e.top), A = Math.max(A, e.bottom)
|
|
}
|
|
});
|
|
var T = d,
|
|
F = c,
|
|
O = h,
|
|
R = f;
|
|
i.each(g.concat(p), r), i.each(g, function(t) {
|
|
T += t.width
|
|
}), i.each(p, function(t) {
|
|
F += t.width
|
|
}), i.each(v.concat(m), r), i.each(v, function(t) {
|
|
O += t.height
|
|
}), i.each(m, function(t) {
|
|
R += t.height
|
|
}), i.each(g.concat(p), function(t) {
|
|
var e = i.findNextWhere(_, function(e) {
|
|
return e.box === t
|
|
}),
|
|
n = {
|
|
left: 0,
|
|
right: 0,
|
|
top: O,
|
|
bottom: R
|
|
};
|
|
e && t.update(e.minSize.width, C, n)
|
|
}), T = d, F = c, O = h, R = f, i.each(g, function(t) {
|
|
T += t.width
|
|
}), i.each(p, function(t) {
|
|
F += t.width
|
|
}), i.each(v, function(t) {
|
|
O += t.height
|
|
}), i.each(m, function(t) {
|
|
R += t.height
|
|
});
|
|
var L = Math.max(D - T, 0);
|
|
T += L, F += Math.max(I - F, 0);
|
|
var z = Math.max(P - O, 0);
|
|
O += z, R += Math.max(A - R, 0);
|
|
var B = o - O - R,
|
|
W = a - T - F;
|
|
W === S && B === C || (i.each(g, function(t) {
|
|
t.height = B
|
|
}), i.each(p, function(t) {
|
|
t.height = B
|
|
}), i.each(v, function(t) {
|
|
t.fullWidth || (t.width = W)
|
|
}), i.each(m, function(t) {
|
|
t.fullWidth || (t.width = W)
|
|
}), C = B, S = W);
|
|
var N = d + L,
|
|
V = h + z;
|
|
i.each(g.concat(v), l), N += S, V += C, i.each(p, l), i.each(m, l), t.chartArea = {
|
|
left: T,
|
|
top: O,
|
|
right: T + S,
|
|
bottom: O + C
|
|
}, i.each(b, function(e) {
|
|
e.left = t.chartArea.left, e.top = t.chartArea.top, e.right = t.chartArea.right, e.bottom = t.chartArea.bottom, e.update(S, C)
|
|
})
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
45: 45
|
|
}],
|
|
31: [function(t, e, n) {
|
|
"use strict";
|
|
var i = t(25),
|
|
a = t(26),
|
|
o = t(45);
|
|
i._set("global", {
|
|
plugins: {}
|
|
}), e.exports = function(t) {
|
|
t.plugins = {
|
|
_plugins: [],
|
|
_cacheId: 0,
|
|
register: function(t) {
|
|
var e = this._plugins;
|
|
[].concat(t).forEach(function(t) {
|
|
-1 === e.indexOf(t) && e.push(t)
|
|
}), this._cacheId++
|
|
},
|
|
unregister: function(t) {
|
|
var e = this._plugins;
|
|
[].concat(t).forEach(function(t) {
|
|
var n = e.indexOf(t); - 1 !== n && e.splice(n, 1)
|
|
}), this._cacheId++
|
|
},
|
|
clear: function() {
|
|
this._plugins = [], this._cacheId++
|
|
},
|
|
count: function() {
|
|
return this._plugins.length
|
|
},
|
|
getAll: function() {
|
|
return this._plugins
|
|
},
|
|
notify: function(t, e, n) {
|
|
var i, a, o, r, l, s = this.descriptors(t),
|
|
u = s.length;
|
|
for (i = 0; i < u; ++i)
|
|
if (a = s[i], o = a.plugin, "function" == typeof(l = o[e]) && ((r = [t].concat(n || [])).push(a.options), !1 === l.apply(o, r))) return !1;
|
|
return !0
|
|
},
|
|
descriptors: function(t) {
|
|
var e = t._plugins || (t._plugins = {});
|
|
if (e.id === this._cacheId) return e.descriptors;
|
|
var n = [],
|
|
a = [],
|
|
r = t && t.config || {},
|
|
l = r.options && r.options.plugins || {};
|
|
return this._plugins.concat(r.plugins || []).forEach(function(t) {
|
|
if (-1 === n.indexOf(t)) {
|
|
var e = t.id,
|
|
r = l[e];
|
|
!1 !== r && (!0 === r && (r = o.clone(i.global.plugins[e])), n.push(t), a.push({
|
|
plugin: t,
|
|
options: r || {}
|
|
}))
|
|
}
|
|
}), e.descriptors = a, e.id = this._cacheId, a
|
|
}
|
|
}, t.pluginService = t.plugins, t.PluginBase = a.extend({})
|
|
}
|
|
}, {
|
|
25: 25,
|
|
26: 26,
|
|
45: 45
|
|
}],
|
|
32: [function(t, e, n) {
|
|
"use strict";
|
|
|
|
function i(t) {
|
|
var e, n, i = [];
|
|
for (e = 0, n = t.length; e < n; ++e) i.push(t[e].label);
|
|
return i
|
|
}
|
|
|
|
function a(t, e, n) {
|
|
var i = t.getPixelForTick(e);
|
|
return n && (i -= 0 === e ? (t.getPixelForTick(1) - i) / 2 : (i - t.getPixelForTick(e - 1)) / 2), i
|
|
}
|
|
var o = t(25),
|
|
r = t(26),
|
|
l = t(45),
|
|
s = t(34);
|
|
o._set("scale", {
|
|
display: !0,
|
|
position: "left",
|
|
offset: !1,
|
|
gridLines: {
|
|
display: !0,
|
|
color: "rgba(0, 0, 0, 0.1)",
|
|
lineWidth: 1,
|
|
drawBorder: !0,
|
|
drawOnChartArea: !0,
|
|
drawTicks: !0,
|
|
tickMarkLength: 10,
|
|
zeroLineWidth: 1,
|
|
zeroLineColor: "rgba(0,0,0,0.25)",
|
|
zeroLineBorderDash: [],
|
|
zeroLineBorderDashOffset: 0,
|
|
offsetGridLines: !1,
|
|
borderDash: [],
|
|
borderDashOffset: 0
|
|
},
|
|
scaleLabel: {
|
|
display: !1,
|
|
labelString: "",
|
|
lineHeight: 1.2,
|
|
padding: {
|
|
top: 4,
|
|
bottom: 4
|
|
}
|
|
},
|
|
ticks: {
|
|
beginAtZero: !1,
|
|
minRotation: 0,
|
|
maxRotation: 50,
|
|
mirror: !1,
|
|
padding: 0,
|
|
reverse: !1,
|
|
display: !0,
|
|
autoSkip: !0,
|
|
autoSkipPadding: 0,
|
|
labelOffset: 0,
|
|
callback: s.formatters.values,
|
|
minor: {},
|
|
major: {}
|
|
}
|
|
}), e.exports = function(t) {
|
|
function e(t, e, n) {
|
|
return l.isArray(e) ? l.longestText(t, n, e) : t.measureText(e).width
|
|
}
|
|
|
|
function n(t) {
|
|
var e = l.valueOrDefault,
|
|
n = o.global,
|
|
i = e(t.fontSize, n.defaultFontSize),
|
|
a = e(t.fontStyle, n.defaultFontStyle),
|
|
r = e(t.fontFamily, n.defaultFontFamily);
|
|
return {
|
|
size: i,
|
|
style: a,
|
|
family: r,
|
|
font: l.fontString(i, a, r)
|
|
}
|
|
}
|
|
|
|
function s(t) {
|
|
return l.options.toLineHeight(l.valueOrDefault(t.lineHeight, 1.2), l.valueOrDefault(t.fontSize, o.global.defaultFontSize))
|
|
}
|
|
t.Scale = r.extend({
|
|
getPadding: function() {
|
|
var t = this;
|
|
return {
|
|
left: t.paddingLeft || 0,
|
|
top: t.paddingTop || 0,
|
|
right: t.paddingRight || 0,
|
|
bottom: t.paddingBottom || 0
|
|
}
|
|
},
|
|
getTicks: function() {
|
|
return this._ticks
|
|
},
|
|
mergeTicksOptions: function() {
|
|
var t = this.options.ticks;
|
|
!1 === t.minor && (t.minor = {
|
|
display: !1
|
|
}), !1 === t.major && (t.major = {
|
|
display: !1
|
|
});
|
|
for (var e in t) "major" !== e && "minor" !== e && (void 0 === t.minor[e] && (t.minor[e] = t[e]), void 0 === t.major[e] && (t.major[e] = t[e]))
|
|
},
|
|
beforeUpdate: function() {
|
|
l.callback(this.options.beforeUpdate, [this])
|
|
},
|
|
update: function(t, e, n) {
|
|
var i, a, o, r, s, u, d = this;
|
|
for (d.beforeUpdate(), d.maxWidth = t, d.maxHeight = e, d.margins = l.extend({
|
|
left: 0,
|
|
right: 0,
|
|
top: 0,
|
|
bottom: 0
|
|
}, n), d.longestTextCache = d.longestTextCache || {}, d.beforeSetDimensions(), d.setDimensions(), d.afterSetDimensions(), d.beforeDataLimits(), d.determineDataLimits(), d.afterDataLimits(), d.beforeBuildTicks(), s = d.buildTicks() || [], d.afterBuildTicks(), d.beforeTickToLabelConversion(), o = d.convertTicksToLabels(s) || d.ticks, d.afterTickToLabelConversion(), d.ticks = o, i = 0, a = o.length; i < a; ++i) r = o[i], (u = s[i]) ? u.label = r : s.push(u = {
|
|
label: r,
|
|
major: !1
|
|
});
|
|
return d._ticks = s, d.beforeCalculateTickRotation(), d.calculateTickRotation(), d.afterCalculateTickRotation(), d.beforeFit(), d.fit(), d.afterFit(), d.afterUpdate(), d.minSize
|
|
},
|
|
afterUpdate: function() {
|
|
l.callback(this.options.afterUpdate, [this])
|
|
},
|
|
beforeSetDimensions: function() {
|
|
l.callback(this.options.beforeSetDimensions, [this])
|
|
},
|
|
setDimensions: function() {
|
|
var t = this;
|
|
t.isHorizontal() ? (t.width = t.maxWidth, t.left = 0, t.right = t.width) : (t.height = t.maxHeight, t.top = 0, t.bottom = t.height), t.paddingLeft = 0, t.paddingTop = 0, t.paddingRight = 0, t.paddingBottom = 0
|
|
},
|
|
afterSetDimensions: function() {
|
|
l.callback(this.options.afterSetDimensions, [this])
|
|
},
|
|
beforeDataLimits: function() {
|
|
l.callback(this.options.beforeDataLimits, [this])
|
|
},
|
|
determineDataLimits: l.noop,
|
|
afterDataLimits: function() {
|
|
l.callback(this.options.afterDataLimits, [this])
|
|
},
|
|
beforeBuildTicks: function() {
|
|
l.callback(this.options.beforeBuildTicks, [this])
|
|
},
|
|
buildTicks: l.noop,
|
|
afterBuildTicks: function() {
|
|
l.callback(this.options.afterBuildTicks, [this])
|
|
},
|
|
beforeTickToLabelConversion: function() {
|
|
l.callback(this.options.beforeTickToLabelConversion, [this])
|
|
},
|
|
convertTicksToLabels: function() {
|
|
var t = this,
|
|
e = t.options.ticks;
|
|
t.ticks = t.ticks.map(e.userCallback || e.callback, this)
|
|
},
|
|
afterTickToLabelConversion: function() {
|
|
l.callback(this.options.afterTickToLabelConversion, [this])
|
|
},
|
|
beforeCalculateTickRotation: function() {
|
|
l.callback(this.options.beforeCalculateTickRotation, [this])
|
|
},
|
|
calculateTickRotation: function() {
|
|
var t = this,
|
|
e = t.ctx,
|
|
a = t.options.ticks,
|
|
o = i(t._ticks),
|
|
r = n(a);
|
|
e.font = r.font;
|
|
var s = a.minRotation || 0;
|
|
if (o.length && t.options.display && t.isHorizontal())
|
|
for (var u, d = l.longestText(e, r.font, o, t.longestTextCache), c = d, h = t.getPixelForTick(1) - t.getPixelForTick(0) - 6; c > h && s < a.maxRotation;) {
|
|
var f = l.toRadians(s);
|
|
if (u = Math.cos(f), Math.sin(f) * d > t.maxHeight) {
|
|
s--;
|
|
break
|
|
}
|
|
s++, c = u * d
|
|
}
|
|
t.labelRotation = s
|
|
},
|
|
afterCalculateTickRotation: function() {
|
|
l.callback(this.options.afterCalculateTickRotation, [this])
|
|
},
|
|
beforeFit: function() {
|
|
l.callback(this.options.beforeFit, [this])
|
|
},
|
|
fit: function() {
|
|
var t = this,
|
|
a = t.minSize = {
|
|
width: 0,
|
|
height: 0
|
|
},
|
|
o = i(t._ticks),
|
|
r = t.options,
|
|
u = r.ticks,
|
|
d = r.scaleLabel,
|
|
c = r.gridLines,
|
|
h = r.display,
|
|
f = t.isHorizontal(),
|
|
g = n(u),
|
|
p = r.gridLines.tickMarkLength;
|
|
if (a.width = f ? t.isFullWidth() ? t.maxWidth - t.margins.left - t.margins.right : t.maxWidth : h && c.drawTicks ? p : 0, a.height = f ? h && c.drawTicks ? p : 0 : t.maxHeight, d.display && h) {
|
|
var v = s(d) + l.options.toPadding(d.padding).height;
|
|
f ? a.height += v : a.width += v
|
|
}
|
|
if (u.display && h) {
|
|
var m = l.longestText(t.ctx, g.font, o, t.longestTextCache),
|
|
b = l.numberOfLabelLines(o),
|
|
x = .5 * g.size,
|
|
y = t.options.ticks.padding;
|
|
if (f) {
|
|
t.longestLabelWidth = m;
|
|
var k = l.toRadians(t.labelRotation),
|
|
w = Math.cos(k),
|
|
M = Math.sin(k) * m + g.size * b + x * (b - 1) + x;
|
|
a.height = Math.min(t.maxHeight, a.height + M + y), t.ctx.font = g.font;
|
|
var S = e(t.ctx, o[0], g.font),
|
|
C = e(t.ctx, o[o.length - 1], g.font);
|
|
0 !== t.labelRotation ? (t.paddingLeft = "bottom" === r.position ? w * S + 3 : w * x + 3, t.paddingRight = "bottom" === r.position ? w * x + 3 : w * C + 3) : (t.paddingLeft = S / 2 + 3, t.paddingRight = C / 2 + 3)
|
|
} else u.mirror ? m = 0 : m += y + x, a.width = Math.min(t.maxWidth, a.width + m), t.paddingTop = g.size / 2, t.paddingBottom = g.size / 2
|
|
}
|
|
t.handleMargins(), t.width = a.width, t.height = a.height
|
|
},
|
|
handleMargins: function() {
|
|
var t = this;
|
|
t.margins && (t.paddingLeft = Math.max(t.paddingLeft - t.margins.left, 0), t.paddingTop = Math.max(t.paddingTop - t.margins.top, 0), t.paddingRight = Math.max(t.paddingRight - t.margins.right, 0), t.paddingBottom = Math.max(t.paddingBottom - t.margins.bottom, 0))
|
|
},
|
|
afterFit: function() {
|
|
l.callback(this.options.afterFit, [this])
|
|
},
|
|
isHorizontal: function() {
|
|
return "top" === this.options.position || "bottom" === this.options.position
|
|
},
|
|
isFullWidth: function() {
|
|
return this.options.fullWidth
|
|
},
|
|
getRightValue: function(t) {
|
|
if (l.isNullOrUndef(t)) return NaN;
|
|
if ("number" == typeof t && !isFinite(t)) return NaN;
|
|
if (t)
|
|
if (this.isHorizontal()) {
|
|
if (void 0 !== t.x) return this.getRightValue(t.x)
|
|
} else if (void 0 !== t.y) return this.getRightValue(t.y);
|
|
return t
|
|
},
|
|
getLabelForIndex: l.noop,
|
|
getPixelForValue: l.noop,
|
|
getValueForPixel: l.noop,
|
|
getPixelForTick: function(t) {
|
|
var e = this,
|
|
n = e.options.offset;
|
|
if (e.isHorizontal()) {
|
|
var i = (e.width - (e.paddingLeft + e.paddingRight)) / Math.max(e._ticks.length - (n ? 0 : 1), 1),
|
|
a = i * t + e.paddingLeft;
|
|
n && (a += i / 2);
|
|
var o = e.left + Math.round(a);
|
|
return o += e.isFullWidth() ? e.margins.left : 0
|
|
}
|
|
var r = e.height - (e.paddingTop + e.paddingBottom);
|
|
return e.top + t * (r / (e._ticks.length - 1))
|
|
},
|
|
getPixelForDecimal: function(t) {
|
|
var e = this;
|
|
if (e.isHorizontal()) {
|
|
var n = (e.width - (e.paddingLeft + e.paddingRight)) * t + e.paddingLeft,
|
|
i = e.left + Math.round(n);
|
|
return i += e.isFullWidth() ? e.margins.left : 0
|
|
}
|
|
return e.top + t * e.height
|
|
},
|
|
getBasePixel: function() {
|
|
return this.getPixelForValue(this.getBaseValue())
|
|
},
|
|
getBaseValue: function() {
|
|
var t = this,
|
|
e = t.min,
|
|
n = t.max;
|
|
return t.beginAtZero ? 0 : e < 0 && n < 0 ? n : e > 0 && n > 0 ? e : 0
|
|
},
|
|
_autoSkip: function(t) {
|
|
var e, n, i, a, o = this,
|
|
r = o.isHorizontal(),
|
|
s = o.options.ticks.minor,
|
|
u = t.length,
|
|
d = l.toRadians(o.labelRotation),
|
|
c = Math.cos(d),
|
|
h = o.longestLabelWidth * c,
|
|
f = [];
|
|
for (s.maxTicksLimit && (a = s.maxTicksLimit), r && (e = !1, (h + s.autoSkipPadding) * u > o.width - (o.paddingLeft + o.paddingRight) && (e = 1 + Math.floor((h + s.autoSkipPadding) * u / (o.width - (o.paddingLeft + o.paddingRight)))), a && u > a && (e = Math.max(e, Math.floor(u / a)))), n = 0; n < u; n++) i = t[n], ((e > 1 && n % e > 0 || n % e == 0 && n + e >= u) && n !== u - 1 || l.isNullOrUndef(i.label)) && delete i.label, f.push(i);
|
|
return f
|
|
},
|
|
draw: function(t) {
|
|
var e = this,
|
|
i = e.options;
|
|
if (i.display) {
|
|
var r = e.ctx,
|
|
u = o.global,
|
|
d = i.ticks.minor,
|
|
c = i.ticks.major || d,
|
|
h = i.gridLines,
|
|
f = i.scaleLabel,
|
|
g = 0 !== e.labelRotation,
|
|
p = e.isHorizontal(),
|
|
v = d.autoSkip ? e._autoSkip(e.getTicks()) : e.getTicks(),
|
|
m = l.valueOrDefault(d.fontColor, u.defaultFontColor),
|
|
b = n(d),
|
|
x = l.valueOrDefault(c.fontColor, u.defaultFontColor),
|
|
y = n(c),
|
|
k = h.drawTicks ? h.tickMarkLength : 0,
|
|
w = l.valueOrDefault(f.fontColor, u.defaultFontColor),
|
|
M = n(f),
|
|
S = l.options.toPadding(f.padding),
|
|
C = l.toRadians(e.labelRotation),
|
|
_ = [],
|
|
D = "right" === i.position ? e.left : e.right - k,
|
|
I = "right" === i.position ? e.left + k : e.right,
|
|
P = "bottom" === i.position ? e.top : e.bottom - k,
|
|
A = "bottom" === i.position ? e.top + k : e.bottom;
|
|
if (l.each(v, function(n, o) {
|
|
if (void 0 !== n.label) {
|
|
var r, s, c, f, m = n.label;
|
|
o === e.zeroLineIndex && i.offset === h.offsetGridLines ? (r = h.zeroLineWidth, s = h.zeroLineColor, c = h.zeroLineBorderDash, f = h.zeroLineBorderDashOffset) : (r = l.valueAtIndexOrDefault(h.lineWidth, o), s = l.valueAtIndexOrDefault(h.color, o), c = l.valueOrDefault(h.borderDash, u.borderDash), f = l.valueOrDefault(h.borderDashOffset, u.borderDashOffset));
|
|
var b, x, y, w, M, S, T, F, O, R, L = "middle",
|
|
z = "middle",
|
|
B = d.padding;
|
|
if (p) {
|
|
var W = k + B;
|
|
"bottom" === i.position ? (z = g ? "middle" : "top", L = g ? "right" : "center", R = e.top + W) : (z = g ? "middle" : "bottom", L = g ? "left" : "center", R = e.bottom - W);
|
|
var N = a(e, o, h.offsetGridLines && v.length > 1);
|
|
N < e.left && (s = "rgba(0,0,0,0)"), N += l.aliasPixel(r), O = e.getPixelForTick(o) + d.labelOffset, b = y = M = T = N, x = P, w = A, S = t.top, F = t.bottom
|
|
} else {
|
|
var V, E = "left" === i.position;
|
|
d.mirror ? (L = E ? "left" : "right", V = B) : (L = E ? "right" : "left", V = k + B), O = E ? e.right - V : e.left + V;
|
|
var H = a(e, o, h.offsetGridLines && v.length > 1);
|
|
H < e.top && (s = "rgba(0,0,0,0)"), H += l.aliasPixel(r), R = e.getPixelForTick(o) + d.labelOffset, b = D, y = I, M = t.left, T = t.right, x = w = S = F = H
|
|
}
|
|
_.push({
|
|
tx1: b,
|
|
ty1: x,
|
|
tx2: y,
|
|
ty2: w,
|
|
x1: M,
|
|
y1: S,
|
|
x2: T,
|
|
y2: F,
|
|
labelX: O,
|
|
labelY: R,
|
|
glWidth: r,
|
|
glColor: s,
|
|
glBorderDash: c,
|
|
glBorderDashOffset: f,
|
|
rotation: -1 * C,
|
|
label: m,
|
|
major: n.major,
|
|
textBaseline: z,
|
|
textAlign: L
|
|
})
|
|
}
|
|
}), l.each(_, function(t) {
|
|
if (h.display && (r.save(), r.lineWidth = t.glWidth, r.strokeStyle = t.glColor, r.setLineDash && (r.setLineDash(t.glBorderDash), r.lineDashOffset = t.glBorderDashOffset), r.beginPath(), h.drawTicks && (r.moveTo(t.tx1, t.ty1), r.lineTo(t.tx2, t.ty2)), h.drawOnChartArea && (r.moveTo(t.x1, t.y1), r.lineTo(t.x2, t.y2)), r.stroke(), r.restore()), d.display) {
|
|
r.save(), r.translate(t.labelX, t.labelY), r.rotate(t.rotation), r.font = t.major ? y.font : b.font, r.fillStyle = t.major ? x : m, r.textBaseline = t.textBaseline, r.textAlign = t.textAlign;
|
|
var e = t.label;
|
|
if (l.isArray(e))
|
|
for (var n = 0, i = 0; n < e.length; ++n) r.fillText("" + e[n], 0, i), i += 1.5 * b.size;
|
|
else r.fillText(e, 0, 0);
|
|
r.restore()
|
|
}
|
|
}), f.display) {
|
|
var T, F, O = 0,
|
|
R = s(f) / 2;
|
|
if (p) T = e.left + (e.right - e.left) / 2, F = "bottom" === i.position ? e.bottom - R - S.bottom : e.top + R + S.top;
|
|
else {
|
|
var L = "left" === i.position;
|
|
T = L ? e.left + R + S.top : e.right - R - S.top, F = e.top + (e.bottom - e.top) / 2, O = L ? -.5 * Math.PI : .5 * Math.PI
|
|
}
|
|
r.save(), r.translate(T, F), r.rotate(O), r.textAlign = "center", r.textBaseline = "middle", r.fillStyle = w, r.font = M.font, r.fillText(f.labelString, 0, 0), r.restore()
|
|
}
|
|
if (h.drawBorder) {
|
|
r.lineWidth = l.valueAtIndexOrDefault(h.lineWidth, 0), r.strokeStyle = l.valueAtIndexOrDefault(h.color, 0);
|
|
var z = e.left,
|
|
B = e.right,
|
|
W = e.top,
|
|
N = e.bottom,
|
|
V = l.aliasPixel(r.lineWidth);
|
|
p ? (W = N = "top" === i.position ? e.bottom : e.top, W += V, N += V) : (z = B = "left" === i.position ? e.right : e.left, z += V, B += V), r.beginPath(), r.moveTo(z, W), r.lineTo(B, N), r.stroke()
|
|
}
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}, {
|
|
25: 25,
|
|
26: 26,
|
|
34: 34,
|
|
45: 45
|
|
}],
|
|
33: [function(t, e, n) {
|
|
"use strict";
|
|
var i = t(25),
|
|
a = t(45);
|
|
e.exports = function(t) {
|
|
t.scaleService = {
|
|
constructors: {},
|
|
defaults: {},
|
|
registerScaleType: function(t, e, n) {
|
|
this.constructors[t] = e, this.defaults[t] = a.clone(n)
|
|
},
|
|
getScaleConstructor: function(t) {
|
|
return this.constructors.hasOwnProperty(t) ? this.constructors[t] : void 0
|
|
},
|
|
getScaleDefaults: function(t) {
|
|
return this.defaults.hasOwnProperty(t) ? a.merge({}, [i.scale, this.defaults[t]]) : {}
|
|
},
|
|
updateScaleDefaults: function(t, e) {
|
|
var n = this;
|
|
n.defaults.hasOwnProperty(t) && (n.defaults[t] = a.extend(n.defaults[t], e))
|
|
},
|
|
addScalesToLayout: function(e) {
|
|
a.each(e.scales, function(n) {
|
|
n.fullWidth = n.options.fullWidth, n.position = n.options.position, n.weight = n.options.weight, t.layoutService.addBox(e, n)
|
|
})
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
25: 25,
|
|
45: 45
|
|
}],
|
|
34: [function(t, e, n) {
|
|
"use strict";
|
|
var i = t(45);
|
|
e.exports = {
|
|
generators: {
|
|
linear: function(t, e) {
|
|
var n, a = [];
|
|
if (t.stepSize && t.stepSize > 0) n = t.stepSize;
|
|
else {
|
|
var o = i.niceNum(e.max - e.min, !1);
|
|
n = i.niceNum(o / (t.maxTicks - 1), !0)
|
|
}
|
|
var r = Math.floor(e.min / n) * n,
|
|
l = Math.ceil(e.max / n) * n;
|
|
t.min && t.max && t.stepSize && i.almostWhole((t.max - t.min) / t.stepSize, n / 1e3) && (r = t.min, l = t.max);
|
|
var s = (l - r) / n;
|
|
s = i.almostEquals(s, Math.round(s), n / 1e3) ? Math.round(s) : Math.ceil(s), a.push(void 0 !== t.min ? t.min : r);
|
|
for (var u = 1; u < s; ++u) a.push(r + u * n);
|
|
return a.push(void 0 !== t.max ? t.max : l), a
|
|
},
|
|
logarithmic: function(t, e) {
|
|
var n, a, o = [],
|
|
r = i.valueOrDefault,
|
|
l = r(t.min, Math.pow(10, Math.floor(i.log10(e.min)))),
|
|
s = Math.floor(i.log10(e.max)),
|
|
u = Math.ceil(e.max / Math.pow(10, s));
|
|
0 === l ? (n = Math.floor(i.log10(e.minNotZero)), a = Math.floor(e.minNotZero / Math.pow(10, n)), o.push(l), l = a * Math.pow(10, n)) : (n = Math.floor(i.log10(l)), a = Math.floor(l / Math.pow(10, n)));
|
|
do {
|
|
o.push(l), 10 === ++a && (a = 1, ++n), l = a * Math.pow(10, n)
|
|
} while (n < s || n === s && a < u);
|
|
var d = r(t.max, l);
|
|
return o.push(d), o
|
|
}
|
|
},
|
|
formatters: {
|
|
values: function(t) {
|
|
return i.isArray(t) ? t : "" + t
|
|
},
|
|
linear: function(t, e, n) {
|
|
var a = n.length > 3 ? n[2] - n[1] : n[1] - n[0];
|
|
Math.abs(a) > 1 && t !== Math.floor(t) && (a = t - Math.floor(t));
|
|
var o = i.log10(Math.abs(a)),
|
|
r = "";
|
|
if (0 !== t) {
|
|
var l = -1 * Math.floor(o);
|
|
l = Math.max(Math.min(l, 20), 0), r = t.toFixed(l)
|
|
} else r = "0";
|
|
return r
|
|
},
|
|
logarithmic: function(t, e, n) {
|
|
var a = t / Math.pow(10, Math.floor(i.log10(t)));
|
|
return 0 === t ? "0" : 1 === a || 2 === a || 5 === a || 0 === e || e === n.length - 1 ? t.toExponential() : ""
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
45: 45
|
|
}],
|
|
35: [function(t, e, n) {
|
|
"use strict";
|
|
var i = t(25),
|
|
a = t(26),
|
|
o = t(45);
|
|
i._set("global", {
|
|
tooltips: {
|
|
enabled: !0,
|
|
custom: null,
|
|
mode: "nearest",
|
|
position: "average",
|
|
intersect: !0,
|
|
backgroundColor: "rgba(0,0,0,0.8)",
|
|
titleFontStyle: "bold",
|
|
titleSpacing: 2,
|
|
titleMarginBottom: 6,
|
|
titleFontColor: "#fff",
|
|
titleAlign: "left",
|
|
bodySpacing: 2,
|
|
bodyFontColor: "#fff",
|
|
bodyAlign: "left",
|
|
footerFontStyle: "bold",
|
|
footerSpacing: 2,
|
|
footerMarginTop: 6,
|
|
footerFontColor: "#fff",
|
|
footerAlign: "left",
|
|
yPadding: 6,
|
|
xPadding: 6,
|
|
caretPadding: 2,
|
|
caretSize: 5,
|
|
cornerRadius: 6,
|
|
multiKeyBackground: "#fff",
|
|
displayColors: !0,
|
|
borderColor: "rgba(0,0,0,0)",
|
|
borderWidth: 0,
|
|
callbacks: {
|
|
beforeTitle: o.noop,
|
|
title: function(t, e) {
|
|
var n = "",
|
|
i = e.labels,
|
|
a = i ? i.length : 0;
|
|
if (t.length > 0) {
|
|
var o = t[0];
|
|
o.xLabel ? n = o.xLabel : a > 0 && o.index < a && (n = i[o.index])
|
|
}
|
|
return n
|
|
},
|
|
afterTitle: o.noop,
|
|
beforeBody: o.noop,
|
|
beforeLabel: o.noop,
|
|
label: function(t, e) {
|
|
var n = e.datasets[t.datasetIndex].label || "";
|
|
return n && (n += ": "), n += t.yLabel
|
|
},
|
|
labelColor: function(t, e) {
|
|
var n = e.getDatasetMeta(t.datasetIndex).data[t.index]._view;
|
|
return {
|
|
borderColor: n.borderColor,
|
|
backgroundColor: n.backgroundColor
|
|
}
|
|
},
|
|
labelTextColor: function() {
|
|
return this._options.bodyFontColor
|
|
},
|
|
afterLabel: o.noop,
|
|
afterBody: o.noop,
|
|
beforeFooter: o.noop,
|
|
footer: o.noop,
|
|
afterFooter: o.noop
|
|
}
|
|
}
|
|
}), e.exports = function(t) {
|
|
function e(t, e) {
|
|
var n = o.color(t);
|
|
return n.alpha(e * n.alpha()).rgbaString()
|
|
}
|
|
|
|
function n(t, e) {
|
|
return e && (o.isArray(e) ? Array.prototype.push.apply(t, e) : t.push(e)), t
|
|
}
|
|
|
|
function r(t) {
|
|
var e = t._xScale,
|
|
n = t._yScale || t._scale,
|
|
i = t._index,
|
|
a = t._datasetIndex;
|
|
return {
|
|
xLabel: e ? e.getLabelForIndex(i, a) : "",
|
|
yLabel: n ? n.getLabelForIndex(i, a) : "",
|
|
index: i,
|
|
datasetIndex: a,
|
|
x: t._model.x,
|
|
y: t._model.y
|
|
}
|
|
}
|
|
|
|
function l(t) {
|
|
var e = i.global,
|
|
n = o.valueOrDefault;
|
|
return {
|
|
xPadding: t.xPadding,
|
|
yPadding: t.yPadding,
|
|
xAlign: t.xAlign,
|
|
yAlign: t.yAlign,
|
|
bodyFontColor: t.bodyFontColor,
|
|
_bodyFontFamily: n(t.bodyFontFamily, e.defaultFontFamily),
|
|
_bodyFontStyle: n(t.bodyFontStyle, e.defaultFontStyle),
|
|
_bodyAlign: t.bodyAlign,
|
|
bodyFontSize: n(t.bodyFontSize, e.defaultFontSize),
|
|
bodySpacing: t.bodySpacing,
|
|
titleFontColor: t.titleFontColor,
|
|
_titleFontFamily: n(t.titleFontFamily, e.defaultFontFamily),
|
|
_titleFontStyle: n(t.titleFontStyle, e.defaultFontStyle),
|
|
titleFontSize: n(t.titleFontSize, e.defaultFontSize),
|
|
_titleAlign: t.titleAlign,
|
|
titleSpacing: t.titleSpacing,
|
|
titleMarginBottom: t.titleMarginBottom,
|
|
footerFontColor: t.footerFontColor,
|
|
_footerFontFamily: n(t.footerFontFamily, e.defaultFontFamily),
|
|
_footerFontStyle: n(t.footerFontStyle, e.defaultFontStyle),
|
|
footerFontSize: n(t.footerFontSize, e.defaultFontSize),
|
|
_footerAlign: t.footerAlign,
|
|
footerSpacing: t.footerSpacing,
|
|
footerMarginTop: t.footerMarginTop,
|
|
caretSize: t.caretSize,
|
|
cornerRadius: t.cornerRadius,
|
|
backgroundColor: t.backgroundColor,
|
|
opacity: 0,
|
|
legendColorBackground: t.multiKeyBackground,
|
|
displayColors: t.displayColors,
|
|
borderColor: t.borderColor,
|
|
borderWidth: t.borderWidth
|
|
}
|
|
}
|
|
|
|
function s(t, e) {
|
|
var n = t._chart.ctx,
|
|
i = 2 * e.yPadding,
|
|
a = 0,
|
|
r = e.body,
|
|
l = r.reduce(function(t, e) {
|
|
return t + e.before.length + e.lines.length + e.after.length
|
|
}, 0);
|
|
l += e.beforeBody.length + e.afterBody.length;
|
|
var s = e.title.length,
|
|
u = e.footer.length,
|
|
d = e.titleFontSize,
|
|
c = e.bodyFontSize,
|
|
h = e.footerFontSize;
|
|
i += s * d, i += s ? (s - 1) * e.titleSpacing : 0, i += s ? e.titleMarginBottom : 0, i += l * c, i += l ? (l - 1) * e.bodySpacing : 0, i += u ? e.footerMarginTop : 0, i += u * h, i += u ? (u - 1) * e.footerSpacing : 0;
|
|
var f = 0,
|
|
g = function(t) {
|
|
a = Math.max(a, n.measureText(t).width + f)
|
|
};
|
|
return n.font = o.fontString(d, e._titleFontStyle, e._titleFontFamily), o.each(e.title, g), n.font = o.fontString(c, e._bodyFontStyle, e._bodyFontFamily), o.each(e.beforeBody.concat(e.afterBody), g), f = e.displayColors ? c + 2 : 0, o.each(r, function(t) {
|
|
o.each(t.before, g), o.each(t.lines, g), o.each(t.after, g)
|
|
}), f = 0, n.font = o.fontString(h, e._footerFontStyle, e._footerFontFamily), o.each(e.footer, g), a += 2 * e.xPadding, {
|
|
width: a,
|
|
height: i
|
|
}
|
|
}
|
|
|
|
function u(t, e) {
|
|
var n = t._model,
|
|
i = t._chart,
|
|
a = t._chart.chartArea,
|
|
o = "center",
|
|
r = "center";
|
|
n.y < e.height ? r = "top" : n.y > i.height - e.height && (r = "bottom");
|
|
var l, s, u, d, c, h = (a.left + a.right) / 2,
|
|
f = (a.top + a.bottom) / 2;
|
|
"center" === r ? (l = function(t) {
|
|
return t <= h
|
|
}, s = function(t) {
|
|
return t > h
|
|
}) : (l = function(t) {
|
|
return t <= e.width / 2
|
|
}, s = function(t) {
|
|
return t >= i.width - e.width / 2
|
|
}), u = function(t) {
|
|
return t + e.width > i.width
|
|
}, d = function(t) {
|
|
return t - e.width < 0
|
|
}, c = function(t) {
|
|
return t <= f ? "top" : "bottom"
|
|
}, l(n.x) ? (o = "left", u(n.x) && (o = "center", r = c(n.y))) : s(n.x) && (o = "right", d(n.x) && (o = "center", r = c(n.y)));
|
|
var g = t._options;
|
|
return {
|
|
xAlign: g.xAlign ? g.xAlign : o,
|
|
yAlign: g.yAlign ? g.yAlign : r
|
|
}
|
|
}
|
|
|
|
function d(t, e, n) {
|
|
var i = t.x,
|
|
a = t.y,
|
|
o = t.caretSize,
|
|
r = t.caretPadding,
|
|
l = t.cornerRadius,
|
|
s = n.xAlign,
|
|
u = n.yAlign,
|
|
d = o + r,
|
|
c = l + r;
|
|
return "right" === s ? i -= e.width : "center" === s && (i -= e.width / 2), "top" === u ? a += d : a -= "bottom" === u ? e.height + d : e.height / 2, "center" === u ? "left" === s ? i += d : "right" === s && (i -= d) : "left" === s ? i -= c : "right" === s && (i += c), {
|
|
x: i,
|
|
y: a
|
|
}
|
|
}
|
|
t.Tooltip = a.extend({
|
|
initialize: function() {
|
|
this._model = l(this._options)
|
|
},
|
|
getTitle: function() {
|
|
var t = this,
|
|
e = t._options.callbacks,
|
|
i = e.beforeTitle.apply(t, arguments),
|
|
a = e.title.apply(t, arguments),
|
|
o = e.afterTitle.apply(t, arguments),
|
|
r = [];
|
|
return r = n(r, i), r = n(r, a), r = n(r, o)
|
|
},
|
|
getBeforeBody: function() {
|
|
var t = this._options.callbacks.beforeBody.apply(this, arguments);
|
|
return o.isArray(t) ? t : void 0 !== t ? [t] : []
|
|
},
|
|
getBody: function(t, e) {
|
|
var i = this,
|
|
a = i._options.callbacks,
|
|
r = [];
|
|
return o.each(t, function(t) {
|
|
var o = {
|
|
before: [],
|
|
lines: [],
|
|
after: []
|
|
};
|
|
n(o.before, a.beforeLabel.call(i, t, e)), n(o.lines, a.label.call(i, t, e)), n(o.after, a.afterLabel.call(i, t, e)), r.push(o)
|
|
}), r
|
|
},
|
|
getAfterBody: function() {
|
|
var t = this._options.callbacks.afterBody.apply(this, arguments);
|
|
return o.isArray(t) ? t : void 0 !== t ? [t] : []
|
|
},
|
|
getFooter: function() {
|
|
var t = this,
|
|
e = t._options.callbacks,
|
|
i = e.beforeFooter.apply(t, arguments),
|
|
a = e.footer.apply(t, arguments),
|
|
o = e.afterFooter.apply(t, arguments),
|
|
r = [];
|
|
return r = n(r, i), r = n(r, a), r = n(r, o)
|
|
},
|
|
update: function(e) {
|
|
var n, i, a = this,
|
|
c = a._options,
|
|
h = a._model,
|
|
f = a._model = l(c),
|
|
g = a._active,
|
|
p = a._data,
|
|
v = {
|
|
xAlign: h.xAlign,
|
|
yAlign: h.yAlign
|
|
},
|
|
m = {
|
|
x: h.x,
|
|
y: h.y
|
|
},
|
|
b = {
|
|
width: h.width,
|
|
height: h.height
|
|
},
|
|
x = {
|
|
x: h.caretX,
|
|
y: h.caretY
|
|
};
|
|
if (g.length) {
|
|
f.opacity = 1;
|
|
var y = [],
|
|
k = [];
|
|
x = t.Tooltip.positioners[c.position](g, a._eventPosition);
|
|
var w = [];
|
|
for (n = 0, i = g.length; n < i; ++n) w.push(r(g[n]));
|
|
c.filter && (w = w.filter(function(t) {
|
|
return c.filter(t, p)
|
|
})), c.itemSort && (w = w.sort(function(t, e) {
|
|
return c.itemSort(t, e, p)
|
|
})), o.each(w, function(t) {
|
|
y.push(c.callbacks.labelColor.call(a, t, a._chart)), k.push(c.callbacks.labelTextColor.call(a, t, a._chart))
|
|
}), f.title = a.getTitle(w, p), f.beforeBody = a.getBeforeBody(w, p), f.body = a.getBody(w, p), f.afterBody = a.getAfterBody(w, p), f.footer = a.getFooter(w, p), f.x = Math.round(x.x), f.y = Math.round(x.y), f.caretPadding = c.caretPadding, f.labelColors = y, f.labelTextColors = k, f.dataPoints = w, m = d(f, b = s(this, f), v = u(this, b))
|
|
} else f.opacity = 0;
|
|
return f.xAlign = v.xAlign, f.yAlign = v.yAlign, f.x = m.x, f.y = m.y, f.width = b.width, f.height = b.height, f.caretX = x.x, f.caretY = x.y, a._model = f, e && c.custom && c.custom.call(a, f), a
|
|
},
|
|
drawCaret: function(t, e) {
|
|
var n = this._chart.ctx,
|
|
i = this._view,
|
|
a = this.getCaretPosition(t, e, i);
|
|
n.lineTo(a.x1, a.y1), n.lineTo(a.x2, a.y2), n.lineTo(a.x3, a.y3)
|
|
},
|
|
getCaretPosition: function(t, e, n) {
|
|
var i, a, o, r, l, s, u = n.caretSize,
|
|
d = n.cornerRadius,
|
|
c = n.xAlign,
|
|
h = n.yAlign,
|
|
f = t.x,
|
|
g = t.y,
|
|
p = e.width,
|
|
v = e.height;
|
|
if ("center" === h) l = g + v / 2, "left" === c ? (a = (i = f) - u, o = i, r = l + u, s = l - u) : (a = (i = f + p) + u, o = i, r = l - u, s = l + u);
|
|
else if ("left" === c ? (i = (a = f + d + u) - u, o = a + u) : "right" === c ? (i = (a = f + p - d - u) - u, o = a + u) : (i = (a = f + p / 2) - u, o = a + u), "top" === h) l = (r = g) - u, s = r;
|
|
else {
|
|
l = (r = g + v) + u, s = r;
|
|
var m = o;
|
|
o = i, i = m
|
|
}
|
|
return {
|
|
x1: i,
|
|
x2: a,
|
|
x3: o,
|
|
y1: r,
|
|
y2: l,
|
|
y3: s
|
|
}
|
|
},
|
|
drawTitle: function(t, n, i, a) {
|
|
var r = n.title;
|
|
if (r.length) {
|
|
i.textAlign = n._titleAlign, i.textBaseline = "top";
|
|
var l = n.titleFontSize,
|
|
s = n.titleSpacing;
|
|
i.fillStyle = e(n.titleFontColor, a), i.font = o.fontString(l, n._titleFontStyle, n._titleFontFamily);
|
|
var u, d;
|
|
for (u = 0, d = r.length; u < d; ++u) i.fillText(r[u], t.x, t.y), t.y += l + s, u + 1 === r.length && (t.y += n.titleMarginBottom - s)
|
|
}
|
|
},
|
|
drawBody: function(t, n, i, a) {
|
|
var r = n.bodyFontSize,
|
|
l = n.bodySpacing,
|
|
s = n.body;
|
|
i.textAlign = n._bodyAlign, i.textBaseline = "top", i.font = o.fontString(r, n._bodyFontStyle, n._bodyFontFamily);
|
|
var u = 0,
|
|
d = function(e) {
|
|
i.fillText(e, t.x + u, t.y), t.y += r + l
|
|
};
|
|
o.each(n.beforeBody, d);
|
|
var c = n.displayColors;
|
|
u = c ? r + 2 : 0, o.each(s, function(l, s) {
|
|
o.each(l.before, d), o.each(l.lines, function(o) {
|
|
if (c) {
|
|
i.fillStyle = e(n.legendColorBackground, a), i.fillRect(t.x, t.y, r, r), i.lineWidth = 1, i.strokeStyle = e(n.labelColors[s].borderColor, a), i.strokeRect(t.x, t.y, r, r), i.fillStyle = e(n.labelColors[s].backgroundColor, a), i.fillRect(t.x + 1, t.y + 1, r - 2, r - 2);
|
|
var l = e(n.labelTextColors[s], a);
|
|
i.fillStyle = l
|
|
}
|
|
d(o)
|
|
}), o.each(l.after, d)
|
|
}), u = 0, o.each(n.afterBody, d), t.y -= l
|
|
},
|
|
drawFooter: function(t, n, i, a) {
|
|
var r = n.footer;
|
|
r.length && (t.y += n.footerMarginTop, i.textAlign = n._footerAlign, i.textBaseline = "top", i.fillStyle = e(n.footerFontColor, a), i.font = o.fontString(n.footerFontSize, n._footerFontStyle, n._footerFontFamily), o.each(r, function(e) {
|
|
i.fillText(e, t.x, t.y), t.y += n.footerFontSize + n.footerSpacing
|
|
}))
|
|
},
|
|
drawBackground: function(t, n, i, a, o) {
|
|
i.fillStyle = e(n.backgroundColor, o), i.strokeStyle = e(n.borderColor, o), i.lineWidth = n.borderWidth;
|
|
var r = n.xAlign,
|
|
l = n.yAlign,
|
|
s = t.x,
|
|
u = t.y,
|
|
d = a.width,
|
|
c = a.height,
|
|
h = n.cornerRadius;
|
|
i.beginPath(), i.moveTo(s + h, u), "top" === l && this.drawCaret(t, a), i.lineTo(s + d - h, u), i.quadraticCurveTo(s + d, u, s + d, u + h), "center" === l && "right" === r && this.drawCaret(t, a), i.lineTo(s + d, u + c - h), i.quadraticCurveTo(s + d, u + c, s + d - h, u + c), "bottom" === l && this.drawCaret(t, a), i.lineTo(s + h, u + c), i.quadraticCurveTo(s, u + c, s, u + c - h), "center" === l && "left" === r && this.drawCaret(t, a), i.lineTo(s, u + h), i.quadraticCurveTo(s, u, s + h, u), i.closePath(), i.fill(), n.borderWidth > 0 && i.stroke()
|
|
},
|
|
draw: function() {
|
|
var t = this._chart.ctx,
|
|
e = this._view;
|
|
if (0 !== e.opacity) {
|
|
var n = {
|
|
width: e.width,
|
|
height: e.height
|
|
},
|
|
i = {
|
|
x: e.x,
|
|
y: e.y
|
|
},
|
|
a = Math.abs(e.opacity < .001) ? 0 : e.opacity,
|
|
o = e.title.length || e.beforeBody.length || e.body.length || e.afterBody.length || e.footer.length;
|
|
this._options.enabled && o && (this.drawBackground(i, e, t, n, a), i.x += e.xPadding, i.y += e.yPadding, this.drawTitle(i, e, t, a), this.drawBody(i, e, t, a), this.drawFooter(i, e, t, a))
|
|
}
|
|
},
|
|
handleEvent: function(t) {
|
|
var e = this,
|
|
n = e._options,
|
|
i = !1;
|
|
if (e._lastActive = e._lastActive || [], "mouseout" === t.type ? e._active = [] : e._active = e._chart.getElementsAtEventForMode(t, n.mode, n), !(i = !o.arrayEquals(e._active, e._lastActive))) return !1;
|
|
if (e._lastActive = e._active, n.enabled || n.custom) {
|
|
e._eventPosition = {
|
|
x: t.x,
|
|
y: t.y
|
|
};
|
|
var a = e._model;
|
|
e.update(!0), e.pivot(), i |= a.x !== e._model.x || a.y !== e._model.y
|
|
}
|
|
return i
|
|
}
|
|
}), t.Tooltip.positioners = {
|
|
average: function(t) {
|
|
if (!t.length) return !1;
|
|
var e, n, i = 0,
|
|
a = 0,
|
|
o = 0;
|
|
for (e = 0, n = t.length; e < n; ++e) {
|
|
var r = t[e];
|
|
if (r && r.hasValue()) {
|
|
var l = r.tooltipPosition();
|
|
i += l.x, a += l.y, ++o
|
|
}
|
|
}
|
|
return {
|
|
x: Math.round(i / o),
|
|
y: Math.round(a / o)
|
|
}
|
|
},
|
|
nearest: function(t, e) {
|
|
var n, i, a, r = e.x,
|
|
l = e.y,
|
|
s = Number.POSITIVE_INFINITY;
|
|
for (n = 0, i = t.length; n < i; ++n) {
|
|
var u = t[n];
|
|
if (u && u.hasValue()) {
|
|
var d = u.getCenterPoint(),
|
|
c = o.distanceBetweenPoints(e, d);
|
|
c < s && (s = c, a = u)
|
|
}
|
|
}
|
|
if (a) {
|
|
var h = a.tooltipPosition();
|
|
r = h.x, l = h.y
|
|
}
|
|
return {
|
|
x: r,
|
|
y: l
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
25: 25,
|
|
26: 26,
|
|
45: 45
|
|
}],
|
|
36: [function(t, e, n) {
|
|
"use strict";
|
|
var i = t(25),
|
|
a = t(26),
|
|
o = t(45);
|
|
i._set("global", {
|
|
elements: {
|
|
arc: {
|
|
backgroundColor: i.global.defaultColor,
|
|
borderColor: "#fff",
|
|
borderWidth: 2
|
|
}
|
|
}
|
|
}), e.exports = a.extend({
|
|
inLabelRange: function(t) {
|
|
var e = this._view;
|
|
return !!e && Math.pow(t - e.x, 2) < Math.pow(e.radius + e.hoverRadius, 2)
|
|
},
|
|
inRange: function(t, e) {
|
|
var n = this._view;
|
|
if (n) {
|
|
for (var i = o.getAngleFromPoint(n, {
|
|
x: t,
|
|
y: e
|
|
}), a = i.angle, r = i.distance, l = n.startAngle, s = n.endAngle; s < l;) s += 2 * Math.PI;
|
|
for (; a > s;) a -= 2 * Math.PI;
|
|
for (; a < l;) a += 2 * Math.PI;
|
|
var u = a >= l && a <= s,
|
|
d = r >= n.innerRadius && r <= n.outerRadius;
|
|
return u && d
|
|
}
|
|
return !1
|
|
},
|
|
getCenterPoint: function() {
|
|
var t = this._view,
|
|
e = (t.startAngle + t.endAngle) / 2,
|
|
n = (t.innerRadius + t.outerRadius) / 2;
|
|
return {
|
|
x: t.x + Math.cos(e) * n,
|
|
y: t.y + Math.sin(e) * n
|
|
}
|
|
},
|
|
getArea: function() {
|
|
var t = this._view;
|
|
return Math.PI * ((t.endAngle - t.startAngle) / (2 * Math.PI)) * (Math.pow(t.outerRadius, 2) - Math.pow(t.innerRadius, 2))
|
|
},
|
|
tooltipPosition: function() {
|
|
var t = this._view,
|
|
e = t.startAngle + (t.endAngle - t.startAngle) / 2,
|
|
n = (t.outerRadius - t.innerRadius) / 2 + t.innerRadius;
|
|
return {
|
|
x: t.x + Math.cos(e) * n,
|
|
y: t.y + Math.sin(e) * n
|
|
}
|
|
},
|
|
draw: function() {
|
|
var t = this._chart.ctx,
|
|
e = this._view,
|
|
n = e.startAngle,
|
|
i = e.endAngle;
|
|
t.beginPath(), t.arc(e.x, e.y, e.outerRadius, n, i), t.arc(e.x, e.y, e.innerRadius, i, n, !0), t.closePath(), t.strokeStyle = e.borderColor, t.lineWidth = e.borderWidth, t.fillStyle = e.backgroundColor, t.fill(), t.lineJoin = "bevel", e.borderWidth && t.stroke()
|
|
}
|
|
})
|
|
}, {
|
|
25: 25,
|
|
26: 26,
|
|
45: 45
|
|
}],
|
|
37: [function(t, e, n) {
|
|
"use strict";
|
|
var i = t(25),
|
|
a = t(26),
|
|
o = t(45),
|
|
r = i.global;
|
|
i._set("global", {
|
|
elements: {
|
|
line: {
|
|
tension: .4,
|
|
backgroundColor: r.defaultColor,
|
|
borderWidth: 3,
|
|
borderColor: r.defaultColor,
|
|
borderCapStyle: "butt",
|
|
borderDash: [],
|
|
borderDashOffset: 0,
|
|
borderJoinStyle: "miter",
|
|
capBezierPoints: !0,
|
|
fill: !0
|
|
}
|
|
}
|
|
}), e.exports = a.extend({
|
|
draw: function() {
|
|
var t, e, n, i, a = this,
|
|
l = a._view,
|
|
s = a._chart.ctx,
|
|
u = l.spanGaps,
|
|
d = a._children.slice(),
|
|
c = r.elements.line,
|
|
h = -1;
|
|
for (a._loop && d.length && d.push(d[0]), s.save(), s.lineCap = l.borderCapStyle || c.borderCapStyle, s.setLineDash && s.setLineDash(l.borderDash || c.borderDash), s.lineDashOffset = l.borderDashOffset || c.borderDashOffset, s.lineJoin = l.borderJoinStyle || c.borderJoinStyle, s.lineWidth = l.borderWidth || c.borderWidth, s.strokeStyle = l.borderColor || r.defaultColor, s.beginPath(), h = -1, t = 0; t < d.length; ++t) e = d[t], n = o.previousItem(d, t), i = e._view, 0 === t ? i.skip || (s.moveTo(i.x, i.y), h = t) : (n = -1 === h ? n : d[h], i.skip || (h !== t - 1 && !u || -1 === h ? s.moveTo(i.x, i.y) : o.canvas.lineTo(s, n._view, e._view), h = t));
|
|
s.stroke(), s.restore()
|
|
}
|
|
})
|
|
}, {
|
|
25: 25,
|
|
26: 26,
|
|
45: 45
|
|
}],
|
|
38: [function(t, e, n) {
|
|
"use strict";
|
|
|
|
function i(t) {
|
|
var e = this._view;
|
|
return !!e && Math.pow(t - e.x, 2) < Math.pow(e.radius + e.hitRadius, 2)
|
|
}
|
|
var a = t(25),
|
|
o = t(26),
|
|
r = t(45),
|
|
l = a.global.defaultColor;
|
|
a._set("global", {
|
|
elements: {
|
|
point: {
|
|
radius: 3,
|
|
pointStyle: "circle",
|
|
backgroundColor: l,
|
|
borderColor: l,
|
|
borderWidth: 1,
|
|
hitRadius: 1,
|
|
hoverRadius: 4,
|
|
hoverBorderWidth: 1
|
|
}
|
|
}
|
|
}), e.exports = o.extend({
|
|
inRange: function(t, e) {
|
|
var n = this._view;
|
|
return !!n && Math.pow(t - n.x, 2) + Math.pow(e - n.y, 2) < Math.pow(n.hitRadius + n.radius, 2)
|
|
},
|
|
inLabelRange: i,
|
|
inXRange: i,
|
|
inYRange: function(t) {
|
|
var e = this._view;
|
|
return !!e && Math.pow(t - e.y, 2) < Math.pow(e.radius + e.hitRadius, 2)
|
|
},
|
|
getCenterPoint: function() {
|
|
var t = this._view;
|
|
return {
|
|
x: t.x,
|
|
y: t.y
|
|
}
|
|
},
|
|
getArea: function() {
|
|
return Math.PI * Math.pow(this._view.radius, 2)
|
|
},
|
|
tooltipPosition: function() {
|
|
var t = this._view;
|
|
return {
|
|
x: t.x,
|
|
y: t.y,
|
|
padding: t.radius + t.borderWidth
|
|
}
|
|
},
|
|
draw: function(t) {
|
|
var e = this._view,
|
|
n = this._model,
|
|
i = this._chart.ctx,
|
|
o = e.pointStyle,
|
|
s = e.radius,
|
|
u = e.x,
|
|
d = e.y,
|
|
c = r.color,
|
|
h = 0;
|
|
e.skip || (i.strokeStyle = e.borderColor || l, i.lineWidth = r.valueOrDefault(e.borderWidth, a.global.elements.point.borderWidth), i.fillStyle = e.backgroundColor || l, void 0 !== t && (n.x < t.left || 1.01 * t.right < n.x || n.y < t.top || 1.01 * t.bottom < n.y) && (n.x < t.left ? h = (u - n.x) / (t.left - n.x) : 1.01 * t.right < n.x ? h = (n.x - u) / (n.x - t.right) : n.y < t.top ? h = (d - n.y) / (t.top - n.y) : 1.01 * t.bottom < n.y && (h = (n.y - d) / (n.y - t.bottom)), h = Math.round(100 * h) / 100, i.strokeStyle = c(i.strokeStyle).alpha(h).rgbString(), i.fillStyle = c(i.fillStyle).alpha(h).rgbString()), r.canvas.drawPoint(i, o, s, u, d))
|
|
}
|
|
})
|
|
}, {
|
|
25: 25,
|
|
26: 26,
|
|
45: 45
|
|
}],
|
|
39: [function(t, e, n) {
|
|
"use strict";
|
|
|
|
function i(t) {
|
|
return void 0 !== t._view.width
|
|
}
|
|
|
|
function a(t) {
|
|
var e, n, a, o, r = t._view;
|
|
if (i(t)) {
|
|
var l = r.width / 2;
|
|
e = r.x - l, n = r.x + l, a = Math.min(r.y, r.base), o = Math.max(r.y, r.base)
|
|
} else {
|
|
var s = r.height / 2;
|
|
e = Math.min(r.x, r.base), n = Math.max(r.x, r.base), a = r.y - s, o = r.y + s
|
|
}
|
|
return {
|
|
left: e,
|
|
top: a,
|
|
right: n,
|
|
bottom: o
|
|
}
|
|
}
|
|
var o = t(25),
|
|
r = t(26);
|
|
o._set("global", {
|
|
elements: {
|
|
rectangle: {
|
|
backgroundColor: o.global.defaultColor,
|
|
borderColor: o.global.defaultColor,
|
|
borderSkipped: "bottom",
|
|
borderWidth: 0
|
|
}
|
|
}
|
|
}), e.exports = r.extend({
|
|
draw: function() {
|
|
function t(t) {
|
|
return m[(b + t) % 4]
|
|
}
|
|
var e, n, i, a, o, r, l, s = this._chart.ctx,
|
|
u = this._view,
|
|
d = u.borderWidth;
|
|
if (u.horizontal ? (e = u.base, n = u.x, i = u.y - u.height / 2, a = u.y + u.height / 2, o = n > e ? 1 : -1, r = 1, l = u.borderSkipped || "left") : (e = u.x - u.width / 2, n = u.x + u.width / 2, i = u.y, o = 1, r = (a = u.base) > i ? 1 : -1, l = u.borderSkipped || "bottom"), d) {
|
|
var c = Math.min(Math.abs(e - n), Math.abs(i - a)),
|
|
h = (d = d > c ? c : d) / 2,
|
|
f = e + ("left" !== l ? h * o : 0),
|
|
g = n + ("right" !== l ? -h * o : 0),
|
|
p = i + ("top" !== l ? h * r : 0),
|
|
v = a + ("bottom" !== l ? -h * r : 0);
|
|
f !== g && (i = p, a = v), p !== v && (e = f, n = g)
|
|
}
|
|
s.beginPath(), s.fillStyle = u.backgroundColor, s.strokeStyle = u.borderColor, s.lineWidth = d;
|
|
var m = [
|
|
[e, a],
|
|
[e, i],
|
|
[n, i],
|
|
[n, a]
|
|
],
|
|
b = ["bottom", "left", "top", "right"].indexOf(l, 0); - 1 === b && (b = 0);
|
|
var x = t(0);
|
|
s.moveTo(x[0], x[1]);
|
|
for (var y = 1; y < 4; y++) x = t(y), s.lineTo(x[0], x[1]);
|
|
s.fill(), d && s.stroke()
|
|
},
|
|
height: function() {
|
|
var t = this._view;
|
|
return t.base - t.y
|
|
},
|
|
inRange: function(t, e) {
|
|
var n = !1;
|
|
if (this._view) {
|
|
var i = a(this);
|
|
n = t >= i.left && t <= i.right && e >= i.top && e <= i.bottom
|
|
}
|
|
return n
|
|
},
|
|
inLabelRange: function(t, e) {
|
|
var n = this;
|
|
if (!n._view) return !1;
|
|
var o = a(n);
|
|
return i(n) ? t >= o.left && t <= o.right : e >= o.top && e <= o.bottom
|
|
},
|
|
inXRange: function(t) {
|
|
var e = a(this);
|
|
return t >= e.left && t <= e.right
|
|
},
|
|
inYRange: function(t) {
|
|
var e = a(this);
|
|
return t >= e.top && t <= e.bottom
|
|
},
|
|
getCenterPoint: function() {
|
|
var t, e, n = this._view;
|
|
return i(this) ? (t = n.x, e = (n.y + n.base) / 2) : (t = (n.x + n.base) / 2, e = n.y), {
|
|
x: t,
|
|
y: e
|
|
}
|
|
},
|
|
getArea: function() {
|
|
var t = this._view;
|
|
return t.width * Math.abs(t.y - t.base)
|
|
},
|
|
tooltipPosition: function() {
|
|
var t = this._view;
|
|
return {
|
|
x: t.x,
|
|
y: t.y
|
|
}
|
|
}
|
|
})
|
|
}, {
|
|
25: 25,
|
|
26: 26
|
|
}],
|
|
40: [function(t, e, n) {
|
|
"use strict";
|
|
e.exports = {}, e.exports.Arc = t(36), e.exports.Line = t(37), e.exports.Point = t(38), e.exports.Rectangle = t(39)
|
|
}, {
|
|
36: 36,
|
|
37: 37,
|
|
38: 38,
|
|
39: 39
|
|
}],
|
|
41: [function(t, e, n) {
|
|
"use strict";
|
|
var i = t(42),
|
|
n = e.exports = {
|
|
clear: function(t) {
|
|
t.ctx.clearRect(0, 0, t.width, t.height)
|
|
},
|
|
roundedRect: function(t, e, n, i, a, o) {
|
|
if (o) {
|
|
var r = Math.min(o, i / 2),
|
|
l = Math.min(o, a / 2);
|
|
t.moveTo(e + r, n), t.lineTo(e + i - r, n), t.quadraticCurveTo(e + i, n, e + i, n + l), t.lineTo(e + i, n + a - l), t.quadraticCurveTo(e + i, n + a, e + i - r, n + a), t.lineTo(e + r, n + a), t.quadraticCurveTo(e, n + a, e, n + a - l), t.lineTo(e, n + l), t.quadraticCurveTo(e, n, e + r, n)
|
|
} else t.rect(e, n, i, a)
|
|
},
|
|
drawPoint: function(t, e, n, i, a) {
|
|
var o, r, l, s, u, d;
|
|
if ("object" != typeof e || "[object HTMLImageElement]" !== (o = e.toString()) && "[object HTMLCanvasElement]" !== o) {
|
|
if (!(isNaN(n) || n <= 0)) {
|
|
switch (e) {
|
|
default: t.beginPath(),
|
|
t.arc(i, a, n, 0, 2 * Math.PI),
|
|
t.closePath(),
|
|
t.fill();
|
|
break;
|
|
case "triangle":
|
|
t.beginPath(),
|
|
u = (r = 3 * n / Math.sqrt(3)) * Math.sqrt(3) / 2,
|
|
t.moveTo(i - r / 2, a + u / 3),
|
|
t.lineTo(i + r / 2, a + u / 3),
|
|
t.lineTo(i, a - 2 * u / 3),
|
|
t.closePath(),
|
|
t.fill();
|
|
break;
|
|
case "rect":
|
|
d = 1 / Math.SQRT2 * n,
|
|
t.beginPath(),
|
|
t.fillRect(i - d, a - d, 2 * d, 2 * d),
|
|
t.strokeRect(i - d, a - d, 2 * d, 2 * d);
|
|
break;
|
|
case "rectRounded":
|
|
var c = n / Math.SQRT2,
|
|
h = i - c,
|
|
f = a - c,
|
|
g = Math.SQRT2 * n;t.beginPath(),
|
|
this.roundedRect(t, h, f, g, g, n / 2),
|
|
t.closePath(),
|
|
t.fill();
|
|
break;
|
|
case "rectRot":
|
|
d = 1 / Math.SQRT2 * n,
|
|
t.beginPath(),
|
|
t.moveTo(i - d, a),
|
|
t.lineTo(i, a + d),
|
|
t.lineTo(i + d, a),
|
|
t.lineTo(i, a - d),
|
|
t.closePath(),
|
|
t.fill();
|
|
break;
|
|
case "cross":
|
|
t.beginPath(),
|
|
t.moveTo(i, a + n),
|
|
t.lineTo(i, a - n),
|
|
t.moveTo(i - n, a),
|
|
t.lineTo(i + n, a),
|
|
t.closePath();
|
|
break;
|
|
case "crossRot":
|
|
t.beginPath(),
|
|
l = Math.cos(Math.PI / 4) * n,
|
|
s = Math.sin(Math.PI / 4) * n,
|
|
t.moveTo(i - l, a - s),
|
|
t.lineTo(i + l, a + s),
|
|
t.moveTo(i - l, a + s),
|
|
t.lineTo(i + l, a - s),
|
|
t.closePath();
|
|
break;
|
|
case "star":
|
|
t.beginPath(),
|
|
t.moveTo(i, a + n),
|
|
t.lineTo(i, a - n),
|
|
t.moveTo(i - n, a),
|
|
t.lineTo(i + n, a),
|
|
l = Math.cos(Math.PI / 4) * n,
|
|
s = Math.sin(Math.PI / 4) * n,
|
|
t.moveTo(i - l, a - s),
|
|
t.lineTo(i + l, a + s),
|
|
t.moveTo(i - l, a + s),
|
|
t.lineTo(i + l, a - s),
|
|
t.closePath();
|
|
break;
|
|
case "line":
|
|
t.beginPath(),
|
|
t.moveTo(i - n, a),
|
|
t.lineTo(i + n, a),
|
|
t.closePath();
|
|
break;
|
|
case "dash":
|
|
t.beginPath(),
|
|
t.moveTo(i, a),
|
|
t.lineTo(i + n, a),
|
|
t.closePath()
|
|
}
|
|
t.stroke()
|
|
}
|
|
} else t.drawImage(e, i - e.width / 2, a - e.height / 2, e.width, e.height)
|
|
},
|
|
clipArea: function(t, e) {
|
|
t.save(), t.beginPath(), t.rect(e.left, e.top, e.right - e.left, e.bottom - e.top), t.clip()
|
|
},
|
|
unclipArea: function(t) {
|
|
t.restore()
|
|
},
|
|
lineTo: function(t, e, n, i) {
|
|
if (n.steppedLine) return "after" === n.steppedLine && !i || "after" !== n.steppedLine && i ? t.lineTo(e.x, n.y) : t.lineTo(n.x, e.y), void t.lineTo(n.x, n.y);
|
|
n.tension ? t.bezierCurveTo(i ? e.controlPointPreviousX : e.controlPointNextX, i ? e.controlPointPreviousY : e.controlPointNextY, i ? n.controlPointNextX : n.controlPointPreviousX, i ? n.controlPointNextY : n.controlPointPreviousY, n.x, n.y) : t.lineTo(n.x, n.y)
|
|
}
|
|
};
|
|
i.clear = n.clear, i.drawRoundedRectangle = function(t) {
|
|
t.beginPath(), n.roundedRect.apply(n, arguments), t.closePath()
|
|
}
|
|
}, {
|
|
42: 42
|
|
}],
|
|
42: [function(t, e, n) {
|
|
"use strict";
|
|
var i = {
|
|
noop: function() {},
|
|
uid: function() {
|
|
var t = 0;
|
|
return function() {
|
|
return t++
|
|
}
|
|
}(),
|
|
isNullOrUndef: function(t) {
|
|
return null === t || void 0 === t
|
|
},
|
|
isArray: Array.isArray ? Array.isArray : function(t) {
|
|
return "[object Array]" === Object.prototype.toString.call(t)
|
|
},
|
|
isObject: function(t) {
|
|
return null !== t && "[object Object]" === Object.prototype.toString.call(t)
|
|
},
|
|
valueOrDefault: function(t, e) {
|
|
return void 0 === t ? e : t
|
|
},
|
|
valueAtIndexOrDefault: function(t, e, n) {
|
|
return i.valueOrDefault(i.isArray(t) ? t[e] : t, n)
|
|
},
|
|
callback: function(t, e, n) {
|
|
if (t && "function" == typeof t.call) return t.apply(n, e)
|
|
},
|
|
each: function(t, e, n, a) {
|
|
var o, r, l;
|
|
if (i.isArray(t))
|
|
if (r = t.length, a)
|
|
for (o = r - 1; o >= 0; o--) e.call(n, t[o], o);
|
|
else
|
|
for (o = 0; o < r; o++) e.call(n, t[o], o);
|
|
else if (i.isObject(t))
|
|
for (r = (l = Object.keys(t)).length, o = 0; o < r; o++) e.call(n, t[l[o]], l[o])
|
|
},
|
|
arrayEquals: function(t, e) {
|
|
var n, a, o, r;
|
|
if (!t || !e || t.length !== e.length) return !1;
|
|
for (n = 0, a = t.length; n < a; ++n)
|
|
if (o = t[n], r = e[n], o instanceof Array && r instanceof Array) {
|
|
if (!i.arrayEquals(o, r)) return !1
|
|
} else if (o !== r) return !1;
|
|
return !0
|
|
},
|
|
clone: function(t) {
|
|
if (i.isArray(t)) return t.map(i.clone);
|
|
if (i.isObject(t)) {
|
|
for (var e = {}, n = Object.keys(t), a = n.length, o = 0; o < a; ++o) e[n[o]] = i.clone(t[n[o]]);
|
|
return e
|
|
}
|
|
return t
|
|
},
|
|
_merger: function(t, e, n, a) {
|
|
var o = e[t],
|
|
r = n[t];
|
|
i.isObject(o) && i.isObject(r) ? i.merge(o, r, a) : e[t] = i.clone(r)
|
|
},
|
|
_mergerIf: function(t, e, n) {
|
|
var a = e[t],
|
|
o = n[t];
|
|
i.isObject(a) && i.isObject(o) ? i.mergeIf(a, o) : e.hasOwnProperty(t) || (e[t] = i.clone(o))
|
|
},
|
|
merge: function(t, e, n) {
|
|
var a, o, r, l, s, u = i.isArray(e) ? e : [e],
|
|
d = u.length;
|
|
if (!i.isObject(t)) return t;
|
|
for (a = (n = n || {}).merger || i._merger, o = 0; o < d; ++o)
|
|
if (e = u[o], i.isObject(e))
|
|
for (s = 0, l = (r = Object.keys(e)).length; s < l; ++s) a(r[s], t, e, n);
|
|
return t
|
|
},
|
|
mergeIf: function(t, e) {
|
|
return i.merge(t, e, {
|
|
merger: i._mergerIf
|
|
})
|
|
}
|
|
};
|
|
e.exports = i, i.callCallback = i.callback, i.indexOf = function(t, e, n) {
|
|
return Array.prototype.indexOf.call(t, e, n)
|
|
}, i.getValueOrDefault = i.valueOrDefault, i.getValueAtIndexOrDefault = i.valueAtIndexOrDefault
|
|
}, {}],
|
|
43: [function(t, e, n) {
|
|
"use strict";
|
|
var i = t(42),
|
|
a = {
|
|
linear: function(t) {
|
|
return t
|
|
},
|
|
easeInQuad: function(t) {
|
|
return t * t
|
|
},
|
|
easeOutQuad: function(t) {
|
|
return -t * (t - 2)
|
|
},
|
|
easeInOutQuad: function(t) {
|
|
return (t /= .5) < 1 ? .5 * t * t : -.5 * (--t * (t - 2) - 1)
|
|
},
|
|
easeInCubic: function(t) {
|
|
return t * t * t
|
|
},
|
|
easeOutCubic: function(t) {
|
|
return (t -= 1) * t * t + 1
|
|
},
|
|
easeInOutCubic: function(t) {
|
|
return (t /= .5) < 1 ? .5 * t * t * t : .5 * ((t -= 2) * t * t + 2)
|
|
},
|
|
easeInQuart: function(t) {
|
|
return t * t * t * t
|
|
},
|
|
easeOutQuart: function(t) {
|
|
return -((t -= 1) * t * t * t - 1)
|
|
},
|
|
easeInOutQuart: function(t) {
|
|
return (t /= .5) < 1 ? .5 * t * t * t * t : -.5 * ((t -= 2) * t * t * t - 2)
|
|
},
|
|
easeInQuint: function(t) {
|
|
return t * t * t * t * t
|
|
},
|
|
easeOutQuint: function(t) {
|
|
return (t -= 1) * t * t * t * t + 1
|
|
},
|
|
easeInOutQuint: function(t) {
|
|
return (t /= .5) < 1 ? .5 * t * t * t * t * t : .5 * ((t -= 2) * t * t * t * t + 2)
|
|
},
|
|
easeInSine: function(t) {
|
|
return 1 - Math.cos(t * (Math.PI / 2))
|
|
},
|
|
easeOutSine: function(t) {
|
|
return Math.sin(t * (Math.PI / 2))
|
|
},
|
|
easeInOutSine: function(t) {
|
|
return -.5 * (Math.cos(Math.PI * t) - 1)
|
|
},
|
|
easeInExpo: function(t) {
|
|
return 0 === t ? 0 : Math.pow(2, 10 * (t - 1))
|
|
},
|
|
easeOutExpo: function(t) {
|
|
return 1 === t ? 1 : 1 - Math.pow(2, -10 * t)
|
|
},
|
|
easeInOutExpo: function(t) {
|
|
return 0 === t ? 0 : 1 === t ? 1 : (t /= .5) < 1 ? .5 * Math.pow(2, 10 * (t - 1)) : .5 * (2 - Math.pow(2, -10 * --t))
|
|
},
|
|
easeInCirc: function(t) {
|
|
return t >= 1 ? t : -(Math.sqrt(1 - t * t) - 1)
|
|
},
|
|
easeOutCirc: function(t) {
|
|
return Math.sqrt(1 - (t -= 1) * t)
|
|
},
|
|
easeInOutCirc: function(t) {
|
|
return (t /= .5) < 1 ? -.5 * (Math.sqrt(1 - t * t) - 1) : .5 * (Math.sqrt(1 - (t -= 2) * t) + 1)
|
|
},
|
|
easeInElastic: function(t) {
|
|
var e = 1.70158,
|
|
n = 0,
|
|
i = 1;
|
|
return 0 === t ? 0 : 1 === t ? 1 : (n || (n = .3), i < 1 ? (i = 1, e = n / 4) : e = n / (2 * Math.PI) * Math.asin(1 / i), -i * Math.pow(2, 10 * (t -= 1)) * Math.sin((t - e) * (2 * Math.PI) / n))
|
|
},
|
|
easeOutElastic: function(t) {
|
|
var e = 1.70158,
|
|
n = 0,
|
|
i = 1;
|
|
return 0 === t ? 0 : 1 === t ? 1 : (n || (n = .3), i < 1 ? (i = 1, e = n / 4) : e = n / (2 * Math.PI) * Math.asin(1 / i), i * Math.pow(2, -10 * t) * Math.sin((t - e) * (2 * Math.PI) / n) + 1)
|
|
},
|
|
easeInOutElastic: function(t) {
|
|
var e = 1.70158,
|
|
n = 0,
|
|
i = 1;
|
|
return 0 === t ? 0 : 2 == (t /= .5) ? 1 : (n || (n = .45), i < 1 ? (i = 1, e = n / 4) : e = n / (2 * Math.PI) * Math.asin(1 / i), t < 1 ? i * Math.pow(2, 10 * (t -= 1)) * Math.sin((t - e) * (2 * Math.PI) / n) * -.5 : i * Math.pow(2, -10 * (t -= 1)) * Math.sin((t - e) * (2 * Math.PI) / n) * .5 + 1)
|
|
},
|
|
easeInBack: function(t) {
|
|
var e = 1.70158;
|
|
return t * t * ((e + 1) * t - e)
|
|
},
|
|
easeOutBack: function(t) {
|
|
var e = 1.70158;
|
|
return (t -= 1) * t * ((e + 1) * t + e) + 1
|
|
},
|
|
easeInOutBack: function(t) {
|
|
var e = 1.70158;
|
|
return (t /= .5) < 1 ? t * t * ((1 + (e *= 1.525)) * t - e) * .5 : .5 * ((t -= 2) * t * ((1 + (e *= 1.525)) * t + e) + 2)
|
|
},
|
|
easeInBounce: function(t) {
|
|
return 1 - a.easeOutBounce(1 - t)
|
|
},
|
|
easeOutBounce: function(t) {
|
|
return t < 1 / 2.75 ? 7.5625 * t * t : t < 2 / 2.75 ? 7.5625 * (t -= 1.5 / 2.75) * t + .75 : t < 2.5 / 2.75 ? 7.5625 * (t -= 2.25 / 2.75) * t + .9375 : 7.5625 * (t -= 2.625 / 2.75) * t + .984375
|
|
},
|
|
easeInOutBounce: function(t) {
|
|
return t < .5 ? .5 * a.easeInBounce(2 * t) : .5 * a.easeOutBounce(2 * t - 1) + .5
|
|
}
|
|
};
|
|
e.exports = {
|
|
effects: a
|
|
}, i.easingEffects = a
|
|
}, {
|
|
42: 42
|
|
}],
|
|
44: [function(t, e, n) {
|
|
"use strict";
|
|
var i = t(42);
|
|
e.exports = {
|
|
toLineHeight: function(t, e) {
|
|
var n = ("" + t).match(/^(normal|(\d+(?:\.\d+)?)(px|em|%)?)$/);
|
|
if (!n || "normal" === n[1]) return 1.2 * e;
|
|
switch (t = +n[2], n[3]) {
|
|
case "px":
|
|
return t;
|
|
case "%":
|
|
t /= 100
|
|
}
|
|
return e * t
|
|
},
|
|
toPadding: function(t) {
|
|
var e, n, a, o;
|
|
return i.isObject(t) ? (e = +t.top || 0, n = +t.right || 0, a = +t.bottom || 0, o = +t.left || 0) : e = n = a = o = +t || 0, {
|
|
top: e,
|
|
right: n,
|
|
bottom: a,
|
|
left: o,
|
|
height: e + a,
|
|
width: o + n
|
|
}
|
|
},
|
|
resolve: function(t, e, n) {
|
|
var a, o, r;
|
|
for (a = 0, o = t.length; a < o; ++a)
|
|
if (void 0 !== (r = t[a]) && (void 0 !== e && "function" == typeof r && (r = r(e)), void 0 !== n && i.isArray(r) && (r = r[n]), void 0 !== r)) return r
|
|
}
|
|
}
|
|
}, {
|
|
42: 42
|
|
}],
|
|
45: [function(t, e, n) {
|
|
"use strict";
|
|
e.exports = t(42), e.exports.easing = t(43), e.exports.canvas = t(41), e.exports.options = t(44)
|
|
}, {
|
|
41: 41,
|
|
42: 42,
|
|
43: 43,
|
|
44: 44
|
|
}],
|
|
46: [function(t, e, n) {
|
|
e.exports = {
|
|
acquireContext: function(t) {
|
|
return t && t.canvas && (t = t.canvas), t && t.getContext("2d") || null
|
|
}
|
|
}
|
|
}, {}],
|
|
47: [function(t, e, n) {
|
|
"use strict";
|
|
|
|
function i(t, e) {
|
|
var n = v.getStyle(t, e),
|
|
i = n && n.match(/^(\d+)(\.\d+)?px$/);
|
|
return i ? Number(i[1]) : void 0
|
|
}
|
|
|
|
function a(t, e) {
|
|
var n = t.style,
|
|
a = t.getAttribute("height"),
|
|
o = t.getAttribute("width");
|
|
if (t[m] = {
|
|
initial: {
|
|
height: a,
|
|
width: o,
|
|
style: {
|
|
display: n.display,
|
|
height: n.height,
|
|
width: n.width
|
|
}
|
|
}
|
|
}, n.display = n.display || "block", null === o || "" === o) {
|
|
var r = i(t, "width");
|
|
void 0 !== r && (t.width = r)
|
|
}
|
|
if (null === a || "" === a)
|
|
if ("" === t.style.height) t.height = t.width / (e.options.aspectRatio || 2);
|
|
else {
|
|
var l = i(t, "height");
|
|
void 0 !== r && (t.height = l)
|
|
}
|
|
return t
|
|
}
|
|
|
|
function o(t, e, n) {
|
|
t.addEventListener(e, n, M)
|
|
}
|
|
|
|
function r(t, e, n) {
|
|
t.removeEventListener(e, n, M)
|
|
}
|
|
|
|
function l(t, e, n, i, a) {
|
|
return {
|
|
type: t,
|
|
chart: e,
|
|
native: a || null,
|
|
x: void 0 !== n ? n : null,
|
|
y: void 0 !== i ? i : null
|
|
}
|
|
}
|
|
|
|
function s(t, e) {
|
|
var n = w[t.type] || t.type,
|
|
i = v.getRelativePosition(t, e);
|
|
return l(n, e, i.x, i.y, t)
|
|
}
|
|
|
|
function u(t, e) {
|
|
var n = !1,
|
|
i = [];
|
|
return function() {
|
|
i = Array.prototype.slice.call(arguments), e = e || this, n || (n = !0, v.requestAnimFrame.call(window, function() {
|
|
n = !1, t.apply(e, i)
|
|
}))
|
|
}
|
|
}
|
|
|
|
function d(t) {
|
|
var e = document.createElement("div"),
|
|
n = b + "size-monitor",
|
|
i = "position:absolute;left:0;top:0;right:0;bottom:0;overflow:hidden;pointer-events:none;visibility:hidden;z-index:-1;";
|
|
e.style.cssText = i, e.className = n, e.innerHTML = '<div class="' + n + '-expand" style="' + i + '"><div style="position:absolute;width:1000000px;height:1000000px;left:0;top:0"></div></div><div class="' + n + '-shrink" style="' + i + '"><div style="position:absolute;width:200%;height:200%;left:0; top:0"></div></div>';
|
|
var a = e.childNodes[0],
|
|
r = e.childNodes[1];
|
|
e._reset = function() {
|
|
a.scrollLeft = 1e6, a.scrollTop = 1e6, r.scrollLeft = 1e6, r.scrollTop = 1e6
|
|
};
|
|
var l = function() {
|
|
e._reset(), t()
|
|
};
|
|
return o(a, "scroll", l.bind(a, "expand")), o(r, "scroll", l.bind(r, "shrink")), e
|
|
}
|
|
|
|
function c(t, e) {
|
|
var n = (t[m] || (t[m] = {})).renderProxy = function(t) {
|
|
t.animationName === y && e()
|
|
};
|
|
v.each(k, function(e) {
|
|
o(t, e, n)
|
|
}), t.classList.add(x)
|
|
}
|
|
|
|
function h(t) {
|
|
var e = t[m] || {},
|
|
n = e.renderProxy;
|
|
n && (v.each(k, function(e) {
|
|
r(t, e, n)
|
|
}), delete e.renderProxy), t.classList.remove(x)
|
|
}
|
|
|
|
function f(t, e, n) {
|
|
var i = t[m] || (t[m] = {}),
|
|
a = i.resizer = d(u(function() {
|
|
if (i.resizer) return e(l("resize", n))
|
|
}));
|
|
c(t, function() {
|
|
if (i.resizer) {
|
|
var e = t.parentNode;
|
|
e && e !== a.parentNode && e.insertBefore(a, e.firstChild), a._reset()
|
|
}
|
|
})
|
|
}
|
|
|
|
function g(t) {
|
|
var e = t[m] || {},
|
|
n = e.resizer;
|
|
delete e.resizer, h(t), n && n.parentNode && n.parentNode.removeChild(n)
|
|
}
|
|
|
|
function p(t, e) {
|
|
var n = t._style || document.createElement("style");
|
|
t._style || (t._style = n, e = "/* Chart.js */\n" + e, n.setAttribute("type", "text/css"), document.getElementsByTagName("head")[0].appendChild(n)), n.appendChild(document.createTextNode(e))
|
|
}
|
|
var v = t(45),
|
|
m = "$chartjs",
|
|
b = "chartjs-",
|
|
x = b + "render-monitor",
|
|
y = b + "render-animation",
|
|
k = ["animationstart", "webkitAnimationStart"],
|
|
w = {
|
|
touchstart: "mousedown",
|
|
touchmove: "mousemove",
|
|
touchend: "mouseup",
|
|
pointerenter: "mouseenter",
|
|
pointerdown: "mousedown",
|
|
pointermove: "mousemove",
|
|
pointerup: "mouseup",
|
|
pointerleave: "mouseout",
|
|
pointerout: "mouseout"
|
|
},
|
|
M = !! function() {
|
|
var t = !1;
|
|
try {
|
|
var e = Object.defineProperty({}, "passive", {
|
|
get: function() {
|
|
t = !0
|
|
}
|
|
});
|
|
window.addEventListener("e", null, e)
|
|
} catch (t) {}
|
|
return t
|
|
}() && {
|
|
passive: !0
|
|
};
|
|
e.exports = {
|
|
_enabled: "undefined" != typeof window && "undefined" != typeof document,
|
|
initialize: function() {
|
|
var t = "from{opacity:0.99}to{opacity:1}";
|
|
p(this, "@-webkit-keyframes " + y + "{" + t + "}@keyframes " + y + "{" + t + "}." + x + "{-webkit-animation:" + y + " 0.001s;animation:" + y + " 0.001s;}")
|
|
},
|
|
acquireContext: function(t, e) {
|
|
"string" == typeof t ? t = document.getElementById(t) : t.length && (t = t[0]), t && t.canvas && (t = t.canvas);
|
|
var n = t && t.getContext && t.getContext("2d");
|
|
return n && n.canvas === t ? (a(t, e), n) : null
|
|
},
|
|
releaseContext: function(t) {
|
|
var e = t.canvas;
|
|
if (e[m]) {
|
|
var n = e[m].initial;
|
|
["height", "width"].forEach(function(t) {
|
|
var i = n[t];
|
|
v.isNullOrUndef(i) ? e.removeAttribute(t) : e.setAttribute(t, i)
|
|
}), v.each(n.style || {}, function(t, n) {
|
|
e.style[n] = t
|
|
}), e.width = e.width, delete e[m]
|
|
}
|
|
},
|
|
addEventListener: function(t, e, n) {
|
|
var i = t.canvas;
|
|
if ("resize" !== e) {
|
|
var a = n[m] || (n[m] = {});
|
|
o(i, e, (a.proxies || (a.proxies = {}))[t.id + "_" + e] = function(e) {
|
|
n(s(e, t))
|
|
})
|
|
} else f(i, n, t)
|
|
},
|
|
removeEventListener: function(t, e, n) {
|
|
var i = t.canvas;
|
|
if ("resize" !== e) {
|
|
var a = ((n[m] || {}).proxies || {})[t.id + "_" + e];
|
|
a && r(i, e, a)
|
|
} else g(i)
|
|
}
|
|
}, v.addEvent = o, v.removeEvent = r
|
|
}, {
|
|
45: 45
|
|
}],
|
|
48: [function(t, e, n) {
|
|
"use strict";
|
|
var i = t(45),
|
|
a = t(46),
|
|
o = t(47),
|
|
r = o._enabled ? o : a;
|
|
e.exports = i.extend({
|
|
initialize: function() {},
|
|
acquireContext: function() {},
|
|
releaseContext: function() {},
|
|
addEventListener: function() {},
|
|
removeEventListener: function() {}
|
|
}, r)
|
|
}, {
|
|
45: 45,
|
|
46: 46,
|
|
47: 47
|
|
}],
|
|
49: [function(t, e, n) {
|
|
"use strict";
|
|
var i = t(25),
|
|
a = t(40),
|
|
o = t(45);
|
|
i._set("global", {
|
|
plugins: {
|
|
filler: {
|
|
propagate: !0
|
|
}
|
|
}
|
|
}), e.exports = function() {
|
|
function t(t, e, n) {
|
|
var i, a = t._model || {},
|
|
o = a.fill;
|
|
if (void 0 === o && (o = !!a.backgroundColor), !1 === o || null === o) return !1;
|
|
if (!0 === o) return "origin";
|
|
if (i = parseFloat(o, 10), isFinite(i) && Math.floor(i) === i) return "-" !== o[0] && "+" !== o[0] || (i = e + i), !(i === e || i < 0 || i >= n) && i;
|
|
switch (o) {
|
|
case "bottom":
|
|
return "start";
|
|
case "top":
|
|
return "end";
|
|
case "zero":
|
|
return "origin";
|
|
case "origin":
|
|
case "start":
|
|
case "end":
|
|
return o;
|
|
default:
|
|
return !1
|
|
}
|
|
}
|
|
|
|
function e(t) {
|
|
var e, n = t.el._model || {},
|
|
i = t.el._scale || {},
|
|
a = t.fill,
|
|
o = null;
|
|
if (isFinite(a)) return null;
|
|
if ("start" === a ? o = void 0 === n.scaleBottom ? i.bottom : n.scaleBottom : "end" === a ? o = void 0 === n.scaleTop ? i.top : n.scaleTop : void 0 !== n.scaleZero ? o = n.scaleZero : i.getBasePosition ? o = i.getBasePosition() : i.getBasePixel && (o = i.getBasePixel()), void 0 !== o && null !== o) {
|
|
if (void 0 !== o.x && void 0 !== o.y) return o;
|
|
if ("number" == typeof o && isFinite(o)) return e = i.isHorizontal(), {
|
|
x: e ? o : null,
|
|
y: e ? null : o
|
|
}
|
|
}
|
|
return null
|
|
}
|
|
|
|
function n(t, e, n) {
|
|
var i, a = t[e].fill,
|
|
o = [e];
|
|
if (!n) return a;
|
|
for (; !1 !== a && -1 === o.indexOf(a);) {
|
|
if (!isFinite(a)) return a;
|
|
if (!(i = t[a])) return !1;
|
|
if (i.visible) return a;
|
|
o.push(a), a = i.fill
|
|
}
|
|
return !1
|
|
}
|
|
|
|
function r(t) {
|
|
var e = t.fill,
|
|
n = "dataset";
|
|
return !1 === e ? null : (isFinite(e) || (n = "boundary"), d[n](t))
|
|
}
|
|
|
|
function l(t) {
|
|
return t && !t.skip
|
|
}
|
|
|
|
function s(t, e, n, i, a) {
|
|
var r;
|
|
if (i && a) {
|
|
for (t.moveTo(e[0].x, e[0].y), r = 1; r < i; ++r) o.canvas.lineTo(t, e[r - 1], e[r]);
|
|
for (t.lineTo(n[a - 1].x, n[a - 1].y), r = a - 1; r > 0; --r) o.canvas.lineTo(t, n[r], n[r - 1], !0)
|
|
}
|
|
}
|
|
|
|
function u(t, e, n, i, a, o) {
|
|
var r, u, d, c, h, f, g, p = e.length,
|
|
v = i.spanGaps,
|
|
m = [],
|
|
b = [],
|
|
x = 0,
|
|
y = 0;
|
|
for (t.beginPath(), r = 0, u = p + !!o; r < u; ++r) h = n(c = e[d = r % p]._view, d, i), f = l(c), g = l(h), f && g ? (x = m.push(c), y = b.push(h)) : x && y && (v ? (f && m.push(c), g && b.push(h)) : (s(t, m, b, x, y), x = y = 0, m = [], b = []));
|
|
s(t, m, b, x, y), t.closePath(), t.fillStyle = a, t.fill()
|
|
}
|
|
var d = {
|
|
dataset: function(t) {
|
|
var e = t.fill,
|
|
n = t.chart,
|
|
i = n.getDatasetMeta(e),
|
|
a = i && n.isDatasetVisible(e) && i.dataset._children || [],
|
|
o = a.length || 0;
|
|
return o ? function(t, e) {
|
|
return e < o && a[e]._view || null
|
|
} : null
|
|
},
|
|
boundary: function(t) {
|
|
var e = t.boundary,
|
|
n = e ? e.x : null,
|
|
i = e ? e.y : null;
|
|
return function(t) {
|
|
return {
|
|
x: null === n ? t.x : n,
|
|
y: null === i ? t.y : i
|
|
}
|
|
}
|
|
}
|
|
};
|
|
return {
|
|
id: "filler",
|
|
afterDatasetsUpdate: function(i, o) {
|
|
var l, s, u, d, c = (i.data.datasets || []).length,
|
|
h = o.propagate,
|
|
f = [];
|
|
for (s = 0; s < c; ++s) d = null, (u = (l = i.getDatasetMeta(s)).dataset) && u._model && u instanceof a.Line && (d = {
|
|
visible: i.isDatasetVisible(s),
|
|
fill: t(u, s, c),
|
|
chart: i,
|
|
el: u
|
|
}), l.$filler = d, f.push(d);
|
|
for (s = 0; s < c; ++s)(d = f[s]) && (d.fill = n(f, s, h), d.boundary = e(d), d.mapper = r(d))
|
|
},
|
|
beforeDatasetDraw: function(t, e) {
|
|
var n = e.meta.$filler;
|
|
if (n) {
|
|
var a = t.ctx,
|
|
r = n.el,
|
|
l = r._view,
|
|
s = r._children || [],
|
|
d = n.mapper,
|
|
c = l.backgroundColor || i.global.defaultColor;
|
|
d && c && s.length && (o.canvas.clipArea(a, t.chartArea), u(a, s, d, l, c, r._loop), o.canvas.unclipArea(a))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
25: 25,
|
|
40: 40,
|
|
45: 45
|
|
}],
|
|
50: [function(t, e, n) {
|
|
"use strict";
|
|
var i = t(25),
|
|
a = t(26),
|
|
o = t(45);
|
|
i._set("global", {
|
|
legend: {
|
|
display: !0,
|
|
position: "top",
|
|
fullWidth: !0,
|
|
reverse: !1,
|
|
weight: 1e3,
|
|
onClick: function(t, e) {
|
|
var n = e.datasetIndex,
|
|
i = this.chart,
|
|
a = i.getDatasetMeta(n);
|
|
a.hidden = null === a.hidden ? !i.data.datasets[n].hidden : null, i.update()
|
|
},
|
|
onHover: null,
|
|
labels: {
|
|
boxWidth: 40,
|
|
padding: 10,
|
|
generateLabels: function(t) {
|
|
var e = t.data;
|
|
return o.isArray(e.datasets) ? e.datasets.map(function(e, n) {
|
|
return {
|
|
text: e.label,
|
|
fillStyle: o.isArray(e.backgroundColor) ? e.backgroundColor[0] : e.backgroundColor,
|
|
hidden: !t.isDatasetVisible(n),
|
|
lineCap: e.borderCapStyle,
|
|
lineDash: e.borderDash,
|
|
lineDashOffset: e.borderDashOffset,
|
|
lineJoin: e.borderJoinStyle,
|
|
lineWidth: e.borderWidth,
|
|
strokeStyle: e.borderColor,
|
|
pointStyle: e.pointStyle,
|
|
datasetIndex: n
|
|
}
|
|
}, this) : []
|
|
}
|
|
}
|
|
},
|
|
legendCallback: function(t) {
|
|
var e = [];
|
|
e.push('<ul class="' + t.id + '-legend">');
|
|
for (var n = 0; n < t.data.datasets.length; n++) e.push('<li><span style="background-color:' + t.data.datasets[n].backgroundColor + '"></span>'), t.data.datasets[n].label && e.push(t.data.datasets[n].label), e.push("</li>");
|
|
return e.push("</ul>"), e.join("")
|
|
}
|
|
}), e.exports = function(t) {
|
|
function e(t, e) {
|
|
return t.usePointStyle ? e * Math.SQRT2 : t.boxWidth
|
|
}
|
|
|
|
function n(e, n) {
|
|
var i = new t.Legend({
|
|
ctx: e.ctx,
|
|
options: n,
|
|
chart: e
|
|
});
|
|
r.configure(e, i, n), r.addBox(e, i), e.legend = i
|
|
}
|
|
var r = t.layoutService,
|
|
l = o.noop;
|
|
return t.Legend = a.extend({
|
|
initialize: function(t) {
|
|
o.extend(this, t), this.legendHitBoxes = [], this.doughnutMode = !1
|
|
},
|
|
beforeUpdate: l,
|
|
update: function(t, e, n) {
|
|
var i = this;
|
|
return i.beforeUpdate(), i.maxWidth = t, i.maxHeight = e, i.margins = n, i.beforeSetDimensions(), i.setDimensions(), i.afterSetDimensions(), i.beforeBuildLabels(), i.buildLabels(), i.afterBuildLabels(), i.beforeFit(), i.fit(), i.afterFit(), i.afterUpdate(), i.minSize
|
|
},
|
|
afterUpdate: l,
|
|
beforeSetDimensions: l,
|
|
setDimensions: function() {
|
|
var t = this;
|
|
t.isHorizontal() ? (t.width = t.maxWidth, t.left = 0, t.right = t.width) : (t.height = t.maxHeight, t.top = 0, t.bottom = t.height), t.paddingLeft = 0, t.paddingTop = 0, t.paddingRight = 0, t.paddingBottom = 0, t.minSize = {
|
|
width: 0,
|
|
height: 0
|
|
}
|
|
},
|
|
afterSetDimensions: l,
|
|
beforeBuildLabels: l,
|
|
buildLabels: function() {
|
|
var t = this,
|
|
e = t.options.labels || {},
|
|
n = o.callback(e.generateLabels, [t.chart], t) || [];
|
|
e.filter && (n = n.filter(function(n) {
|
|
return e.filter(n, t.chart.data)
|
|
})), t.options.reverse && n.reverse(), t.legendItems = n
|
|
},
|
|
afterBuildLabels: l,
|
|
beforeFit: l,
|
|
fit: function() {
|
|
var t = this,
|
|
n = t.options,
|
|
a = n.labels,
|
|
r = n.display,
|
|
l = t.ctx,
|
|
s = i.global,
|
|
u = o.valueOrDefault,
|
|
d = u(a.fontSize, s.defaultFontSize),
|
|
c = u(a.fontStyle, s.defaultFontStyle),
|
|
h = u(a.fontFamily, s.defaultFontFamily),
|
|
f = o.fontString(d, c, h),
|
|
g = t.legendHitBoxes = [],
|
|
p = t.minSize,
|
|
v = t.isHorizontal();
|
|
if (v ? (p.width = t.maxWidth, p.height = r ? 10 : 0) : (p.width = r ? 10 : 0, p.height = t.maxHeight), r)
|
|
if (l.font = f, v) {
|
|
var m = t.lineWidths = [0],
|
|
b = t.legendItems.length ? d + a.padding : 0;
|
|
l.textAlign = "left", l.textBaseline = "top", o.each(t.legendItems, function(n, i) {
|
|
var o = e(a, d) + d / 2 + l.measureText(n.text).width;
|
|
m[m.length - 1] + o + a.padding >= t.width && (b += d + a.padding, m[m.length] = t.left), g[i] = {
|
|
left: 0,
|
|
top: 0,
|
|
width: o,
|
|
height: d
|
|
}, m[m.length - 1] += o + a.padding
|
|
}), p.height += b
|
|
} else {
|
|
var x = a.padding,
|
|
y = t.columnWidths = [],
|
|
k = a.padding,
|
|
w = 0,
|
|
M = 0,
|
|
S = d + x;
|
|
o.each(t.legendItems, function(t, n) {
|
|
var i = e(a, d) + d / 2 + l.measureText(t.text).width;
|
|
M + S > p.height && (k += w + a.padding, y.push(w), w = 0, M = 0), w = Math.max(w, i), M += S, g[n] = {
|
|
left: 0,
|
|
top: 0,
|
|
width: i,
|
|
height: d
|
|
}
|
|
}), k += w, y.push(w), p.width += k
|
|
}
|
|
t.width = p.width, t.height = p.height
|
|
},
|
|
afterFit: l,
|
|
isHorizontal: function() {
|
|
return "top" === this.options.position || "bottom" === this.options.position
|
|
},
|
|
draw: function() {
|
|
var t = this,
|
|
n = t.options,
|
|
a = n.labels,
|
|
r = i.global,
|
|
l = r.elements.line,
|
|
s = t.width,
|
|
u = t.lineWidths;
|
|
if (n.display) {
|
|
var d, c = t.ctx,
|
|
h = o.valueOrDefault,
|
|
f = h(a.fontColor, r.defaultFontColor),
|
|
g = h(a.fontSize, r.defaultFontSize),
|
|
p = h(a.fontStyle, r.defaultFontStyle),
|
|
v = h(a.fontFamily, r.defaultFontFamily),
|
|
m = o.fontString(g, p, v);
|
|
c.textAlign = "left", c.textBaseline = "middle", c.lineWidth = .5, c.strokeStyle = f, c.fillStyle = f, c.font = m;
|
|
var b = e(a, g),
|
|
x = t.legendHitBoxes,
|
|
y = function(t, e, i) {
|
|
if (!(isNaN(b) || b <= 0)) {
|
|
c.save(), c.fillStyle = h(i.fillStyle, r.defaultColor), c.lineCap = h(i.lineCap, l.borderCapStyle), c.lineDashOffset = h(i.lineDashOffset, l.borderDashOffset), c.lineJoin = h(i.lineJoin, l.borderJoinStyle), c.lineWidth = h(i.lineWidth, l.borderWidth), c.strokeStyle = h(i.strokeStyle, r.defaultColor);
|
|
var a = 0 === h(i.lineWidth, l.borderWidth);
|
|
if (c.setLineDash && c.setLineDash(h(i.lineDash, l.borderDash)), n.labels && n.labels.usePointStyle) {
|
|
var s = g * Math.SQRT2 / 2,
|
|
u = s / Math.SQRT2,
|
|
d = t + u,
|
|
f = e + u;
|
|
o.canvas.drawPoint(c, i.pointStyle, s, d, f)
|
|
} else a || c.strokeRect(t, e, b, g), c.fillRect(t, e, b, g);
|
|
c.restore()
|
|
}
|
|
},
|
|
k = function(t, e, n, i) {
|
|
var a = g / 2,
|
|
o = b + a + t,
|
|
r = e + a;
|
|
c.fillText(n.text, o, r), n.hidden && (c.beginPath(), c.lineWidth = 2, c.moveTo(o, r), c.lineTo(o + i, r), c.stroke())
|
|
},
|
|
w = t.isHorizontal();
|
|
d = w ? {
|
|
x: t.left + (s - u[0]) / 2,
|
|
y: t.top + a.padding,
|
|
line: 0
|
|
} : {
|
|
x: t.left + a.padding,
|
|
y: t.top + a.padding,
|
|
line: 0
|
|
};
|
|
var M = g + a.padding;
|
|
o.each(t.legendItems, function(e, n) {
|
|
var i = c.measureText(e.text).width,
|
|
o = b + g / 2 + i,
|
|
r = d.x,
|
|
l = d.y;
|
|
w ? r + o >= s && (l = d.y += M, d.line++, r = d.x = t.left + (s - u[d.line]) / 2) : l + M > t.bottom && (r = d.x = r + t.columnWidths[d.line] + a.padding, l = d.y = t.top + a.padding, d.line++), y(r, l, e), x[n].left = r, x[n].top = l, k(r, l, e, i), w ? d.x += o + a.padding : d.y += M
|
|
})
|
|
}
|
|
},
|
|
handleEvent: function(t) {
|
|
var e = this,
|
|
n = e.options,
|
|
i = "mouseup" === t.type ? "click" : t.type,
|
|
a = !1;
|
|
if ("mousemove" === i) {
|
|
if (!n.onHover) return
|
|
} else {
|
|
if ("click" !== i) return;
|
|
if (!n.onClick) return
|
|
}
|
|
var o = t.x,
|
|
r = t.y;
|
|
if (o >= e.left && o <= e.right && r >= e.top && r <= e.bottom)
|
|
for (var l = e.legendHitBoxes, s = 0; s < l.length; ++s) {
|
|
var u = l[s];
|
|
if (o >= u.left && o <= u.left + u.width && r >= u.top && r <= u.top + u.height) {
|
|
if ("click" === i) {
|
|
n.onClick.call(e, t.native, e.legendItems[s]), a = !0;
|
|
break
|
|
}
|
|
if ("mousemove" === i) {
|
|
n.onHover.call(e, t.native, e.legendItems[s]), a = !0;
|
|
break
|
|
}
|
|
}
|
|
}
|
|
return a
|
|
}
|
|
}), {
|
|
id: "legend",
|
|
beforeInit: function(t) {
|
|
var e = t.options.legend;
|
|
e && n(t, e)
|
|
},
|
|
beforeUpdate: function(t) {
|
|
var e = t.options.legend,
|
|
a = t.legend;
|
|
e ? (o.mergeIf(e, i.global.legend), a ? (r.configure(t, a, e), a.options = e) : n(t, e)) : a && (r.removeBox(t, a), delete t.legend)
|
|
},
|
|
afterEvent: function(t, e) {
|
|
var n = t.legend;
|
|
n && n.handleEvent(e)
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
25: 25,
|
|
26: 26,
|
|
45: 45
|
|
}],
|
|
51: [function(t, e, n) {
|
|
"use strict";
|
|
var i = t(25),
|
|
a = t(26),
|
|
o = t(45);
|
|
i._set("global", {
|
|
title: {
|
|
display: !1,
|
|
fontStyle: "bold",
|
|
fullWidth: !0,
|
|
lineHeight: 1.2,
|
|
padding: 10,
|
|
position: "top",
|
|
text: "",
|
|
weight: 2e3
|
|
}
|
|
}), e.exports = function(t) {
|
|
function e(e, i) {
|
|
var a = new t.Title({
|
|
ctx: e.ctx,
|
|
options: i,
|
|
chart: e
|
|
});
|
|
n.configure(e, a, i), n.addBox(e, a), e.titleBlock = a
|
|
}
|
|
var n = t.layoutService,
|
|
r = o.noop;
|
|
return t.Title = a.extend({
|
|
initialize: function(t) {
|
|
var e = this;
|
|
o.extend(e, t), e.legendHitBoxes = []
|
|
},
|
|
beforeUpdate: r,
|
|
update: function(t, e, n) {
|
|
var i = this;
|
|
return i.beforeUpdate(), i.maxWidth = t, i.maxHeight = e, i.margins = n, i.beforeSetDimensions(), i.setDimensions(), i.afterSetDimensions(), i.beforeBuildLabels(), i.buildLabels(), i.afterBuildLabels(), i.beforeFit(), i.fit(), i.afterFit(), i.afterUpdate(), i.minSize
|
|
},
|
|
afterUpdate: r,
|
|
beforeSetDimensions: r,
|
|
setDimensions: function() {
|
|
var t = this;
|
|
t.isHorizontal() ? (t.width = t.maxWidth, t.left = 0, t.right = t.width) : (t.height = t.maxHeight, t.top = 0, t.bottom = t.height), t.paddingLeft = 0, t.paddingTop = 0, t.paddingRight = 0, t.paddingBottom = 0, t.minSize = {
|
|
width: 0,
|
|
height: 0
|
|
}
|
|
},
|
|
afterSetDimensions: r,
|
|
beforeBuildLabels: r,
|
|
buildLabels: r,
|
|
afterBuildLabels: r,
|
|
beforeFit: r,
|
|
fit: function() {
|
|
var t = this,
|
|
e = o.valueOrDefault,
|
|
n = t.options,
|
|
a = n.display,
|
|
r = e(n.fontSize, i.global.defaultFontSize),
|
|
l = t.minSize,
|
|
s = o.isArray(n.text) ? n.text.length : 1,
|
|
u = o.options.toLineHeight(n.lineHeight, r),
|
|
d = a ? s * u + 2 * n.padding : 0;
|
|
t.isHorizontal() ? (l.width = t.maxWidth, l.height = d) : (l.width = d, l.height = t.maxHeight), t.width = l.width, t.height = l.height
|
|
},
|
|
afterFit: r,
|
|
isHorizontal: function() {
|
|
var t = this.options.position;
|
|
return "top" === t || "bottom" === t
|
|
},
|
|
draw: function() {
|
|
var t = this,
|
|
e = t.ctx,
|
|
n = o.valueOrDefault,
|
|
a = t.options,
|
|
r = i.global;
|
|
if (a.display) {
|
|
var l, s, u, d = n(a.fontSize, r.defaultFontSize),
|
|
c = n(a.fontStyle, r.defaultFontStyle),
|
|
h = n(a.fontFamily, r.defaultFontFamily),
|
|
f = o.fontString(d, c, h),
|
|
g = o.options.toLineHeight(a.lineHeight, d),
|
|
p = g / 2 + a.padding,
|
|
v = 0,
|
|
m = t.top,
|
|
b = t.left,
|
|
x = t.bottom,
|
|
y = t.right;
|
|
e.fillStyle = n(a.fontColor, r.defaultFontColor), e.font = f, t.isHorizontal() ? (s = b + (y - b) / 2, u = m + p, l = y - b) : (s = "left" === a.position ? b + p : y - p, u = m + (x - m) / 2, l = x - m, v = Math.PI * ("left" === a.position ? -.5 : .5)), e.save(), e.translate(s, u), e.rotate(v), e.textAlign = "center", e.textBaseline = "middle";
|
|
var k = a.text;
|
|
if (o.isArray(k))
|
|
for (var w = 0, M = 0; M < k.length; ++M) e.fillText(k[M], 0, w, l), w += g;
|
|
else e.fillText(k, 0, 0, l);
|
|
e.restore()
|
|
}
|
|
}
|
|
}), {
|
|
id: "title",
|
|
beforeInit: function(t) {
|
|
var n = t.options.title;
|
|
n && e(t, n)
|
|
},
|
|
beforeUpdate: function(a) {
|
|
var r = a.options.title,
|
|
l = a.titleBlock;
|
|
r ? (o.mergeIf(r, i.global.title), l ? (n.configure(a, l, r), l.options = r) : e(a, r)) : l && (t.layoutService.removeBox(a, l), delete a.titleBlock)
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
25: 25,
|
|
26: 26,
|
|
45: 45
|
|
}],
|
|
52: [function(t, e, n) {
|
|
"use strict";
|
|
e.exports = function(t) {
|
|
var e = {
|
|
position: "bottom"
|
|
},
|
|
n = t.Scale.extend({
|
|
getLabels: function() {
|
|
var t = this.chart.data;
|
|
return this.options.labels || (this.isHorizontal() ? t.xLabels : t.yLabels) || t.labels
|
|
},
|
|
determineDataLimits: function() {
|
|
var t = this,
|
|
e = t.getLabels();
|
|
t.minIndex = 0, t.maxIndex = e.length - 1;
|
|
var n;
|
|
void 0 !== t.options.ticks.min && (n = e.indexOf(t.options.ticks.min), t.minIndex = -1 !== n ? n : t.minIndex), void 0 !== t.options.ticks.max && (n = e.indexOf(t.options.ticks.max), t.maxIndex = -1 !== n ? n : t.maxIndex), t.min = e[t.minIndex], t.max = e[t.maxIndex]
|
|
},
|
|
buildTicks: function() {
|
|
var t = this,
|
|
e = t.getLabels();
|
|
t.ticks = 0 === t.minIndex && t.maxIndex === e.length - 1 ? e : e.slice(t.minIndex, t.maxIndex + 1)
|
|
},
|
|
getLabelForIndex: function(t, e) {
|
|
var n = this,
|
|
i = n.chart.data,
|
|
a = n.isHorizontal();
|
|
return i.yLabels && !a ? n.getRightValue(i.datasets[e].data[t]) : n.ticks[t - n.minIndex]
|
|
},
|
|
getPixelForValue: function(t, e) {
|
|
var n, i = this,
|
|
a = i.options.offset,
|
|
o = Math.max(i.maxIndex + 1 - i.minIndex - (a ? 0 : 1), 1);
|
|
if (void 0 !== t && null !== t && (n = i.isHorizontal() ? t.x : t.y), void 0 !== n || void 0 !== t && isNaN(e)) {
|
|
var r = i.getLabels();
|
|
t = n || t;
|
|
var l = r.indexOf(t);
|
|
e = -1 !== l ? l : e
|
|
}
|
|
if (i.isHorizontal()) {
|
|
var s = i.width / o,
|
|
u = s * (e - i.minIndex);
|
|
return a && (u += s / 2), i.left + Math.round(u)
|
|
}
|
|
var d = i.height / o,
|
|
c = d * (e - i.minIndex);
|
|
return a && (c += d / 2), i.top + Math.round(c)
|
|
},
|
|
getPixelForTick: function(t) {
|
|
return this.getPixelForValue(this.ticks[t], t + this.minIndex, null)
|
|
},
|
|
getValueForPixel: function(t) {
|
|
var e = this,
|
|
n = e.options.offset,
|
|
i = Math.max(e._ticks.length - (n ? 0 : 1), 1),
|
|
a = e.isHorizontal(),
|
|
o = (a ? e.width : e.height) / i;
|
|
return t -= a ? e.left : e.top, n && (t -= o / 2), (t <= 0 ? 0 : Math.round(t / o)) + e.minIndex
|
|
},
|
|
getBasePixel: function() {
|
|
return this.bottom
|
|
}
|
|
});
|
|
t.scaleService.registerScaleType("category", n, e)
|
|
}
|
|
}, {}],
|
|
53: [function(t, e, n) {
|
|
"use strict";
|
|
var i = t(25),
|
|
a = t(45),
|
|
o = t(34);
|
|
e.exports = function(t) {
|
|
var e = {
|
|
position: "left",
|
|
ticks: {
|
|
callback: o.formatters.linear
|
|
}
|
|
},
|
|
n = t.LinearScaleBase.extend({
|
|
determineDataLimits: function() {
|
|
function t(t) {
|
|
return r ? t.xAxisID === e.id : t.yAxisID === e.id
|
|
}
|
|
var e = this,
|
|
n = e.options,
|
|
i = e.chart,
|
|
o = i.data.datasets,
|
|
r = e.isHorizontal();
|
|
e.min = null, e.max = null;
|
|
var l = n.stacked;
|
|
if (void 0 === l && a.each(o, function(e, n) {
|
|
if (!l) {
|
|
var a = i.getDatasetMeta(n);
|
|
i.isDatasetVisible(n) && t(a) && void 0 !== a.stack && (l = !0)
|
|
}
|
|
}), n.stacked || l) {
|
|
var s = {};
|
|
a.each(o, function(o, r) {
|
|
var l = i.getDatasetMeta(r),
|
|
u = [l.type, void 0 === n.stacked && void 0 === l.stack ? r : "", l.stack].join(".");
|
|
void 0 === s[u] && (s[u] = {
|
|
positiveValues: [],
|
|
negativeValues: []
|
|
});
|
|
var d = s[u].positiveValues,
|
|
c = s[u].negativeValues;
|
|
i.isDatasetVisible(r) && t(l) && a.each(o.data, function(t, i) {
|
|
var a = +e.getRightValue(t);
|
|
isNaN(a) || l.data[i].hidden || (d[i] = d[i] || 0, c[i] = c[i] || 0, n.relativePoints ? d[i] = 100 : a < 0 ? c[i] += a : d[i] += a)
|
|
})
|
|
}), a.each(s, function(t) {
|
|
var n = t.positiveValues.concat(t.negativeValues),
|
|
i = a.min(n),
|
|
o = a.max(n);
|
|
e.min = null === e.min ? i : Math.min(e.min, i), e.max = null === e.max ? o : Math.max(e.max, o)
|
|
})
|
|
} else a.each(o, function(n, o) {
|
|
var r = i.getDatasetMeta(o);
|
|
i.isDatasetVisible(o) && t(r) && a.each(n.data, function(t, n) {
|
|
var i = +e.getRightValue(t);
|
|
isNaN(i) || r.data[n].hidden || (null === e.min ? e.min = i : i < e.min && (e.min = i), null === e.max ? e.max = i : i > e.max && (e.max = i))
|
|
})
|
|
});
|
|
e.min = isFinite(e.min) && !isNaN(e.min) ? e.min : 0, e.max = isFinite(e.max) && !isNaN(e.max) ? e.max : 1, this.handleTickRangeOptions()
|
|
},
|
|
getTickLimit: function() {
|
|
var t, e = this,
|
|
n = e.options.ticks;
|
|
if (e.isHorizontal()) t = Math.min(n.maxTicksLimit ? n.maxTicksLimit : 11, Math.ceil(e.width / 50));
|
|
else {
|
|
var o = a.valueOrDefault(n.fontSize, i.global.defaultFontSize);
|
|
t = Math.min(n.maxTicksLimit ? n.maxTicksLimit : 11, Math.ceil(e.height / (2 * o)))
|
|
}
|
|
return t
|
|
},
|
|
handleDirectionalChanges: function() {
|
|
this.isHorizontal() || this.ticks.reverse()
|
|
},
|
|
getLabelForIndex: function(t, e) {
|
|
return +this.getRightValue(this.chart.data.datasets[e].data[t])
|
|
},
|
|
getPixelForValue: function(t) {
|
|
var e, n = this,
|
|
i = n.start,
|
|
a = +n.getRightValue(t),
|
|
o = n.end - i;
|
|
return n.isHorizontal() ? (e = n.left + n.width / o * (a - i), Math.round(e)) : (e = n.bottom - n.height / o * (a - i), Math.round(e))
|
|
},
|
|
getValueForPixel: function(t) {
|
|
var e = this,
|
|
n = e.isHorizontal(),
|
|
i = n ? e.width : e.height,
|
|
a = (n ? t - e.left : e.bottom - t) / i;
|
|
return e.start + (e.end - e.start) * a
|
|
},
|
|
getPixelForTick: function(t) {
|
|
return this.getPixelForValue(this.ticksAsNumbers[t])
|
|
}
|
|
});
|
|
t.scaleService.registerScaleType("linear", n, e)
|
|
}
|
|
}, {
|
|
25: 25,
|
|
34: 34,
|
|
45: 45
|
|
}],
|
|
54: [function(t, e, n) {
|
|
"use strict";
|
|
var i = t(45),
|
|
a = t(34);
|
|
e.exports = function(t) {
|
|
var e = i.noop;
|
|
t.LinearScaleBase = t.Scale.extend({
|
|
getRightValue: function(e) {
|
|
return "string" == typeof e ? +e : t.Scale.prototype.getRightValue.call(this, e)
|
|
},
|
|
handleTickRangeOptions: function() {
|
|
var t = this,
|
|
e = t.options.ticks;
|
|
if (e.beginAtZero) {
|
|
var n = i.sign(t.min),
|
|
a = i.sign(t.max);
|
|
n < 0 && a < 0 ? t.max = 0 : n > 0 && a > 0 && (t.min = 0)
|
|
}
|
|
var o = void 0 !== e.min || void 0 !== e.suggestedMin,
|
|
r = void 0 !== e.max || void 0 !== e.suggestedMax;
|
|
void 0 !== e.min ? t.min = e.min : void 0 !== e.suggestedMin && (null === t.min ? t.min = e.suggestedMin : t.min = Math.min(t.min, e.suggestedMin)), void 0 !== e.max ? t.max = e.max : void 0 !== e.suggestedMax && (null === t.max ? t.max = e.suggestedMax : t.max = Math.max(t.max, e.suggestedMax)), o !== r && t.min >= t.max && (o ? t.max = t.min + 1 : t.min = t.max - 1), t.min === t.max && (t.max++, e.beginAtZero || t.min--)
|
|
},
|
|
getTickLimit: e,
|
|
handleDirectionalChanges: e,
|
|
buildTicks: function() {
|
|
var t = this,
|
|
e = t.options.ticks,
|
|
n = t.getTickLimit(),
|
|
o = {
|
|
maxTicks: n = Math.max(2, n),
|
|
min: e.min,
|
|
max: e.max,
|
|
stepSize: i.valueOrDefault(e.fixedStepSize, e.stepSize)
|
|
},
|
|
r = t.ticks = a.generators.linear(o, t);
|
|
t.handleDirectionalChanges(), t.max = i.max(r), t.min = i.min(r), e.reverse ? (r.reverse(), t.start = t.max, t.end = t.min) : (t.start = t.min, t.end = t.max)
|
|
},
|
|
convertTicksToLabels: function() {
|
|
var e = this;
|
|
e.ticksAsNumbers = e.ticks.slice(), e.zeroLineIndex = e.ticks.indexOf(0), t.Scale.prototype.convertTicksToLabels.call(e)
|
|
}
|
|
})
|
|
}
|
|
}, {
|
|
34: 34,
|
|
45: 45
|
|
}],
|
|
55: [function(t, e, n) {
|
|
"use strict";
|
|
var i = t(45),
|
|
a = t(34);
|
|
e.exports = function(t) {
|
|
var e = {
|
|
position: "left",
|
|
ticks: {
|
|
callback: a.formatters.logarithmic
|
|
}
|
|
},
|
|
n = t.Scale.extend({
|
|
determineDataLimits: function() {
|
|
function t(t) {
|
|
return s ? t.xAxisID === e.id : t.yAxisID === e.id
|
|
}
|
|
var e = this,
|
|
n = e.options,
|
|
a = n.ticks,
|
|
o = e.chart,
|
|
r = o.data.datasets,
|
|
l = i.valueOrDefault,
|
|
s = e.isHorizontal();
|
|
e.min = null, e.max = null, e.minNotZero = null;
|
|
var u = n.stacked;
|
|
if (void 0 === u && i.each(r, function(e, n) {
|
|
if (!u) {
|
|
var i = o.getDatasetMeta(n);
|
|
o.isDatasetVisible(n) && t(i) && void 0 !== i.stack && (u = !0)
|
|
}
|
|
}), n.stacked || u) {
|
|
var d = {};
|
|
i.each(r, function(a, r) {
|
|
var l = o.getDatasetMeta(r),
|
|
s = [l.type, void 0 === n.stacked && void 0 === l.stack ? r : "", l.stack].join(".");
|
|
o.isDatasetVisible(r) && t(l) && (void 0 === d[s] && (d[s] = []), i.each(a.data, function(t, i) {
|
|
var a = d[s],
|
|
o = +e.getRightValue(t);
|
|
isNaN(o) || l.data[i].hidden || (a[i] = a[i] || 0, n.relativePoints ? a[i] = 100 : a[i] += o)
|
|
}))
|
|
}), i.each(d, function(t) {
|
|
var n = i.min(t),
|
|
a = i.max(t);
|
|
e.min = null === e.min ? n : Math.min(e.min, n), e.max = null === e.max ? a : Math.max(e.max, a)
|
|
})
|
|
} else i.each(r, function(n, a) {
|
|
var r = o.getDatasetMeta(a);
|
|
o.isDatasetVisible(a) && t(r) && i.each(n.data, function(t, n) {
|
|
var i = +e.getRightValue(t);
|
|
isNaN(i) || r.data[n].hidden || (null === e.min ? e.min = i : i < e.min && (e.min = i), null === e.max ? e.max = i : i > e.max && (e.max = i), 0 !== i && (null === e.minNotZero || i < e.minNotZero) && (e.minNotZero = i))
|
|
})
|
|
});
|
|
e.min = l(a.min, e.min), e.max = l(a.max, e.max), e.min === e.max && (0 !== e.min && null !== e.min ? (e.min = Math.pow(10, Math.floor(i.log10(e.min)) - 1), e.max = Math.pow(10, Math.floor(i.log10(e.max)) + 1)) : (e.min = 1, e.max = 10))
|
|
},
|
|
buildTicks: function() {
|
|
var t = this,
|
|
e = t.options.ticks,
|
|
n = {
|
|
min: e.min,
|
|
max: e.max
|
|
},
|
|
o = t.ticks = a.generators.logarithmic(n, t);
|
|
t.isHorizontal() || o.reverse(), t.max = i.max(o), t.min = i.min(o), e.reverse ? (o.reverse(), t.start = t.max, t.end = t.min) : (t.start = t.min, t.end = t.max)
|
|
},
|
|
convertTicksToLabels: function() {
|
|
this.tickValues = this.ticks.slice(), t.Scale.prototype.convertTicksToLabels.call(this)
|
|
},
|
|
getLabelForIndex: function(t, e) {
|
|
return +this.getRightValue(this.chart.data.datasets[e].data[t])
|
|
},
|
|
getPixelForTick: function(t) {
|
|
return this.getPixelForValue(this.tickValues[t])
|
|
},
|
|
getPixelForValue: function(t) {
|
|
var e, n, a, o = this,
|
|
r = o.start,
|
|
l = +o.getRightValue(t),
|
|
s = o.options.ticks;
|
|
return o.isHorizontal() ? (a = i.log10(o.end) - i.log10(r), 0 === l ? n = o.left : (e = o.width, n = o.left + e / a * (i.log10(l) - i.log10(r)))) : (e = o.height, 0 !== r || s.reverse ? 0 === o.end && s.reverse ? (a = i.log10(o.start) - i.log10(o.minNotZero), n = l === o.end ? o.top : l === o.minNotZero ? o.top + .02 * e : o.top + .02 * e + .98 * e / a * (i.log10(l) - i.log10(o.minNotZero))) : 0 === l ? n = s.reverse ? o.top : o.bottom : (a = i.log10(o.end) - i.log10(r), e = o.height, n = o.bottom - e / a * (i.log10(l) - i.log10(r))) : (a = i.log10(o.end) - i.log10(o.minNotZero), n = l === r ? o.bottom : l === o.minNotZero ? o.bottom - .02 * e : o.bottom - .02 * e - .98 * e / a * (i.log10(l) - i.log10(o.minNotZero)))), n
|
|
},
|
|
getValueForPixel: function(t) {
|
|
var e, n, a = this,
|
|
o = i.log10(a.end) - i.log10(a.start);
|
|
return a.isHorizontal() ? (n = a.width, e = a.start * Math.pow(10, (t - a.left) * o / n)) : (n = a.height, e = Math.pow(10, (a.bottom - t) * o / n) / a.start), e
|
|
}
|
|
});
|
|
t.scaleService.registerScaleType("logarithmic", n, e)
|
|
}
|
|
}, {
|
|
34: 34,
|
|
45: 45
|
|
}],
|
|
56: [function(t, e, n) {
|
|
"use strict";
|
|
var i = t(25),
|
|
a = t(45),
|
|
o = t(34);
|
|
e.exports = function(t) {
|
|
function e(t) {
|
|
var e = t.options;
|
|
return e.angleLines.display || e.pointLabels.display ? t.chart.data.labels.length : 0
|
|
}
|
|
|
|
function n(t) {
|
|
var e = t.options.pointLabels,
|
|
n = a.valueOrDefault(e.fontSize, v.defaultFontSize),
|
|
i = a.valueOrDefault(e.fontStyle, v.defaultFontStyle),
|
|
o = a.valueOrDefault(e.fontFamily, v.defaultFontFamily);
|
|
return {
|
|
size: n,
|
|
style: i,
|
|
family: o,
|
|
font: a.fontString(n, i, o)
|
|
}
|
|
}
|
|
|
|
function r(t, e, n) {
|
|
return a.isArray(n) ? {
|
|
w: a.longestText(t, t.font, n),
|
|
h: n.length * e + 1.5 * (n.length - 1) * e
|
|
} : {
|
|
w: t.measureText(n).width,
|
|
h: e
|
|
}
|
|
}
|
|
|
|
function l(t, e, n, i, a) {
|
|
return t === i || t === a ? {
|
|
start: e - n / 2,
|
|
end: e + n / 2
|
|
} : t < i || t > a ? {
|
|
start: e - n - 5,
|
|
end: e
|
|
} : {
|
|
start: e,
|
|
end: e + n + 5
|
|
}
|
|
}
|
|
|
|
function s(t) {
|
|
var i, o, s, u = n(t),
|
|
d = Math.min(t.height / 2, t.width / 2),
|
|
c = {
|
|
r: t.width,
|
|
l: 0,
|
|
t: t.height,
|
|
b: 0
|
|
},
|
|
h = {};
|
|
t.ctx.font = u.font, t._pointLabelSizes = [];
|
|
var f = e(t);
|
|
for (i = 0; i < f; i++) {
|
|
s = t.getPointPosition(i, d), o = r(t.ctx, u.size, t.pointLabels[i] || ""), t._pointLabelSizes[i] = o;
|
|
var g = t.getIndexAngle(i),
|
|
p = a.toDegrees(g) % 360,
|
|
v = l(p, s.x, o.w, 0, 180),
|
|
m = l(p, s.y, o.h, 90, 270);
|
|
v.start < c.l && (c.l = v.start, h.l = g), v.end > c.r && (c.r = v.end, h.r = g), m.start < c.t && (c.t = m.start, h.t = g), m.end > c.b && (c.b = m.end, h.b = g)
|
|
}
|
|
t.setReductions(d, c, h)
|
|
}
|
|
|
|
function u(t) {
|
|
var e = Math.min(t.height / 2, t.width / 2);
|
|
t.drawingArea = Math.round(e), t.setCenterPoint(0, 0, 0, 0)
|
|
}
|
|
|
|
function d(t) {
|
|
return 0 === t || 180 === t ? "center" : t < 180 ? "left" : "right"
|
|
}
|
|
|
|
function c(t, e, n, i) {
|
|
if (a.isArray(e))
|
|
for (var o = n.y, r = 1.5 * i, l = 0; l < e.length; ++l) t.fillText(e[l], n.x, o), o += r;
|
|
else t.fillText(e, n.x, n.y)
|
|
}
|
|
|
|
function h(t, e, n) {
|
|
90 === t || 270 === t ? n.y -= e.h / 2 : (t > 270 || t < 90) && (n.y -= e.h)
|
|
}
|
|
|
|
function f(t) {
|
|
var i = t.ctx,
|
|
o = a.valueOrDefault,
|
|
r = t.options,
|
|
l = r.angleLines,
|
|
s = r.pointLabels;
|
|
i.lineWidth = l.lineWidth, i.strokeStyle = l.color;
|
|
var u = t.getDistanceFromCenterForValue(r.ticks.reverse ? t.min : t.max),
|
|
f = n(t);
|
|
i.textBaseline = "top";
|
|
for (var g = e(t) - 1; g >= 0; g--) {
|
|
if (l.display) {
|
|
var p = t.getPointPosition(g, u);
|
|
i.beginPath(), i.moveTo(t.xCenter, t.yCenter), i.lineTo(p.x, p.y), i.stroke(), i.closePath()
|
|
}
|
|
if (s.display) {
|
|
var m = t.getPointPosition(g, u + 5),
|
|
b = o(s.fontColor, v.defaultFontColor);
|
|
i.font = f.font, i.fillStyle = b;
|
|
var x = t.getIndexAngle(g),
|
|
y = a.toDegrees(x);
|
|
i.textAlign = d(y), h(y, t._pointLabelSizes[g], m), c(i, t.pointLabels[g] || "", m, f.size)
|
|
}
|
|
}
|
|
}
|
|
|
|
function g(t, n, i, o) {
|
|
var r = t.ctx;
|
|
if (r.strokeStyle = a.valueAtIndexOrDefault(n.color, o - 1), r.lineWidth = a.valueAtIndexOrDefault(n.lineWidth, o - 1), t.options.gridLines.circular) r.beginPath(), r.arc(t.xCenter, t.yCenter, i, 0, 2 * Math.PI), r.closePath(), r.stroke();
|
|
else {
|
|
var l = e(t);
|
|
if (0 === l) return;
|
|
r.beginPath();
|
|
var s = t.getPointPosition(0, i);
|
|
r.moveTo(s.x, s.y);
|
|
for (var u = 1; u < l; u++) s = t.getPointPosition(u, i), r.lineTo(s.x, s.y);
|
|
r.closePath(), r.stroke()
|
|
}
|
|
}
|
|
|
|
function p(t) {
|
|
return a.isNumber(t) ? t : 0
|
|
}
|
|
var v = i.global,
|
|
m = {
|
|
display: !0,
|
|
animate: !0,
|
|
position: "chartArea",
|
|
angleLines: {
|
|
display: !0,
|
|
color: "rgba(0, 0, 0, 0.1)",
|
|
lineWidth: 1
|
|
},
|
|
gridLines: {
|
|
circular: !1
|
|
},
|
|
ticks: {
|
|
showLabelBackdrop: !0,
|
|
backdropColor: "rgba(255,255,255,0.75)",
|
|
backdropPaddingY: 2,
|
|
backdropPaddingX: 2,
|
|
callback: o.formatters.linear
|
|
},
|
|
pointLabels: {
|
|
display: !0,
|
|
fontSize: 10,
|
|
callback: function(t) {
|
|
return t
|
|
}
|
|
}
|
|
},
|
|
b = t.LinearScaleBase.extend({
|
|
setDimensions: function() {
|
|
var t = this,
|
|
e = t.options,
|
|
n = e.ticks;
|
|
t.width = t.maxWidth, t.height = t.maxHeight, t.xCenter = Math.round(t.width / 2), t.yCenter = Math.round(t.height / 2);
|
|
var i = a.min([t.height, t.width]),
|
|
o = a.valueOrDefault(n.fontSize, v.defaultFontSize);
|
|
t.drawingArea = e.display ? i / 2 - (o / 2 + n.backdropPaddingY) : i / 2
|
|
},
|
|
determineDataLimits: function() {
|
|
var t = this,
|
|
e = t.chart,
|
|
n = Number.POSITIVE_INFINITY,
|
|
i = Number.NEGATIVE_INFINITY;
|
|
a.each(e.data.datasets, function(o, r) {
|
|
if (e.isDatasetVisible(r)) {
|
|
var l = e.getDatasetMeta(r);
|
|
a.each(o.data, function(e, a) {
|
|
var o = +t.getRightValue(e);
|
|
isNaN(o) || l.data[a].hidden || (n = Math.min(o, n), i = Math.max(o, i))
|
|
})
|
|
}
|
|
}), t.min = n === Number.POSITIVE_INFINITY ? 0 : n, t.max = i === Number.NEGATIVE_INFINITY ? 0 : i, t.handleTickRangeOptions()
|
|
},
|
|
getTickLimit: function() {
|
|
var t = this.options.ticks,
|
|
e = a.valueOrDefault(t.fontSize, v.defaultFontSize);
|
|
return Math.min(t.maxTicksLimit ? t.maxTicksLimit : 11, Math.ceil(this.drawingArea / (1.5 * e)))
|
|
},
|
|
convertTicksToLabels: function() {
|
|
var e = this;
|
|
t.LinearScaleBase.prototype.convertTicksToLabels.call(e), e.pointLabels = e.chart.data.labels.map(e.options.pointLabels.callback, e)
|
|
},
|
|
getLabelForIndex: function(t, e) {
|
|
return +this.getRightValue(this.chart.data.datasets[e].data[t])
|
|
},
|
|
fit: function() {
|
|
this.options.pointLabels.display ? s(this) : u(this)
|
|
},
|
|
setReductions: function(t, e, n) {
|
|
var i = this,
|
|
a = e.l / Math.sin(n.l),
|
|
o = Math.max(e.r - i.width, 0) / Math.sin(n.r),
|
|
r = -e.t / Math.cos(n.t),
|
|
l = -Math.max(e.b - i.height, 0) / Math.cos(n.b);
|
|
a = p(a), o = p(o), r = p(r), l = p(l), i.drawingArea = Math.min(Math.round(t - (a + o) / 2), Math.round(t - (r + l) / 2)), i.setCenterPoint(a, o, r, l)
|
|
},
|
|
setCenterPoint: function(t, e, n, i) {
|
|
var a = this,
|
|
o = a.width - e - a.drawingArea,
|
|
r = t + a.drawingArea,
|
|
l = n + a.drawingArea,
|
|
s = a.height - i - a.drawingArea;
|
|
a.xCenter = Math.round((r + o) / 2 + a.left), a.yCenter = Math.round((l + s) / 2 + a.top)
|
|
},
|
|
getIndexAngle: function(t) {
|
|
return t * (2 * Math.PI / e(this)) + (this.chart.options && this.chart.options.startAngle ? this.chart.options.startAngle : 0) * Math.PI * 2 / 360
|
|
},
|
|
getDistanceFromCenterForValue: function(t) {
|
|
var e = this;
|
|
if (null === t) return 0;
|
|
var n = e.drawingArea / (e.max - e.min);
|
|
return e.options.ticks.reverse ? (e.max - t) * n : (t - e.min) * n
|
|
},
|
|
getPointPosition: function(t, e) {
|
|
var n = this,
|
|
i = n.getIndexAngle(t) - Math.PI / 2;
|
|
return {
|
|
x: Math.round(Math.cos(i) * e) + n.xCenter,
|
|
y: Math.round(Math.sin(i) * e) + n.yCenter
|
|
}
|
|
},
|
|
getPointPositionForValue: function(t, e) {
|
|
return this.getPointPosition(t, this.getDistanceFromCenterForValue(e))
|
|
},
|
|
getBasePosition: function() {
|
|
var t = this,
|
|
e = t.min,
|
|
n = t.max;
|
|
return t.getPointPositionForValue(0, t.beginAtZero ? 0 : e < 0 && n < 0 ? n : e > 0 && n > 0 ? e : 0)
|
|
},
|
|
draw: function() {
|
|
var t = this,
|
|
e = t.options,
|
|
n = e.gridLines,
|
|
i = e.ticks,
|
|
o = a.valueOrDefault;
|
|
if (e.display) {
|
|
var r = t.ctx,
|
|
l = this.getIndexAngle(0),
|
|
s = o(i.fontSize, v.defaultFontSize),
|
|
u = o(i.fontStyle, v.defaultFontStyle),
|
|
d = o(i.fontFamily, v.defaultFontFamily),
|
|
c = a.fontString(s, u, d);
|
|
a.each(t.ticks, function(e, a) {
|
|
if (a > 0 || i.reverse) {
|
|
var u = t.getDistanceFromCenterForValue(t.ticksAsNumbers[a]);
|
|
if (n.display && 0 !== a && g(t, n, u, a), i.display) {
|
|
var d = o(i.fontColor, v.defaultFontColor);
|
|
if (r.font = c, r.save(), r.translate(t.xCenter, t.yCenter), r.rotate(l), i.showLabelBackdrop) {
|
|
var h = r.measureText(e).width;
|
|
r.fillStyle = i.backdropColor, r.fillRect(-h / 2 - i.backdropPaddingX, -u - s / 2 - i.backdropPaddingY, h + 2 * i.backdropPaddingX, s + 2 * i.backdropPaddingY)
|
|
}
|
|
r.textAlign = "center", r.textBaseline = "middle", r.fillStyle = d, r.fillText(e, 0, -u), r.restore()
|
|
}
|
|
}
|
|
}), (e.angleLines.display || e.pointLabels.display) && f(t)
|
|
}
|
|
}
|
|
});
|
|
t.scaleService.registerScaleType("radialLinear", b, m)
|
|
}
|
|
}, {
|
|
25: 25,
|
|
34: 34,
|
|
45: 45
|
|
}],
|
|
57: [function(t, e, n) {
|
|
"use strict";
|
|
|
|
function i(t, e) {
|
|
return t - e
|
|
}
|
|
|
|
function a(t) {
|
|
var e, n, i, a = {},
|
|
o = [];
|
|
for (e = 0, n = t.length; e < n; ++e) a[i = t[e]] || (a[i] = !0, o.push(i));
|
|
return o
|
|
}
|
|
|
|
function o(t, e, n, i) {
|
|
if ("linear" === i || !t.length) return [{
|
|
time: e,
|
|
pos: 0
|
|
}, {
|
|
time: n,
|
|
pos: 1
|
|
}];
|
|
var a, o, r, l, s, u = [],
|
|
d = [e];
|
|
for (a = 0, o = t.length; a < o; ++a)(l = t[a]) > e && l < n && d.push(l);
|
|
for (d.push(n), a = 0, o = d.length; a < o; ++a) s = d[a + 1], r = d[a - 1], l = d[a], void 0 !== r && void 0 !== s && Math.round((s + r) / 2) === l || u.push({
|
|
time: l,
|
|
pos: a / (o - 1)
|
|
});
|
|
return u
|
|
}
|
|
|
|
function r(t, e, n) {
|
|
for (var i, a, o, r = 0, l = t.length - 1; r >= 0 && r <= l;) {
|
|
if (i = r + l >> 1, a = t[i - 1] || null, o = t[i], !a) return {
|
|
lo: null,
|
|
hi: o
|
|
};
|
|
if (o[e] < n) r = i + 1;
|
|
else {
|
|
if (!(a[e] > n)) return {
|
|
lo: a,
|
|
hi: o
|
|
};
|
|
l = i - 1
|
|
}
|
|
}
|
|
return {
|
|
lo: o,
|
|
hi: null
|
|
}
|
|
}
|
|
|
|
function l(t, e, n, i) {
|
|
var a = r(t, e, n),
|
|
o = a.lo ? a.hi ? a.lo : t[t.length - 2] : t[0],
|
|
l = a.lo ? a.hi ? a.hi : t[t.length - 1] : t[1],
|
|
s = l[e] - o[e],
|
|
u = s ? (n - o[e]) / s : 0,
|
|
d = (l[i] - o[i]) * u;
|
|
return o[i] + d
|
|
}
|
|
|
|
function s(t, e) {
|
|
var n = e.parser,
|
|
i = e.parser || e.format;
|
|
return "function" == typeof n ? n(t) : "string" == typeof t && "string" == typeof i ? v(t, i) : (t instanceof v || (t = v(t)), t.isValid() ? t : "function" == typeof i ? i(t) : t)
|
|
}
|
|
|
|
function u(t, e) {
|
|
if (b.isNullOrUndef(t)) return null;
|
|
var n = e.options.time,
|
|
i = s(e.getRightValue(t), n);
|
|
return i.isValid() ? (n.round && i.startOf(n.round), i.valueOf()) : null
|
|
}
|
|
|
|
function d(t, e, n, i) {
|
|
var a, o, r, l = e - t,
|
|
s = k[n],
|
|
u = s.size,
|
|
d = s.steps;
|
|
if (!d) return Math.ceil(l / ((i || 1) * u));
|
|
for (a = 0, o = d.length; a < o && (r = d[a], !(Math.ceil(l / (u * r)) <= i)); ++a);
|
|
return r
|
|
}
|
|
|
|
function c(t, e, n, i) {
|
|
var a, o, r, l = w.length;
|
|
for (a = w.indexOf(t); a < l - 1; ++a)
|
|
if (o = k[w[a]], r = o.steps ? o.steps[o.steps.length - 1] : y, Math.ceil((n - e) / (r * o.size)) <= i) return w[a];
|
|
return w[l - 1]
|
|
}
|
|
|
|
function h(t) {
|
|
for (var e = w.indexOf(t) + 1, n = w.length; e < n; ++e)
|
|
if (k[w[e]].major) return w[e]
|
|
}
|
|
|
|
function f(t, e, n, i, a, o) {
|
|
var r, l = o.time,
|
|
s = b.valueOrDefault(l.stepSize, l.unitStepSize),
|
|
u = "week" === n && l.isoWeekday,
|
|
c = o.ticks.major.enabled,
|
|
h = k[n],
|
|
f = v(t),
|
|
g = v(e),
|
|
p = [];
|
|
for (s || (s = d(t, e, n, a)), u && (f = f.isoWeekday(u), g = g.isoWeekday(u)), f = f.startOf(u ? "day" : n), (g = g.startOf(u ? "day" : n)) < e && g.add(1, n), r = v(f), c && i && !u && !l.round && (r.startOf(i), r.add(~~((f - r) / (h.size * s)) * s, n)); r < g; r.add(s, n)) p.push(+r);
|
|
return p.push(+r), p
|
|
}
|
|
|
|
function g(t, e, n, i, a) {
|
|
var o, r, s = 0,
|
|
u = 0;
|
|
return a.offset && e.length && (a.time.min || (o = e.length > 1 ? e[1] : i, r = e[0], s = (l(t, "time", o, "pos") - l(t, "time", r, "pos")) / 2), a.time.max || (o = e[e.length - 1], r = e.length > 1 ? e[e.length - 2] : n, u = (l(t, "time", o, "pos") - l(t, "time", r, "pos")) / 2)), {
|
|
left: s,
|
|
right: u
|
|
}
|
|
}
|
|
|
|
function p(t, e) {
|
|
var n, i, a, o, r = [];
|
|
for (n = 0, i = t.length; n < i; ++n) a = t[n], o = !!e && a === +v(a).startOf(e), r.push({
|
|
value: a,
|
|
major: o
|
|
});
|
|
return r
|
|
}
|
|
var v = t(1);
|
|
v = "function" == typeof v ? v : window.moment;
|
|
var m = t(25),
|
|
b = t(45),
|
|
x = Number.MIN_SAFE_INTEGER || -9007199254740991,
|
|
y = Number.MAX_SAFE_INTEGER || 9007199254740991,
|
|
k = {
|
|
millisecond: {
|
|
major: !0,
|
|
size: 1,
|
|
steps: [1, 2, 5, 10, 20, 50, 100, 250, 500]
|
|
},
|
|
second: {
|
|
major: !0,
|
|
size: 1e3,
|
|
steps: [1, 2, 5, 10, 30]
|
|
},
|
|
minute: {
|
|
major: !0,
|
|
size: 6e4,
|
|
steps: [1, 2, 5, 10, 30]
|
|
},
|
|
hour: {
|
|
major: !0,
|
|
size: 36e5,
|
|
steps: [1, 2, 3, 6, 12]
|
|
},
|
|
day: {
|
|
major: !0,
|
|
size: 864e5,
|
|
steps: [1, 2, 5]
|
|
},
|
|
week: {
|
|
major: !1,
|
|
size: 6048e5,
|
|
steps: [1, 2, 3, 4]
|
|
},
|
|
month: {
|
|
major: !0,
|
|
size: 2628e6,
|
|
steps: [1, 2, 3]
|
|
},
|
|
quarter: {
|
|
major: !1,
|
|
size: 7884e6,
|
|
steps: [1, 2, 3, 4]
|
|
},
|
|
year: {
|
|
major: !0,
|
|
size: 3154e7
|
|
}
|
|
},
|
|
w = Object.keys(k);
|
|
e.exports = function(t) {
|
|
var e = {
|
|
position: "bottom",
|
|
distribution: "linear",
|
|
bounds: "data",
|
|
time: {
|
|
parser: !1,
|
|
format: !1,
|
|
unit: !1,
|
|
round: !1,
|
|
displayFormat: !1,
|
|
isoWeekday: !1,
|
|
minUnit: "millisecond",
|
|
displayFormats: {
|
|
millisecond: "h:mm:ss.SSS a",
|
|
second: "h:mm:ss a",
|
|
minute: "h:mm a",
|
|
hour: "hA",
|
|
day: "MMM D",
|
|
week: "ll",
|
|
month: "MMM YYYY",
|
|
quarter: "[Q]Q - YYYY",
|
|
year: "YYYY"
|
|
}
|
|
},
|
|
ticks: {
|
|
autoSkip: !1,
|
|
source: "auto",
|
|
major: {
|
|
enabled: !1
|
|
}
|
|
}
|
|
},
|
|
n = t.Scale.extend({
|
|
initialize: function() {
|
|
if (!v) throw new Error("Chart.js - Moment.js could not be found! You must include it before Chart.js to use the time scale. Download at https://momentjs.com");
|
|
this.mergeTicksOptions(), t.Scale.prototype.initialize.call(this)
|
|
},
|
|
update: function() {
|
|
var e = this,
|
|
n = e.options;
|
|
return n.time && n.time.format && console.warn("options.time.format is deprecated and replaced by options.time.parser."), t.Scale.prototype.update.apply(e, arguments)
|
|
},
|
|
getRightValue: function(e) {
|
|
return e && void 0 !== e.t && (e = e.t), t.Scale.prototype.getRightValue.call(this, e)
|
|
},
|
|
determineDataLimits: function() {
|
|
var t, e, n, o, r, l, s = this,
|
|
d = s.chart,
|
|
c = s.options.time,
|
|
h = u(c.min, s) || y,
|
|
f = u(c.max, s) || x,
|
|
g = [],
|
|
p = [],
|
|
m = [];
|
|
for (t = 0, n = d.data.labels.length; t < n; ++t) m.push(u(d.data.labels[t], s));
|
|
for (t = 0, n = (d.data.datasets || []).length; t < n; ++t)
|
|
if (d.isDatasetVisible(t))
|
|
if (r = d.data.datasets[t].data, b.isObject(r[0]))
|
|
for (p[t] = [], e = 0, o = r.length; e < o; ++e) l = u(r[e], s), g.push(l), p[t][e] = l;
|
|
else g.push.apply(g, m), p[t] = m.slice(0);
|
|
else p[t] = [];
|
|
m.length && (m = a(m).sort(i), h = Math.min(h, m[0]), f = Math.max(f, m[m.length - 1])), g.length && (g = a(g).sort(i), h = Math.min(h, g[0]), f = Math.max(f, g[g.length - 1])), h = h === y ? +v().startOf("day") : h, f = f === x ? +v().endOf("day") + 1 : f, s.min = Math.min(h, f), s.max = Math.max(h + 1, f), s._horizontal = s.isHorizontal(), s._table = [], s._timestamps = {
|
|
data: g,
|
|
datasets: p,
|
|
labels: m
|
|
}
|
|
},
|
|
buildTicks: function() {
|
|
var t, e, n, i = this,
|
|
a = i.min,
|
|
r = i.max,
|
|
l = i.options,
|
|
s = l.time,
|
|
d = s.displayFormats,
|
|
v = i.getLabelCapacity(a),
|
|
m = s.unit || c(s.minUnit, a, r, v),
|
|
b = h(m),
|
|
x = [],
|
|
y = [];
|
|
switch (l.ticks.source) {
|
|
case "data":
|
|
x = i._timestamps.data;
|
|
break;
|
|
case "labels":
|
|
x = i._timestamps.labels;
|
|
break;
|
|
case "auto":
|
|
default:
|
|
x = f(a, r, m, b, v, l)
|
|
}
|
|
for ("ticks" === l.bounds && x.length && (a = x[0], r = x[x.length - 1]), a = u(s.min, i) || a, r = u(s.max, i) || r, t = 0, e = x.length; t < e; ++t)(n = x[t]) >= a && n <= r && y.push(n);
|
|
return i.min = a, i.max = r, i._unit = m, i._majorUnit = b, i._minorFormat = d[m], i._majorFormat = d[b], i._table = o(i._timestamps.data, a, r, l.distribution), i._offsets = g(i._table, y, a, r, l), p(y, b)
|
|
},
|
|
getLabelForIndex: function(t, e) {
|
|
var n = this,
|
|
i = n.chart.data,
|
|
a = n.options.time,
|
|
o = i.labels && t < i.labels.length ? i.labels[t] : "",
|
|
r = i.datasets[e].data[t];
|
|
return b.isObject(r) && (o = n.getRightValue(r)), a.tooltipFormat && (o = s(o, a).format(a.tooltipFormat)), o
|
|
},
|
|
tickFormatFunction: function(t, e, n) {
|
|
var i = this,
|
|
a = i.options,
|
|
o = t.valueOf(),
|
|
r = i._majorUnit,
|
|
l = i._majorFormat,
|
|
s = t.clone().startOf(i._majorUnit).valueOf(),
|
|
u = a.ticks.major,
|
|
d = u.enabled && r && l && o === s,
|
|
c = t.format(d ? l : i._minorFormat),
|
|
h = d ? u : a.ticks.minor,
|
|
f = b.valueOrDefault(h.callback, h.userCallback);
|
|
return f ? f(c, e, n) : c
|
|
},
|
|
convertTicksToLabels: function(t) {
|
|
var e, n, i = [];
|
|
for (e = 0, n = t.length; e < n; ++e) i.push(this.tickFormatFunction(v(t[e].value), e, t));
|
|
return i
|
|
},
|
|
getPixelForOffset: function(t) {
|
|
var e = this,
|
|
n = e._horizontal ? e.width : e.height,
|
|
i = e._horizontal ? e.left : e.top,
|
|
a = l(e._table, "time", t, "pos");
|
|
return i + n * (e._offsets.left + a) / (e._offsets.left + 1 + e._offsets.right)
|
|
},
|
|
getPixelForValue: function(t, e, n) {
|
|
var i = this,
|
|
a = null;
|
|
if (void 0 !== e && void 0 !== n && (a = i._timestamps.datasets[n][e]), null === a && (a = u(t, i)), null !== a) return i.getPixelForOffset(a)
|
|
},
|
|
getPixelForTick: function(t) {
|
|
var e = this.getTicks();
|
|
return t >= 0 && t < e.length ? this.getPixelForOffset(e[t].value) : null
|
|
},
|
|
getValueForPixel: function(t) {
|
|
var e = this,
|
|
n = e._horizontal ? e.width : e.height,
|
|
i = e._horizontal ? e.left : e.top,
|
|
a = (n ? (t - i) / n : 0) * (e._offsets.left + 1 + e._offsets.left) - e._offsets.right,
|
|
o = l(e._table, "pos", a, "time");
|
|
return v(o)
|
|
},
|
|
getLabelWidth: function(t) {
|
|
var e = this,
|
|
n = e.options.ticks,
|
|
i = e.ctx.measureText(t).width,
|
|
a = b.toRadians(n.maxRotation),
|
|
o = Math.cos(a),
|
|
r = Math.sin(a);
|
|
return i * o + b.valueOrDefault(n.fontSize, m.global.defaultFontSize) * r
|
|
},
|
|
getLabelCapacity: function(t) {
|
|
var e = this;
|
|
e._minorFormat = e.options.time.displayFormats.millisecond;
|
|
var n = e.tickFormatFunction(v(t), 0, []),
|
|
i = e.getLabelWidth(n),
|
|
a = e.isHorizontal() ? e.width : e.height;
|
|
return Math.floor(a / i)
|
|
}
|
|
});
|
|
t.scaleService.registerScaleType("time", n, e)
|
|
}
|
|
}, {
|
|
1: 1,
|
|
25: 25,
|
|
45: 45
|
|
}]
|
|
}, {}, [7])(7)
|
|
});
|