@progress/kendo-ui
Version:
This package is part of the [Kendo UI for jQuery](http://www.telerik.com/kendo-ui) suite.
1,620 lines (1,332 loc) • 432 kB
JavaScript
module.exports =
/******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId])
/******/ return installedModules[moduleId].exports;
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ exports: {},
/******/ id: moduleId,
/******/ loaded: false
/******/ };
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/ // Flag the module as loaded
/******/ module.loaded = true;
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/ // Load entry module and return exports
/******/ return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ({
/***/ 0:
/***/ (function(module, exports, __webpack_require__) {
module.exports = __webpack_require__(861);
/***/ }),
/***/ 3:
/***/ (function(module, exports) {
module.exports = function() { throw new Error("define cannot be used indirect"); };
/***/ }),
/***/ 857:
/***/ (function(module, exports) {
module.exports = require("../../kendo.dataviz.core");
/***/ }),
/***/ 859:
/***/ (function(module, exports) {
module.exports = require("../../kendo.drawing");
/***/ }),
/***/ 861:
/***/ (function(module, exports, __webpack_require__) {
var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/***********************************************************************
* WARNING: this file is auto-generated. If you change it directly,
* your modifications will eventually be lost. The source code is in
* `kendo-charts` repository, you should make your changes there and
* run `src-modules/sync.sh` in this repository.
*/
(function(f, define){
!(__WEBPACK_AMD_DEFINE_ARRAY__ = [
__webpack_require__(862),
__webpack_require__(863),
__webpack_require__(859),
__webpack_require__(857)
], __WEBPACK_AMD_DEFINE_FACTORY__ = (f), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
})(function(){
(function ($) {
window.kendo.dataviz = window.kendo.dataviz || {};
var dataviz = kendo.dataviz;
var Class = dataviz.Class;
var isNumber = dataviz.isNumber;
var datavizConstants = dataviz.constants;
var MAX_VALUE = datavizConstants.MAX_VALUE;
var MIN_VALUE = datavizConstants.MIN_VALUE;
var VALUE = datavizConstants.VALUE;
var CENTER = datavizConstants.CENTER;
var TOP = datavizConstants.TOP;
var BOTTOM = datavizConstants.BOTTOM;
var LEFT = datavizConstants.LEFT;
var WHITE = datavizConstants.WHITE;
var CIRCLE = datavizConstants.CIRCLE;
var X = datavizConstants.X;
var Y = datavizConstants.Y;
var RIGHT = datavizConstants.RIGHT;
var BLACK = datavizConstants.BLACK;
var DATE = datavizConstants.DATE;
var DEFAULT_PRECISION = datavizConstants.DEFAULT_PRECISION;
var ARC = datavizConstants.ARC;
var defined = dataviz.defined;
var getter = dataviz.getter;
var isArray = dataviz.isArray;
var ChartElement = dataviz.ChartElement;
var Point = dataviz.Point;
var Box = dataviz.Box;
var alignPathToPixel = dataviz.alignPathToPixel;
var setDefaultOptions = dataviz.setDefaultOptions;
var inArray = dataviz.inArray;
var isFunction = dataviz.isFunction;
var valueOrDefault = dataviz.valueOrDefault;
var isObject = dataviz.isObject;
var deepExtend = dataviz.deepExtend;
var last = dataviz.last;
var eventElement = dataviz.eventElement;
var getTemplate = dataviz.getTemplate;
var TextBox = dataviz.TextBox;
var ShapeElement = dataviz.ShapeElement;
var getSpacing = dataviz.getSpacing;
var CurveProcessor = dataviz.CurveProcessor;
var append = dataviz.append;
var isString = dataviz.isString;
var parseDate = dataviz.parseDate;
var styleValue = dataviz.styleValue;
var CategoryAxis = dataviz.CategoryAxis;
var BoxElement = dataviz.BoxElement;
var round = dataviz.round;
var limitValue = dataviz.limitValue;
var grep = dataviz.grep;
var elementStyles = dataviz.elementStyles;
var hasClasses = dataviz.hasClasses;
var bindEvents = dataviz.bindEvents;
var services = dataviz.services;
var unbindEvents = dataviz.unbindEvents;
var support = kendo.support;
var drawing = kendo.drawing;
var Path = drawing.Path;
var Animation = drawing.Animation;
var AnimationFactory = drawing.AnimationFactory;
var Group = drawing.Group;
var Color = kendo.Color;
var geometry = kendo.geometry;
var GeometryPoint = geometry.Point;
var transform = geometry.transform;
var ChartAxis = Class.extend({
init: function(axis) {
this._axis = axis;
this.options = axis.options;
},
value: function(point) {
var axis = this._axis;
var value = axis.getCategory ? axis.getCategory(point) : axis.getValue(point);
return value;
},
slot: function(from, to, limit) {
if (limit === void 0) { limit = true; }
return this._axis.slot(from, to, limit);
},
range: function() {
return this._axis.range();
},
valueRange: function() {
return this._axis.valueRange();
}
});
function findAxisByName(name, axes) {
for (var idx = 0; idx < axes.length; idx++) {
if (axes[idx].options.name === name) {
axes[idx].prepareUserOptions();
return new ChartAxis(axes[idx]);
}
}
}
var ChartPane = kendo.Class.extend({
init: function(pane) {
this.visual = pane.visual;
this.chartsVisual = pane.chartContainer.visual;
this._pane = pane;
},
findAxisByName: function(name) {
return findAxisByName(name, this._pane.axes);
}
});
var ChartPlotArea = Class.extend({
init: function(plotArea) {
this._plotArea = plotArea;
this.visual = plotArea.visual;
this.backgroundVisual = plotArea._bgVisual;
}
});
function countNumbers(values) {
var length = values.length;
var count = 0;
for (var i = 0; i < length; i++) {
var num = values[i];
if (isNumber(num)) {
count++;
}
}
return count;
}
var Aggregates = {
min: function(values) {
var length = values.length;
var min = MAX_VALUE;
for (var i = 0; i < length; i++) {
var value = values[i];
if (isNumber(value)) {
min = Math.min(min, value);
}
}
return min === MAX_VALUE ? values[0] : min;
},
max: function(values) {
var length = values.length;
var max = MIN_VALUE;
for (var i = 0; i < length; i++) {
var value = values[i];
if (isNumber(value)) {
max = Math.max(max, value);
}
}
return max === MIN_VALUE ? values[0] : max;
},
sum: function(values) {
var length = values.length;
var sum = 0;
for (var i = 0; i < length; i++) {
var value = values[i];
if (isNumber(value)) {
sum += value;
}
}
return sum;
},
sumOrNull: function(values) {
var result = null;
if (countNumbers(values)) {
result = Aggregates.sum(values);
}
return result;
},
count: function(values) {
var length = values.length;
var count = 0;
for (var i = 0; i < length; i++) {
var value = values[i];
if (value !== null && defined(value)) {
count++;
}
}
return count;
},
avg: function(values) {
var count = countNumbers(values);
var result = values[0];
if (count > 0) {
result = Aggregates.sum(values) / count;
}
return result;
},
first: function(values) {
var length = values.length;
for (var i = 0; i < length; i++) {
var value = values[i];
if (value !== null && defined(value)) {
return value;
}
}
return values[0];
}
};
function getField(field, row) {
if (row === null) {
return row;
}
var get = getter(field, true);
return get(row);
}
var SeriesBinder = Class.extend({
init: function() {
this._valueFields = {};
this._otherFields = {};
this._nullValue = {};
this._undefinedValue = {};
},
register: function(seriesTypes, valueFields, otherFields) {
var this$1 = this;
if (valueFields === void 0) { valueFields = [ VALUE ]; }
if (otherFields === void 0) { otherFields = {}; }
for (var i = 0; i < seriesTypes.length; i++) {
var type = seriesTypes[i];
this$1._valueFields[type] = valueFields;
this$1._otherFields[type] = otherFields;
this$1._nullValue[type] = this$1._makeValue(valueFields, null);
this$1._undefinedValue[type] = this$1._makeValue(valueFields, undefined);
}
},
canonicalFields: function(series) {
return this.valueFields(series).concat(this.otherFields(series));
},
valueFields: function(series) {
return this._valueFields[series.type] || [ VALUE ];
},
otherFields: function(series) {
return this._otherFields[series.type] || [ VALUE ];
},
bindPoint: function(series, pointIx, item) {
var data = series.data;
var pointData = defined(item) ? item : data[pointIx];
var result = { valueFields: { value: pointData } };
var valueFields = this.valueFields(series);
var otherFields = this._otherFields[series.type];
var fields, value;
if (pointData === null) {
value = this._nullValue[series.type];
} else if (!defined(pointData)) {
value = this._undefinedValue[series.type];
} else if (Array.isArray(pointData)) {
var fieldData = pointData.slice(valueFields.length);
value = this._bindFromArray(pointData, valueFields);
fields = this._bindFromArray(fieldData, otherFields);
} else if (typeof pointData === "object") {
var srcValueFields = this.sourceFields(series, valueFields);
var srcPointFields = this.sourceFields(series, otherFields);
value = this._bindFromObject(pointData, valueFields, srcValueFields);
fields = this._bindFromObject(pointData, otherFields, srcPointFields);
}
if (defined(value)) {
if (valueFields.length === 1) {
result.valueFields.value = value[valueFields[0]];
} else {
result.valueFields = value;
}
}
result.fields = fields || {};
return result;
},
_makeValue: function(fields, initialValue) {
var value = {};
var length = fields.length;
for (var i = 0; i < length; i++) {
var fieldName = fields[i];
value[fieldName] = initialValue;
}
return value;
},
_bindFromArray: function(array, fields) {
var value = {};
if (fields) {
var length = Math.min(fields.length, array.length);
for (var i = 0; i < length; i++) {
value[fields[i]] = array[i];
}
}
return value;
},
_bindFromObject: function(object, fields, srcFields) {
if (srcFields === void 0) { srcFields = fields; }
var value = {};
if (fields) {
var length = fields.length;
for (var i = 0; i < length; i++) {
var fieldName = fields[i];
var srcFieldName = srcFields[i];
if (srcFieldName !== null) {
value[fieldName] = getField(srcFieldName, object);
}
}
}
return value;
},
sourceFields: function(series, canonicalFields) {
var sourceFields = [];
if (canonicalFields) {
var length = canonicalFields.length;
for (var i = 0; i < length; i++) {
var fieldName = canonicalFields[i];
var sourceFieldName = fieldName === VALUE ? "field" : fieldName + "Field";
sourceFields.push(series[sourceFieldName] !== null ? (series[sourceFieldName] || fieldName) : null);
}
}
return sourceFields;
}
});
SeriesBinder.current = new SeriesBinder();
var STD_ERR = "stderr";
var STD_DEV = "stddev";
var percentRegex = /percent(?:\w*)\((\d+)\)/;
var standardDeviationRegex = new RegExp("^" + STD_DEV + "(?:\\((\\d+(?:\\.\\d+)?)\\))?$");
var ErrorRangeCalculator = Class.extend({
init: function(errorValue, series, field) {
this.initGlobalRanges(errorValue, series, field);
},
initGlobalRanges: function(errorValue, series, field) {
var data = series.data;
var deviationMatch = standardDeviationRegex.exec(errorValue);
if (deviationMatch) {
this.valueGetter = this.createValueGetter(series, field);
var average = this.getAverage(data);
var deviation = this.getStandardDeviation(data, average, false);
var multiple = deviationMatch[1] ? parseFloat(deviationMatch[1]) : 1;
var errorRange = { low: average.value - deviation * multiple, high: average.value + deviation * multiple };
this.globalRange = function() {
return errorRange;
};
} else if (errorValue.indexOf && errorValue.indexOf(STD_ERR) >= 0) {
this.valueGetter = this.createValueGetter(series, field);
var standardError = this.getStandardError(data, this.getAverage(data));
this.globalRange = function(value) {
return { low: value - standardError, high: value + standardError };
};
}
},
createValueGetter: function(series, field) {
var data = series.data;
var binder = SeriesBinder.current;
var valueFields = binder.valueFields(series);
var item = defined(data[0]) ? data[0] : {};
var valueGetter;
if (isArray(item)) {
var index = field ? valueFields.indexOf(field) : 0;
valueGetter = getter("[" + index + "]");
} else if (isNumber(item)) {
valueGetter = getter();
} else if (typeof item === datavizConstants.OBJECT) {
var srcValueFields = binder.sourceFields(series, valueFields);
valueGetter = getter(srcValueFields[valueFields.indexOf(field)]);
}
return valueGetter;
},
getErrorRange: function(pointValue, errorValue) {
var low, high, value;
if (!defined(errorValue)) {
return null;
}
if (this.globalRange) {
return this.globalRange(pointValue);
}
if (isArray(errorValue)) {
low = pointValue - errorValue[0];
high = pointValue + errorValue[1];
} else if (isNumber(value = parseFloat(errorValue))) {
low = pointValue - value;
high = pointValue + value;
} else if ((value = percentRegex.exec(errorValue))) {
var percentValue = pointValue * (parseFloat(value[1]) / 100);
low = pointValue - Math.abs(percentValue);
high = pointValue + Math.abs(percentValue);
} else {
throw new Error("Invalid ErrorBar value: " + errorValue);
}
return { low: low, high: high };
},
getStandardError: function(data, average) {
return this.getStandardDeviation(data, average, true) / Math.sqrt(average.count);
},
getStandardDeviation: function(data, average, isSample) {
var this$1 = this;
var length = data.length;
var total = isSample ? average.count - 1 : average.count;
var squareDifferenceSum = 0;
for (var idx = 0; idx < length; idx++) {
var value = this$1.valueGetter(data[idx]);
if (isNumber(value)) {
squareDifferenceSum += Math.pow(value - average.value, 2);
}
}
return Math.sqrt(squareDifferenceSum / total);
},
getAverage: function(data) {
var this$1 = this;
var length = data.length;
var sum = 0;
var count = 0;
for (var idx = 0; idx < length; idx++) {
var value = this$1.valueGetter(data[idx]);
if (isNumber(value)) {
sum += value;
count++;
}
}
return {
value: sum / count,
count: count
};
}
});
var browser = support.browser || {};
var INITIAL_ANIMATION_DURATION = 600;
var FADEIN = "fadeIn";
var GLASS = "glass";
var BORDER_BRIGHTNESS = 0.8;
var TOOLTIP_OFFSET = 5;
var START_SCALE = browser.msie ? 0.001 : 0;
var ERROR_LOW_FIELD = "errorLow";
var ERROR_HIGH_FIELD = "errorHigh";
var X_ERROR_LOW_FIELD = "xErrorLow";
var X_ERROR_HIGH_FIELD = "xErrorHigh";
var Y_ERROR_LOW_FIELD = "yErrorLow";
var Y_ERROR_HIGH_FIELD = "yErrorHigh";
var LINE_MARKER_SIZE = 8;
var ZERO = "zero";
var INTERPOLATE = "interpolate";
var GAP = "gap";
var ABOVE = "above";
var BELOW = "below";
var SMOOTH = "smooth";
var STEP = "step";
var AREA = "area";
var BAR = "bar";
var BOX_PLOT = "boxPlot";
var BUBBLE = "bubble";
var BULLET = "bullet";
var CANDLESTICK = "candlestick";
var COLUMN = "column";
var DONUT = "donut";
var FUNNEL = "funnel";
var HORIZONTAL_WATERFALL = "horizontalWaterfall";
var LINE = "line";
var OHLC = "ohlc";
var PIE = "pie";
var POLAR_AREA = "polarArea";
var POLAR_LINE = "polarLine";
var POLAR_SCATTER = "polarScatter";
var RADAR_AREA = "radarArea";
var RADAR_COLUMN = "radarColumn";
var RADAR_LINE = "radarLine";
var RANGE_AREA = "rangeArea";
var RANGE_BAR = "rangeBar";
var RANGE_COLUMN = "rangeColumn";
var SCATTER = "scatter";
var SCATTER_LINE = "scatterLine";
var VERTICAL_AREA = "verticalArea";
var VERTICAL_BOX_PLOT = "verticalBoxPlot";
var VERTICAL_BULLET = "verticalBullet";
var VERTICAL_LINE = "verticalLine";
var VERTICAL_RANGE_AREA = "verticalRangeArea";
var WATERFALL = "waterfall";
var EQUALLY_SPACED_SERIES = [
BAR, COLUMN, OHLC, CANDLESTICK, BOX_PLOT, VERTICAL_BOX_PLOT,
BULLET, RANGE_COLUMN, RANGE_BAR, WATERFALL, HORIZONTAL_WATERFALL
];
var LEGEND_ITEM_CLICK = "legendItemClick";
var LEGEND_ITEM_HOVER = "legendItemHover";
var LEGEND_ITEM_LEAVE = "legendItemLeave";
var SERIES_CLICK = "seriesClick";
var SERIES_HOVER = "seriesHover";
var SERIES_OVER = "seriesOver";
var SERIES_LEAVE = "seriesLeave";
var PLOT_AREA_CLICK = "plotAreaClick";
var PLOT_AREA_HOVER = "plotAreaHover";
var PLOT_AREA_LEAVE = "plotAreaLeave";
var DRAG = "drag";
var DRAG_END = "dragEnd";
var DRAG_START = "dragStart";
var ZOOM_START = "zoomStart";
var ZOOM = "zoom";
var ZOOM_END = "zoomEnd";
var SELECT_START = "selectStart";
var SELECT = "select";
var SELECT_END = "selectEnd";
var RENDER = "render";
var SHOW_TOOLTIP = "showTooltip";
var HIDE_TOOLTIP = "hideTooltip";
var PANE_RENDER = "paneRender";
var LOGARITHMIC = "log";
var CATEGORY = "category";
var INSIDE_END = "insideEnd";
var INSIDE_BASE = "insideBase";
var OUTSIDE_END = "outsideEnd";
var MOUSEWHEEL = "DOMMouseScroll mousewheel";
var MOUSEWHEEL_DELAY = 150;
var constants = {
INITIAL_ANIMATION_DURATION: INITIAL_ANIMATION_DURATION,
FADEIN: FADEIN,
LEGEND_ITEM_CLICK: LEGEND_ITEM_CLICK,
LEGEND_ITEM_HOVER: LEGEND_ITEM_HOVER,
LEGEND_ITEM_LEAVE: LEGEND_ITEM_LEAVE,
SERIES_CLICK: SERIES_CLICK,
SERIES_HOVER: SERIES_HOVER,
SERIES_OVER: SERIES_OVER,
SERIES_LEAVE: SERIES_LEAVE,
GLASS: GLASS,
BORDER_BRIGHTNESS: BORDER_BRIGHTNESS,
TOOLTIP_OFFSET: TOOLTIP_OFFSET,
START_SCALE: START_SCALE,
ERROR_LOW_FIELD: ERROR_LOW_FIELD,
ERROR_HIGH_FIELD: ERROR_HIGH_FIELD,
X_ERROR_LOW_FIELD: X_ERROR_LOW_FIELD,
X_ERROR_HIGH_FIELD: X_ERROR_HIGH_FIELD,
Y_ERROR_LOW_FIELD: Y_ERROR_LOW_FIELD,
Y_ERROR_HIGH_FIELD: Y_ERROR_HIGH_FIELD,
LINE_MARKER_SIZE: LINE_MARKER_SIZE,
INTERPOLATE: INTERPOLATE,
ZERO: ZERO,
SMOOTH: SMOOTH,
STEP: STEP,
CATEGORY: CATEGORY,
FUNNEL: FUNNEL,
BAR: BAR,
CANDLESTICK: CANDLESTICK,
PIE: PIE,
COLUMN: COLUMN,
AREA: AREA,
VERTICAL_BULLET: VERTICAL_BULLET,
BOX_PLOT: BOX_PLOT,
OHLC: OHLC,
WATERFALL: WATERFALL,
LINE: LINE,
BULLET: BULLET,
VERTICAL_LINE: VERTICAL_LINE,
VERTICAL_AREA: VERTICAL_AREA,
RANGE_AREA: RANGE_AREA,
VERTICAL_RANGE_AREA: VERTICAL_RANGE_AREA,
RANGE_COLUMN: RANGE_COLUMN,
VERTICAL_BOX_PLOT: VERTICAL_BOX_PLOT,
RANGE_BAR: RANGE_BAR,
HORIZONTAL_WATERFALL: HORIZONTAL_WATERFALL,
SCATTER: SCATTER,
SCATTER_LINE: SCATTER_LINE,
BUBBLE: BUBBLE,
RADAR_AREA: RADAR_AREA,
RADAR_LINE: RADAR_LINE,
RADAR_COLUMN: RADAR_COLUMN,
POLAR_LINE: POLAR_LINE,
POLAR_AREA: POLAR_AREA,
POLAR_SCATTER: POLAR_SCATTER,
RENDER: RENDER,
PLOT_AREA_CLICK: PLOT_AREA_CLICK,
PLOT_AREA_HOVER: PLOT_AREA_HOVER,
PLOT_AREA_LEAVE: PLOT_AREA_LEAVE,
LOGARITHMIC: LOGARITHMIC,
DRAG: DRAG,
DRAG_START: DRAG_START,
DRAG_END: DRAG_END,
ZOOM_START: ZOOM_START,
ZOOM: ZOOM,
ZOOM_END: ZOOM_END,
SELECT_START: SELECT_START,
SELECT: SELECT,
SELECT_END: SELECT_END,
PANE_RENDER: PANE_RENDER,
GAP: GAP,
DONUT: DONUT,
INSIDE_END: INSIDE_END,
INSIDE_BASE: INSIDE_BASE,
OUTSIDE_END: OUTSIDE_END,
MOUSEWHEEL: MOUSEWHEEL,
MOUSEWHEEL_DELAY: MOUSEWHEEL_DELAY,
SHOW_TOOLTIP: SHOW_TOOLTIP,
HIDE_TOOLTIP: HIDE_TOOLTIP,
EQUALLY_SPACED_SERIES: EQUALLY_SPACED_SERIES,
ABOVE: ABOVE,
BELOW: BELOW
};
var DEFAULT_ERROR_BAR_WIDTH = 4;
var ErrorBarBase = ChartElement.extend({
init: function(low, high, isVertical, chart, series, options) {
ChartElement.fn.init.call(this, options);
this.low = low;
this.high = high;
this.isVertical = isVertical;
this.chart = chart;
this.series = series;
},
reflow: function(targetBox) {
var endCaps = this.options.endCaps;
var isVertical = this.isVertical;
var axis = this.getAxis();
var valueBox = axis.getSlot(this.low, this.high);
var centerBox = targetBox.center();
var capsWidth = this.getCapsWidth(targetBox, isVertical);
var capValue = isVertical ? centerBox.x : centerBox.y;
var capStart = capValue - capsWidth;
var capEnd = capValue + capsWidth;
var linePoints;
if (isVertical) {
linePoints = [
new Point(centerBox.x, valueBox.y1),
new Point(centerBox.x, valueBox.y2)
];
if (endCaps) {
linePoints.push(new Point(capStart, valueBox.y1),
new Point(capEnd, valueBox.y1),
new Point(capStart, valueBox.y2),
new Point(capEnd, valueBox.y2));
}
this.box = new Box(capStart, valueBox.y1, capEnd, valueBox.y2);
} else {
linePoints = [
new Point(valueBox.x1, centerBox.y),
new Point(valueBox.x2, centerBox.y)
];
if (endCaps) {
linePoints.push(new Point(valueBox.x1, capStart),
new Point(valueBox.x1, capEnd),
new Point(valueBox.x2, capStart),
new Point(valueBox.x2, capEnd));
}
this.box = new Box(valueBox.x1, capStart, valueBox.x2, capEnd);
}
this.linePoints = linePoints;
},
getCapsWidth: function(box, isVertical) {
var boxSize = isVertical ? box.width() : box.height();
var capsWidth = Math.min(Math.floor(boxSize / 2), DEFAULT_ERROR_BAR_WIDTH) || DEFAULT_ERROR_BAR_WIDTH;
return capsWidth;
},
createVisual: function() {
var this$1 = this;
var options = this.options;
var visual = options.visual;
if (visual) {
this.visual = visual({
low: this.low,
high: this.high,
rect: this.box.toRect(),
sender: this.getSender(),
options: {
endCaps: options.endCaps,
color: options.color,
line: options.line
},
createVisual: function () {
this$1.createDefaultVisual();
var defaultVisual = this$1.visual;
delete this$1.visual;
return defaultVisual;
}
});
} else {
this.createDefaultVisual();
}
},
createDefaultVisual: function() {
var this$1 = this;
var ref = this;
var options = ref.options;
var linePoints = ref.linePoints;
var lineOptions = {
stroke: {
color: options.color,
width: options.line.width,
dashType: options.line.dashType
}
};
ChartElement.fn.createVisual.call(this);
for (var idx = 0; idx < linePoints.length; idx += 2) {
var line = new Path(lineOptions)
.moveTo(linePoints[idx].x, linePoints[idx].y)
.lineTo(linePoints[idx + 1].x, linePoints[idx + 1].y);
alignPathToPixel(line);
this$1.visual.append(line);
}
}
});
setDefaultOptions(ErrorBarBase, {
animation: {
type: FADEIN,
delay: INITIAL_ANIMATION_DURATION
},
endCaps: true,
line: {
width: 2
},
zIndex: 1
});
var CategoricalErrorBar = ErrorBarBase.extend({
getAxis: function() {
var axis = this.chart.seriesValueAxis(this.series);
return axis;
}
});
var MAX_EXPAND_DEPTH = 5;
function evalOptions(options, context, state, dryRun) {
if (state === void 0) { state = {}; }
if (dryRun === void 0) { dryRun = false; }
var defaults = state.defaults = state.defaults || {};
var depth = state.depth = state.depth || 0;
var needsEval = false;
state.excluded = state.excluded || [];
if (depth > MAX_EXPAND_DEPTH) {
return null;
}
for (var property in options) {
if (!inArray(property, state.excluded) && options.hasOwnProperty(property)) {
var propValue = options[property];
if (isFunction(propValue)) {
needsEval = true;
if (!dryRun) {
options[property] = valueOrDefault(propValue(context), defaults[property]);
}
} else if (isObject(propValue)) {
if (!dryRun) {
state.defaults = defaults[property];
}
state.depth++;
needsEval = evalOptions(propValue, context, state, dryRun) || needsEval;
state.depth--;
}
}
}
return needsEval;
}
function categoriesCount(series) {
var seriesCount = series.length;
var categories = 0;
for (var i = 0; i < seriesCount; i++) {
categories = Math.max(categories, series[i].data.length);
}
return categories;
}
var CategoricalChart = ChartElement.extend({
init: function(plotArea, options) {
ChartElement.fn.init.call(this, options);
this.plotArea = plotArea;
this.chartService = plotArea.chartService;
this.categoryAxis = plotArea.seriesCategoryAxis(options.series[0]);
// Value axis ranges grouped by axis name, e.g.:
// primary: { min: 0, max: 1 }
this.valueAxisRanges = {};
this.points = [];
this.categoryPoints = [];
this.seriesPoints = [];
this.seriesOptions = [];
this._evalSeries = [];
this.render();
},
render: function() {
this.traverseDataPoints(this.addValue.bind(this));
},
pointOptions: function(series, seriesIx) {
var options = this.seriesOptions[seriesIx];
if (!options) {
var defaults = this.pointType().prototype.defaults;
this.seriesOptions[seriesIx] = options = deepExtend({ }, defaults, {
vertical: !this.options.invertAxes
}, series);
}
return options;
},
plotValue: function(point) {
if (!point) {
return 0;
}
if (this.options.isStacked100 && isNumber(point.value)) {
var categoryIx = point.categoryIx;
var categoryPoints = this.categoryPoints[categoryIx];
var otherValues = [];
var categorySum = 0;
for (var i = 0; i < categoryPoints.length; i++) {
var other = categoryPoints[i];
if (other) {
var stack = point.series.stack;
var otherStack = other.series.stack;
if ((stack && otherStack) && stack.group !== otherStack.group) {
continue;
}
if (isNumber(other.value)) {
categorySum += Math.abs(other.value);
otherValues.push(Math.abs(other.value));
}
}
}
if (categorySum > 0) {
return point.value / categorySum;
}
}
return point.value;
},
plotRange: function(point, startValue) {
var this$1 = this;
if (startValue === void 0) { startValue = 0; }
var categoryPoints = this.categoryPoints[point.categoryIx];
if (this.options.isStacked) {
var plotValue = this.plotValue(point);
var positive = plotValue >= 0;
var prevValue = startValue;
var isStackedBar = false;
for (var i = 0; i < categoryPoints.length; i++) {
var other = categoryPoints[i];
if (point === other) {
break;
}
var stack = point.series.stack;
var otherStack = other.series.stack;
if (stack && otherStack) {
if (typeof stack === datavizConstants.STRING && stack !== otherStack) {
continue;
}
if (stack.group && stack.group !== otherStack.group) {
continue;
}
}
var otherValue = this$1.plotValue(other);
if ((otherValue >= 0 && positive) ||
(otherValue < 0 && !positive)) {
prevValue += otherValue;
plotValue += otherValue;
isStackedBar = true;
if (this$1.options.isStacked100) {
plotValue = Math.min(plotValue, 1);
}
}
}
if (isStackedBar) {
prevValue -= startValue;
}
return [ prevValue, plotValue ];
}
var series = point.series;
var valueAxis = this.seriesValueAxis(series);
var axisCrossingValue = this.categoryAxisCrossingValue(valueAxis);
return [ axisCrossingValue, dataviz.convertableToNumber(point.value) ? point.value : axisCrossingValue ];
},
stackLimits: function(axisName, stackName) {
var this$1 = this;
var min = MAX_VALUE;
var max = MIN_VALUE;
for (var i = 0; i < this.categoryPoints.length; i++) {
var categoryPoints = this$1.categoryPoints[i];
if (!categoryPoints) {
continue;
}
for (var pIx = 0; pIx < categoryPoints.length; pIx++) {
var point = categoryPoints[pIx];
if (point) {
if (point.series.stack === stackName || point.series.axis === axisName) {
var to = this$1.plotRange(point, 0)[1];
if (defined(to) && isFinite(to)) {
max = Math.max(max, to);
min = Math.min(min, to);
}
}
}
}
}
return { min: min, max: max };
},
updateStackRange: function() {
var this$1 = this;
var ref = this.options;
var isStacked = ref.isStacked;
var chartSeries = ref.series;
var limitsCache = {};
if (isStacked) {
for (var i = 0; i < chartSeries.length; i++) {
var series = chartSeries[i];
var axisName = series.axis;
var key = axisName + series.stack;
var limits = limitsCache[key];
if (!limits) {
limits = this$1.stackLimits(axisName, series.stack);
var errorTotals = this$1.errorTotals;
if (errorTotals) {
if (errorTotals.negative.length) {
limits.min = Math.min(limits.min, dataviz.sparseArrayLimits(errorTotals.negative).min);
}
if (errorTotals.positive.length) {
limits.max = Math.max(limits.max, dataviz.sparseArrayLimits(errorTotals.positive).max);
}
}
if (limits.min !== MAX_VALUE || limits.max !== MIN_VALUE) {
limitsCache[key] = limits;
} else {
limits = null;
}
}
if (limits) {
this$1.valueAxisRanges[axisName] = limits;
}
}
}
},
addErrorBar: function(point, data, categoryIx) {
var value = point.value;
var series = point.series;
var seriesIx = point.seriesIx;
var errorBars = point.options.errorBars;
var lowValue = data.fields[ERROR_LOW_FIELD];
var highValue = data.fields[ERROR_HIGH_FIELD];
var errorRange;
if (isNumber(lowValue) && isNumber(highValue)) {
errorRange = { low: lowValue, high: highValue };
} else if (errorBars && defined(errorBars.value)) {
this.seriesErrorRanges = this.seriesErrorRanges || [];
this.seriesErrorRanges[seriesIx] = this.seriesErrorRanges[seriesIx] ||
new ErrorRangeCalculator(errorBars.value, series, VALUE);
errorRange = this.seriesErrorRanges[seriesIx].getErrorRange(value, errorBars.value);
}
if (errorRange) {
point.low = errorRange.low;
point.high = errorRange.high;
this.addPointErrorBar(point, categoryIx);
}
},
addPointErrorBar: function(point, categoryIx) {
var isVertical = !this.options.invertAxes;
var options = point.options.errorBars;
var series = point.series;
var low = point.low;
var high = point.high;
if (this.options.isStacked) {
var stackedErrorRange = this.stackedErrorRange(point, categoryIx);
low = stackedErrorRange.low;
high = stackedErrorRange.high;
} else {
var fields = { categoryIx: categoryIx, series: series };
this.updateRange({ value: low }, fields);
this.updateRange({ value: high }, fields);
}
var errorBar = new CategoricalErrorBar(low, high, isVertical, this, series, options);
point.errorBars = [ errorBar ];
point.append(errorBar);
},
stackedErrorRange: function(point, categoryIx) {
var plotValue = this.plotRange(point, 0)[1] - point.value;
var low = point.low + plotValue;
var high = point.high + plotValue;
this.errorTotals = this.errorTotals || { positive: [], negative: [] };
if (low < 0) {
this.errorTotals.negative[categoryIx] = Math.min(this.errorTotals.negative[categoryIx] || 0, low);
}
if (high > 0) {
this.errorTotals.positive[categoryIx] = Math.max(this.errorTotals.positive[categoryIx] || 0, high);
}
return { low: low, high: high };
},
addValue: function(data, fields) {
var categoryIx = fields.categoryIx;
var series = fields.series;
var seriesIx = fields.seriesIx;
var categoryPoints = this.categoryPoints[categoryIx];
if (!categoryPoints) {
this.categoryPoints[categoryIx] = categoryPoints = [];
}
var seriesPoints = this.seriesPoints[seriesIx];
if (!seriesPoints) {
this.seriesPoints[seriesIx] = seriesPoints = [];
}
var point = this.createPoint(data, fields);
if (point) {
$.extend(point, fields);
point.owner = this;
point.noteText = data.fields.noteText;
if (!defined(point.dataItem)) {
point.dataItem = series.data[categoryIx];
}
this.addErrorBar(point, data, categoryIx);
}
this.points.push(point);
seriesPoints.push(point);
categoryPoints.push(point);
this.updateRange(data.valueFields, fields);
},
evalPointOptions: function(options, value, category, categoryIx, series, seriesIx) {
var state = { defaults: series._defaults, excluded: [ "data", "aggregate", "_events", "tooltip", "content", "template", "visual", "toggle", "_outOfRangeMinPoint", "_outOfRangeMaxPoint" ] };
var doEval = this._evalSeries[seriesIx];
if (!defined(doEval)) {
this._evalSeries[seriesIx] = doEval = evalOptions(options, {}, state, true);
}
var pointOptions = options;
if (doEval) {
pointOptions = deepExtend({}, pointOptions);
evalOptions(pointOptions, {
value: value,
category: category,
index: categoryIx,
series: series,
dataItem: series.data[categoryIx]
}, state);
}
return pointOptions;
},
updateRange: function(data, fields) {
var axisName = fields.series.axis;
var value = data.value;
var axisRange = this.valueAxisRanges[axisName];
if (isFinite(value) && value !== null) {
axisRange = this.valueAxisRanges[axisName] =
axisRange || { min: MAX_VALUE, max: MIN_VALUE };
axisRange.min = Math.min(axisRange.min, value);
axisRange.max = Math.max(axisRange.max, value);
}
},
seriesValueAxis: function(series) {
var plotArea = this.plotArea;
var axisName = series.axis;
var axis = axisName ? plotArea.namedValueAxes[axisName] : plotArea.valueAxis;
if (!axis) {
throw new Error("Unable to locate value axis with name " + axisName);
}
return axis;
},
reflow: function(targetBox) {
var this$1 = this;
var categorySlots = this.categorySlots = [];
var chartPoints = this.points;
var categoryAxis = this.categoryAxis;
var pointIx = 0;
this.traverseDataPoints(function (data, fields) {
var categoryIx = fields.categoryIx;
var currentSeries = fields.series;
var valueAxis = this$1.seriesValueAxis(currentSeries);
var point = chartPoints[pointIx++];
var categorySlot = categorySlots[categoryIx];
if (!categorySlot) {
categorySlots[categoryIx] = categorySlot =
this$1.categorySlot(categoryAxis, categoryIx, valueAxis);
}
if (point) {
var plotRange = this$1.plotRange(point, valueAxis.startValue());
var valueSlot = this$1.valueSlot(valueAxis, plotRange);
if (valueSlot) {
var pointSlot = this$1.pointSlot(categorySlot, valueSlot);
point.aboveAxis = this$1.aboveAxis(point, valueAxis);
point.stackValue = plotRange[1];
if (this$1.options.isStacked100) {
point.percentage = this$1.plotValue(point);
}
this$1.reflowPoint(point, pointSlot);
} else {
point.visible = false;
}
}
});
this.reflowCategories(categorySlots);
if (!this.options.clip && this.options.limitPoints && this.points.length) {
this.limitPoints();
}
this.box = targetBox;
},
valueSlot: function(valueAxis, plotRange) {
return valueAxis.getSlot(plotRange[0], plotRange[1], !this.options.clip);
},
limitPoints: function() {
var this$1 = this;
var categoryPoints = this.categoryPoints;
var points = categoryPoints[0].concat(last(categoryPoints));
for (var idx = 0; idx < points.length; idx++) {
if (points[idx]) {
this$1.limitPoint(points[idx]);
}
}
},
limitPoint: function(point) {
var limittedSlot = this.categoryAxis.limitSlot(point.box);
if (!limittedSlot.equals(point.box)) {
point.reflow(limittedSlot);
}
},
aboveAxis: function(point, valueAxis) {
var axisCrossingValue = this.categoryAxisCrossingValue(valueAxis);
var value = point.value;
return valueAxis.options.reverse ?
value < axisCrossingValue : value >= axisCrossingValue;
},
categoryAxisCrossingValue: function(valueAxis) {
var categoryAxis = this.categoryAxis;
var options = valueAxis.options;
var crossingValues = [].concat(
options.axisCrossingValues || options.axisCrossingValue
);
return crossingValues[categoryAxis.axisIndex || 0] || 0;
},
reflowPoint: function(point, pointSlot) {
point.reflow(pointSlot);
},
reflowCategories: function() { },
pointSlot: function(categorySlot, valueSlot) {
var options = this.options;
var invertAxes = options.invertAxes;
var slotX = invertAxes ? valueSlot : categorySlot;
var slotY = invertAxes ? categorySlot : valueSlot;
return new Box(slotX.x1, slotY.y1, slotX.x2, slotY.y2);
},
categorySlot: function(categoryAxis, categoryIx) {
return categoryAxis.getSlot(categoryIx);
},
traverseDataPoints: function(callback) {
var this$1 = this;
var series = this.options.series;
var count = categoriesCount(series);
var seriesCount = series.length;
for (var seriesIx = 0; seriesIx < seriesCount; seriesIx++) {
this$1._outOfRangeCallback(series[seriesIx], "_outOfRangeMinPoint", seriesIx, callback);
}
for (var categoryIx = 0; categoryIx < count; categoryIx++) {
for (var seriesIx$1 = 0; seriesIx$1 < seriesCount; seriesIx$1++) {
var currentSeries = series[seriesIx$1];
var currentCategory = this$1.categoryAxis.categoryAt(categoryIx);
var pointData = this$1._bindPoint(currentSeries, seriesIx$1, categoryIx);
callback(pointData, {
category: currentCategory,
categoryIx: categoryIx,
series: currentSeries,
seriesIx: seriesIx$1
});
}
}
for (var seriesIx$2 = 0; seriesIx$2 < seriesCount; seriesIx$2++) {
this$1._outOfRangeCallback(series[seriesIx$2], "_outOfRangeMaxPoint", seriesIx$2, callback);
}
},
_outOfRangeCallback: function(series, field, seriesIx, callback) {
var outOfRangePoint = series[field];
if (outOfRangePoint) {
var categoryIx = outOfRangePoint.categoryIx;
var pointData = this._bindPoint(series, seriesIx, categoryIx, outOfRangePoint.item);
callback(pointData, {
category: outOfRangePoint.category,
categoryIx: categoryIx,
series: series,
seriesIx: seriesIx,
dataItem: outOfRangePoint.item
});
}
},
_bindPoint: function(series, seriesIx, categoryIx, item) {
if (!this._bindCache) {
this._bindCache = [];
}
var bindCache = this._bindCache[seriesIx];
if (!bindCache) {
bindCache = this._bindCache[seriesIx] = [];
}
var data = bindCache[categoryIx];
if (!data) {
data = bindCache[categoryIx] = SeriesBinder.current.bindPoint(series, categoryIx, item);
}
return data;
},
formatPointValue: function(point, format) {
if (point.value === null) {
return "";
}
return this.chartService.format.auto(format, point.value);
},
pointValue: function(data) {
return data.valueFields.value;
}
});
setDefaultOptions(CategoricalChart, {
series: [],
invertAxes: false,
isStacked: false,
clip: true,
limitPoints: true
});
var PointEventsMixin = {
click: function(chart, e) {
return chart.trigger(
SERIES_CLICK,
this.eventArgs(e)
);
},
hover: function(chart, e) {
return chart.trigger(
SERIES_HOVER,
this.eventArgs(e)
);
},
over: function(chart, e) {
return chart.trigger(
SERIES_OVER,
this.eventArgs(e)
);
},
out: function(chart, e) {
return chart.trigger(
SERIES_LEAVE,
this.eventArgs(e)
);
},
eventArgs: function(e) {
return {
value: this.value,
percentage: this.percentage,
stackValue: this.stackValue,
category: this.category,
series: this.series,
dataItem: this.dataItem,
runningTotal: this.runningTotal,
total: this.total,
element: eventElement(e),
originalEvent: e,
point: this
};
}
};
var NoteMixin = {
createNote: function() {
var options = this.options.notes;
var text = this.noteText || options.label.text;
if (options.visible !== false && defined(text) && text !== null) {
this.note = new dataviz.Note({
value: this.value,
text: text,
dataItem: this.dataItem,
category: this.category,
series: this.series
}, this.options.notes, this.owner.chartService);
this.append(this.note);
}
}
};
var LinePoint = ChartElement.extend({
init: function(value, options) {
ChartElement.fn.init.call(this);
this.value = value;
this.options = options;
this.aboveAxis = valueOrDefault(this.options.aboveAxis, true);
this.tooltipTracking = true;
},
render: function() {
var ref = this.options;
var markers = ref.markers;
var labels = ref.labels;
if (this._rendered) {
return;
}
this._rendered = true;
if (markers.visible && markers.size) {
this.marker = this.createMarker();
this.append(this.marker);
}
if (labels.visible) {
var labelTemplate = getTemplate(labels);
var pointData = this.pointData();
var labelText = this.value;
if (labelTemplate) {
labelText = labelTemplate(pointData);
} else if (labels.format) {
labelText = this.formatValue(labels.format);
}
this.label = new TextBox(labelText,
deepExtend({
align: CENTER,
vAlign: CENTER,
margin: {
left: 5,
right: 5
},
zIndex: valueOrDefault(labels.zIndex, this.ser