@progress/kendo-charts 1.31.0 → 1.32.0

package/dist/es/chart/base-theme.js

@@ -1,3 +1,6 @@
+import { TRENDLINE_SERIES } from './constants';
+import { INHERIT } from '../common/constants';
+
 var BAR_GAP = 1.5;
 var BAR_SPACING = 0.4;
 var BLACK = '#000';
@@ -262,7 +265,22 @@ var heatmapSeries = function () { return ({
     }
 }); };
 
-var seriesDefaults = function (options) { return ({
+var trendlineSeriesDefaults = function () { return TRENDLINE_SERIES.reduce(
+    function (options, type) {
+        options[type] = {
+            color: INHERIT,
+            trendline: {},
+            markers: {
+                visible: false
+            },
+            width: 1,
+            dashType: 'longDash'
+        };
+
+        return options;
+    }, {}); };
+
+var seriesDefaults = function (options) { return (Object.assign({
     visible: true,
     labels: {
         font: SANS11
@@ -300,7 +318,9 @@ var seriesDefaults = function (options) { return ({
     verticalBullet: bulletSeries(),
     verticalLine: lineSeries(),
     waterfall: waterfallSeries()
-}); };
+},
+    trendlineSeriesDefaults()
+)); };
 
 var title = function () { return ({
     font: SANS16

package/dist/es/chart/categorical-chart.js

@@ -1,11 +1,9 @@
 import ErrorRangeCalculator from './error-bars/error-range-calculator';
 import CategoricalErrorBar from './error-bars/categorical-error-bar';
 
-import SeriesBinder from './series-binder';
 import { ERROR_LOW_FIELD, ERROR_HIGH_FIELD } from './constants';
 
-import evalOptions from './utils/eval-options';
-import categoriesCount from './utils/categories-count';
+import { evalOptions, categoriesCount } from './utils';
 
 import { ChartElement, Box } from '../core';
 
@@ -444,9 +442,9 @@ var CategoricalChart = (function (ChartElement) {
     };
 
     CategoricalChart.prototype.limitPoint = function limitPoint (point) {
-        var limittedSlot = this.categoryAxis.limitSlot(point.box);
-        if (!limittedSlot.equals(point.box)) {
-            point.reflow(limittedSlot);
+        var limitedSlot = this.categoryAxis.limitSlot(point.box);
+        if (!limitedSlot.equals(point.box)) {
+            point.reflow(limitedSlot);
         }
     };
 
@@ -502,7 +500,7 @@ var CategoricalChart = (function (ChartElement) {
             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);
+                var pointData = this$1.plotArea.bindPoint(currentSeries, categoryIx);
 
                 callback(pointData, {
                     category: currentCategory,
@@ -523,7 +521,7 @@ var CategoricalChart = (function (ChartElement) {
         var outOfRangePoint = series[field];
         if (outOfRangePoint) {
             var categoryIx = outOfRangePoint.categoryIx;
-            var pointData = this._bindPoint(series, seriesIx, categoryIx, outOfRangePoint.item);
+            var pointData = this.plotArea.bindPoint(series, categoryIx, outOfRangePoint.item);
 
             callback(pointData, {
                 category: outOfRangePoint.category,
@@ -535,24 +533,6 @@ var CategoricalChart = (function (ChartElement) {
         }
     };
 
-    CategoricalChart.prototype._bindPoint = function _bindPoint (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;
-    };
-
     CategoricalChart.prototype.formatPointValue = function formatPointValue (point, format) {
         if (point.value === null) {
             return "";

package/dist/es/chart/constants.js

@@ -62,6 +62,12 @@ var EQUALLY_SPACED_SERIES = [
     BULLET, RANGE_COLUMN, RANGE_BAR, WATERFALL, HORIZONTAL_WATERFALL
 ];
 
+var TRENDLINE_LINEAR = 'linearTrendline';
+var TRENDLINE_MOVING_AVERAGE = 'movingAverageTrendline';
+var TRENDLINE_SERIES = [
+    TRENDLINE_LINEAR, TRENDLINE_MOVING_AVERAGE
+];
+
 var LEGEND_ITEM_CLICK = "legendItemClick";
 var LEGEND_ITEM_HOVER = "legendItemHover";
 var LEGEND_ITEM_LEAVE = "legendItemLeave";
@@ -100,6 +106,8 @@ var MOUSEWHEEL_ZOOM_RATE = 0.3;
 var DRILLDOWN = "drilldown";
 var DRILLDOWN_FIELD = "drilldown";
 
+var MIN_MOVING_AVERAGE_PERIOD = 2;
+
 export {
     INITIAL_ANIMATION_DURATION, FADEIN,
     LEGEND_ITEM_CLICK, LEGEND_ITEM_HOVER, LEGEND_ITEM_LEAVE,
@@ -124,5 +132,7 @@ export {
     SHOW_TOOLTIP, HIDE_TOOLTIP,
     EQUALLY_SPACED_SERIES, ABOVE, BELOW,
     HEATMAP,
-    DRILLDOWN, DRILLDOWN_FIELD
+    DRILLDOWN, DRILLDOWN_FIELD,
+    MIN_MOVING_AVERAGE_PERIOD,
+    TRENDLINE_SERIES, TRENDLINE_LINEAR, TRENDLINE_MOVING_AVERAGE
 };

package/dist/es/chart/heatmap-chart/heatmap-chart.js

@@ -1,7 +1,6 @@
 import { deepExtend, defined, isFunction, setDefaultOptions } from '../../common';
 import { MAX_VALUE, MIN_VALUE } from '../../common/constants';
 import { Box, ChartElement } from '../../core';
-import CategoricalChart from '../categorical-chart';
 import evalOptions from '../utils/eval-options';
 import colorScale from './color-scale';
 import HeatmapPoint from './heatmap-point';
@@ -43,7 +42,7 @@ var HeatmapChart = (function (ChartElement) {
             var currentSeries = series[seriesIx];
 
             for (var pointIx = 0; pointIx < currentSeries.data.length; pointIx++) {
-                var ref$1 = this$1._bindPoint(currentSeries, seriesIx, pointIx);
+                var ref$1 = this$1.plotArea.bindPoint(currentSeries, pointIx);
                 var valueFields = ref$1.valueFields;
                 if (defined(valueFields.value) && valueFields.value !== null) {
                     this$1.valueRange.min = Math.min(this$1.valueRange.min, valueFields.value);
@@ -210,7 +209,7 @@ var HeatmapChart = (function (ChartElement) {
             var yRange = yAxis.currentRangeIndices();
 
             for (var pointIx = 0; pointIx < currentSeries.data.length; pointIx++) {
-                var ref$2 = this$1._bindPoint(currentSeries, seriesIx, pointIx);
+                var ref$2 = this$1.plotArea.bindPoint(currentSeries, pointIx);
                 var value = ref$2.valueFields;
                 var fields = ref$2.fields;
                 var xIndex = xAxis.totalIndex(value.x);
@@ -257,8 +256,5 @@ setDefaultOptions(HeatmapChart, {
     },
     clip: true
 });
-deepExtend(HeatmapChart.prototype, {
-    _bindPoint: CategoricalChart.prototype._bindPoint
-});
 
 export default HeatmapChart;

package/dist/es/chart/plotarea/categorical-plotarea.js

@@ -14,6 +14,8 @@ import OHLCChart from '../ohlc-chart/ohlc-chart';
 import CandlestickChart from '../candlestick-chart/candlestick-chart';
 import BoxPlotChart from '../box-plot-chart/box-plot-chart';
 import WaterfallChart from '../waterfall-chart/waterfall-chart';
+import trendlineFactory from '../trendlines/trendline-factory';
+import trendlineRegistry from '../trendlines/trendline-registry';
 
 import { CategoryAxis, DateCategoryAxis, NumericAxis, LogarithmicAxis, Point } from '../../core';
 
@@ -25,7 +27,7 @@ import { BAR, COLUMN, BULLET, VERTICAL_BULLET, LINE, VERTICAL_LINE, AREA, VERTIC
     BOX_PLOT, VERTICAL_BOX_PLOT, OHLC, CANDLESTICK, LOGARITHMIC, STEP, EQUALLY_SPACED_SERIES } from '../constants';
 
 import { DATE, MAX_VALUE } from '../../common/constants';
-import { setDefaultOptions, inArray, isNumber, deepExtend, defined, eventElement, grep } from '../../common';
+import { setDefaultOptions, inArray, deepExtend, defined, eventElement, grep } from '../../common';
 
 var AREA_SERIES = [ AREA, VERTICAL_AREA, RANGE_AREA, VERTICAL_RANGE_AREA ];
 var OUT_OF_RANGE_SERIES = [ LINE, VERTICAL_LINE ].concat(AREA_SERIES);
@@ -45,6 +47,8 @@ var CategoricalPlotArea = (function (PlotAreaBase) {
         this.namedCategoryAxes = {};
         this.namedValueAxes = {};
         this.valueAxisRangeTracker = new AxisGroupRangeTracker();
+        this._seriesPointsCache = {};
+        this._currentPointsCache = {};
 
         if (series.length > 0) {
             this.invertAxes = inArray(
@@ -60,14 +64,17 @@ var CategoricalPlotArea = (function (PlotAreaBase) {
                 }
             }
         }
-
     };
 
     CategoricalPlotArea.prototype.render = function render (panes) {
         if ( panes === void 0 ) panes = this.panes;
 
+        this.series = [].concat( this.originalSeries );
         this.createCategoryAxes(panes);
+
         this.aggregateCategories(panes);
+        this.createTrendlineSeries(panes);
+
         this.createCategoryAxesLabels(panes);
         this.createCharts(panes);
         this.createValueAxes(panes);
@@ -94,6 +101,62 @@ var CategoricalPlotArea = (function (PlotAreaBase) {
         }
     };
 
+    CategoricalPlotArea.prototype.trendlineFactory = function trendlineFactory$1 (options, series) {
+        var categoryAxis = this.seriesCategoryAxis(options);
+        var seriesValues = this.seriesValues.bind(this, series.index);
+
+        var trendline = trendlineFactory(trendlineRegistry, options.type, {
+            options: options,
+            categoryAxis: categoryAxis,
+            seriesValues: seriesValues
+        });
+
+        if (trendline) {
+            // Inherit settings
+            trendline.categoryAxis = series.categoryAxis;
+            trendline.valueAxis = series.valueAxis;
+
+            return this.filterSeries(trendline, categoryAxis);
+        }
+
+        return trendline;
+    };
+
+    CategoricalPlotArea.prototype.trendlineAggregateForecast = function trendlineAggregateForecast () {
+        return this.series
+            .map(function (series) { return (series.trendline || {}).forecast; })
+            .filter(function (forecast) { return forecast !== undefined; })
+            .reduce(function (result, forecast) { return ({
+                before: Math.max(result.before, forecast.before || 0),
+                after: Math.max(result.after, forecast.after || 0)
+            }); }, { before: 0, after: 0 });
+    };
+
+    CategoricalPlotArea.prototype.seriesValues = function seriesValues (seriesIx, range) {
+        var this$1 = this;
+
+        var result = [];
+
+        var series = this.srcSeries[seriesIx];
+        var categoryAxis = this.seriesCategoryAxis(series);
+        var dateAxis = equalsIgnoreCase(categoryAxis.options.type, DATE);
+        if (dateAxis) {
+            this._seriesPointsCache = {};
+            this._currentPointsCache = {};
+            categoryAxis.options.dataItems = [];
+            series = this.aggregateSeries(series, categoryAxis, categoryAxis.totalRangeIndices());
+        }
+
+        var min = range ? range.min : 0;
+        var max = range ? range.max : series.data.length;
+        for (var categoryIx = min; categoryIx < max; categoryIx++) {
+            var data = this$1.bindPoint(series, categoryIx);
+            result.push({ categoryIx: categoryIx, category: data.fields.category, valueFields: data.valueFields });
+        }
+
+        return result;
+    };
+
     CategoricalPlotArea.prototype.createCharts = function createCharts (panes) {
         var this$1 = this;
 
@@ -161,21 +224,24 @@ var CategoricalPlotArea = (function (PlotAreaBase) {
     CategoricalPlotArea.prototype.aggregateCategories = function aggregateCategories (panes) {
         var this$1 = this;
 
-        var series = this.srcSeries || this.series;
+        var series = [].concat( this.series );
         var processedSeries = [];
         this._currentPointsCache = {};
         this._seriesPointsCache = this._seriesPointsCache || {};
 
         for (var i = 0; i < series.length; i++) {
             var currentSeries = series[i];
-            var categoryAxis = this$1.seriesCategoryAxis(currentSeries);
-            var axisPane = this$1.findPane(categoryAxis.options.pane);
-            var dateAxis = equalsIgnoreCase(categoryAxis.options.type, DATE);
 
-            if ((dateAxis || currentSeries.categoryField) && inArray(axisPane, panes)) {
-                currentSeries = this$1.aggregateSeries(currentSeries, categoryAxis);
-            } else {
-                currentSeries = this$1.filterSeries(currentSeries, categoryAxis);
+            if (!this$1.isTrendline(currentSeries)) {
+                var categoryAxis = this$1.seriesCategoryAxis(currentSeries);
+                var axisPane = this$1.findPane(categoryAxis.options.pane);
+                var dateAxis = equalsIgnoreCase(categoryAxis.options.type, DATE);
+
+                if ((dateAxis || currentSeries.categoryField) && inArray(axisPane, panes)) {
+                    currentSeries = this$1.aggregateSeries(currentSeries, categoryAxis, categoryAxis.currentRangeIndices());
+                } else {
+                    currentSeries = this$1.filterSeries(currentSeries, categoryAxis);
+                }
             }
 
             processedSeries.push(currentSeries);
@@ -192,7 +258,7 @@ var CategoricalPlotArea = (function (PlotAreaBase) {
         var dataLength = (series.data || {}).length;
         categoryAxis._seriesMax = Math.max(categoryAxis._seriesMax || 0, dataLength);
 
-        if (!(isNumber(categoryAxis.options.min) || isNumber(categoryAxis.options.max))) {
+        if (!(defined(categoryAxis.options.min) || defined(categoryAxis.options.max))) {
             return series;
         }
 
@@ -221,7 +287,7 @@ var CategoricalPlotArea = (function (PlotAreaBase) {
         var this$1 = this;
 
         var key = (series.index) + ";" + (categoryAxis.categoriesHash());
-        if (this._seriesPointsCache[key]) {
+        if (this._seriesPointsCache && this._seriesPointsCache[key]) {
             this._currentPointsCache[key] = this._seriesPointsCache[key];
             return this._seriesPointsCache[key];
         }
@@ -233,7 +299,7 @@ var CategoricalPlotArea = (function (PlotAreaBase) {
         var getFn = dateAxis ? getDateField : getField;
         var result = [];
         if (!dateAxis) {
-            categoryAxis.mapCategories();//fixes major performance issue caused by searching for the index for large data
+            categoryAxis.mapCategories(); //fixes major performance issue caused by searching for the index for large data
         }
 
         for (var idx = 0; idx < srcData.length; idx++) {
@@ -256,7 +322,7 @@ var CategoricalPlotArea = (function (PlotAreaBase) {
         return result;
     };
 
-    CategoricalPlotArea.prototype.aggregateSeries = function aggregateSeries (series, categoryAxis) {
+    CategoricalPlotArea.prototype.aggregateSeries = function aggregateSeries (series, categoryAxis, range) {
         var srcData = series.data;
         if (!srcData.length) {
             return series;
@@ -266,9 +332,9 @@ var CategoricalPlotArea = (function (PlotAreaBase) {
         var result = deepExtend({}, series);
         var aggregator = new SeriesAggregator(deepExtend({}, series), SeriesBinder.current, DefaultAggregates.current);
         var data = result.data = [];
+
         var dataItems = categoryAxis.options.dataItems || [];
 
-        var range = categoryAxis.currentRangeIndices();
         var categoryItem = function (idx) {
             var categoryIdx = idx - range.min;
             var point = srcPoints[idx];
@@ -616,6 +682,7 @@ var CategoricalPlotArea = (function (PlotAreaBase) {
                 var categoryAxis = (void 0);
 
                 if (isDateAxis(axisOptions, categories[0])) {
+                    axisOptions._forecast = this$1.trendlineAggregateForecast();
                     categoryAxis = new DateCategoryAxis(axisOptions, this$1.chartService);
                 } else {
                     categoryAxis = new CategoryAxis(axisOptions, this$1.chartService);
@@ -795,4 +862,4 @@ setDefaultOptions(CategoricalPlotArea, {
 
 deepExtend(CategoricalPlotArea.prototype, PlotAreaEventsMixin);
 
-export default CategoricalPlotArea;
+export default CategoricalPlotArea;

package/dist/es/chart/plotarea/plotarea-base.js

@@ -4,9 +4,11 @@ import { ChartElement, Box } from '../../core';
 import Crosshair from '../crosshair/crosshair';
 import Pane from '../pane';
 import { hasValue } from '../utils';
+import SeriesBinder from '../series-binder';
 
-import { WHITE, BLACK, X, Y, COORD_PRECISION, TOP, BOTTOM, LEFT, RIGHT, START, END } from '../../common/constants';
-import { append, deepExtend, defined, getSpacing, getTemplate, inArray, isFunction, isString, limitValue, round, setDefaultOptions } from '../../common';
+import { WHITE, BLACK, X, Y, COORD_PRECISION, TOP, BOTTOM, LEFT, RIGHT, START, END, INHERIT } from '../../common/constants';
+import { append, deepExtend, defined, getSpacing, getTemplate, inArray, isFunction, isString, limitValue, round, setDefaultOptions, last } from '../../common';
+import { TRENDLINE_SERIES } from '../constants';
 
 var PlotAreaBase = (function (ChartElement) {
     function PlotAreaBase(series, options, chartService) {
@@ -22,6 +24,8 @@ var PlotAreaBase = (function (ChartElement) {
         this.crosshairs = [];
         this.chartService = chartService;
         this.originalOptions = options;
+        this.originalSeries = series;
+        this._bindCache = new WeakMap();
 
         this.createPanes();
         this.render();
@@ -42,6 +46,21 @@ var PlotAreaBase = (function (ChartElement) {
         }
     };
 
+    PlotAreaBase.prototype.bindPoint = function bindPoint (series, pointIx, item) {
+        var cached = this._bindCache.get(series);
+        if (!cached) {
+            cached = [];
+            this._bindCache.set(series, cached);
+        }
+
+        var data = cached[pointIx];
+        if (!data) {
+            data = cached[pointIx] = SeriesBinder.current.bindPoint(series, pointIx, item);
+        }
+
+        return data;
+    };
+
     PlotAreaBase.prototype.createPanes = function createPanes () {
         var this$1 = this;
 
@@ -334,6 +353,8 @@ var PlotAreaBase = (function (ChartElement) {
             panesArray[i].empty();
         }
 
+        this._bindCache = new WeakMap();
+
         this.render(panesArray);
         this.detachLabels();
         this.reflowAxes(this.panes);
@@ -968,6 +989,54 @@ var PlotAreaBase = (function (ChartElement) {
         return labelAxis;
     };
 
+    PlotAreaBase.prototype.isTrendline = function isTrendline (series) {
+        return series && inArray(series.type, TRENDLINE_SERIES);
+    };
+
+    PlotAreaBase.prototype.trendlineFactory = function trendlineFactory () { /* abstract */ };
+
+    PlotAreaBase.prototype.createTrendlineSeries = function createTrendlineSeries () {
+        var this$1 = this;
+
+        var modifiedSeries = [];
+
+        this.series = this.series.map(function (series) {
+            if (!this$1.isTrendline(series)) {
+                return series;
+            }
+
+            var forSeries = this$1.seriesByName(series.for);
+            if (!forSeries) {
+                throw new Error('Invalid Configuration: Unable to locate linked series ' +
+                    "\"" + (series.for) + "\" for trendline \"" + (series.name) + "\".");
+            }
+
+            var valueFields = SeriesBinder.current.valueFields(forSeries);
+            var field = last(valueFields); // Use the last field for multi-field series
+
+            var trendlineSeries = this$1.trendlineFactory(Object.assign({}, {field: field}, series), forSeries);
+            if (trendlineSeries) {
+                if (forSeries.visible === false) {
+                    trendlineSeries.visible = false;
+                }
+
+                if (trendlineSeries.color === INHERIT) {
+                    trendlineSeries.color = forSeries.color;
+                }
+
+                modifiedSeries.push(trendlineSeries);
+            }
+
+            return trendlineSeries;
+        }).filter(function (series) { return series !== null; });
+
+        return modifiedSeries;
+    };
+
+    PlotAreaBase.prototype.seriesByName = function seriesByName (name) {
+        return this.series.find(function (series) { return series.name === name; });
+    };
+
     return PlotAreaBase;
 }(ChartElement));
 

package/dist/es/chart/plotarea/plotarea-factory.js

@@ -1,5 +1,6 @@
 import filterSeriesByType from '../utils/filter-series-by-type';
 import { Class } from '../../common';
+import { TRENDLINE_SERIES } from '../constants';
 
 var PlotAreaFactory = (function (Class) {
     function PlotAreaFactory() {
@@ -27,8 +28,9 @@ var PlotAreaFactory = (function (Class) {
         for (var idx = 0; idx < registry.length; idx++) {
             var entry = registry[idx];
             series = filterSeriesByType(srcSeries, entry.seriesTypes);
+            var trendlines = filterSeriesByType(srcSeries, TRENDLINE_SERIES);
 
-            if (series.length > 0) {
+            if ((series.length - trendlines.length) > 0) {
                 match = entry;
                 break;
             }
@@ -42,4 +44,4 @@ var PlotAreaFactory = (function (Class) {
 
 PlotAreaFactory.current = new PlotAreaFactory();
 
-export default PlotAreaFactory;
+export default PlotAreaFactory;

package/dist/es/chart/plotarea/polar-plotarea.js

@@ -13,6 +13,7 @@ import filterSeriesByType from '../utils/filter-series-by-type';
 
 import { ARC } from '../../common/constants';
 import { deepExtend, eventElement, setDefaultOptions } from '../../common';
+import XYPlotArea from './xy-plotarea';
 
 var PolarPlotArea = (function (PolarPlotAreaBase) {
     function PolarPlotArea () {
@@ -31,6 +32,13 @@ var PolarPlotArea = (function (PolarPlotAreaBase) {
         this.appendAxis(polarAxis);
     };
 
+    PolarPlotArea.prototype.render = function render () {
+        this.series = [].concat( this.originalSeries );
+        this.createTrendlineSeries();
+
+        PolarPlotAreaBase.prototype.render.call(this);
+    };
+
     PolarPlotArea.prototype.valueAxisOptions = function valueAxisOptions (defaults) {
         return deepExtend(defaults, {
             majorGridLines: { type: ARC },
@@ -43,6 +51,15 @@ var PolarPlotArea = (function (PolarPlotAreaBase) {
         this.axisY = this.valueAxis;
     };
 
+    PolarPlotArea.prototype.trendlineFactory = function trendlineFactory (options, series) {
+        var trendline = XYPlotArea.prototype.trendlineFactory.call(this, options, series);
+        if (trendline) {
+            trendline.type = POLAR_LINE;
+        }
+
+        return trendline;
+    };
+
     PolarPlotArea.prototype.appendChart = function appendChart (chart, pane) {
         this.valueAxisRangeTracker.update(chart.yAxisRanges);
 
@@ -124,6 +141,8 @@ setDefaultOptions(PolarPlotArea, {
     yAxis: {}
 });
 
-deepExtend(PolarPlotArea.prototype, PlotAreaEventsMixin);
+deepExtend(PolarPlotArea.prototype, PlotAreaEventsMixin, {
+    seriesValues: XYPlotArea.prototype.seriesValues
+});
 
-export default PolarPlotArea;
+export default PolarPlotArea;

package/dist/es/chart/plotarea/radar-plotarea.js

@@ -30,6 +30,7 @@ var RadarPlotArea = (function (PolarPlotAreaBase) {
         this.categoryAxis = categoryAxis;
         this.appendAxis(categoryAxis);
         this.aggregateCategories();
+        this.createTrendlineSeries();
         this.createCategoryAxesLabels();
     };
 
@@ -65,6 +66,15 @@ var RadarPlotArea = (function (PolarPlotAreaBase) {
         return currentSeries;
     };
 
+    RadarPlotArea.prototype.trendlineFactory = function trendlineFactory (options, series) {
+        var trendline = CategoricalPlotArea.prototype.trendlineFactory.call(this, options, series);
+        if (trendline) {
+            trendline.type = RADAR_LINE;
+        }
+
+        return trendline;
+    };
+
     RadarPlotArea.prototype.createCharts = function createCharts () {
         var series = this.filterVisibleSeries(this.series);
         var pane = this.panes[0];
@@ -163,7 +173,8 @@ var RadarPlotArea = (function (PolarPlotAreaBase) {
 deepExtend(RadarPlotArea.prototype, PlotAreaEventsMixin, {
     appendChart: CategoricalPlotArea.prototype.appendChart,
     aggregateSeries: CategoricalPlotArea.prototype.aggregateSeries,
-    seriesSourcePoints: CategoricalPlotArea.prototype.seriesSourcePoints
+    seriesSourcePoints: CategoricalPlotArea.prototype.seriesSourcePoints,
+    seriesValues: CategoricalPlotArea.prototype.seriesValues
 });
 
 setDefaultOptions(RadarPlotArea, {
@@ -173,4 +184,4 @@ setDefaultOptions(RadarPlotArea, {
     valueAxis: {}
 });
 
-export default RadarPlotArea;
+export default RadarPlotArea;

package/dist/es/chart/plotarea/xy-plotarea.js

@@ -5,12 +5,12 @@ import ScatterChart from '../scatter-charts/scatter-chart';
 import ScatterLineChart from '../scatter-charts/scatter-line-chart';
 import BubbleChart from '../bubble-chart/bubble-chart';
 import SeriesBinder from '../series-binder';
+import trendlineFactory from '../trendlines/trendline-factory';
+import scatterTrendlineRegistry from '../trendlines/scatter-trendline-registry';
 
 import { NumericAxis, LogarithmicAxis, DateValueAxis, Point } from '../../core';
 
-import filterSeriesByType from '../utils/filter-series-by-type';
-import equalsIgnoreCase from '../utils/equals-ignore-case';
-import singleItemOrArray from '../utils/single-item-or-array';
+import { filterSeriesByType, equalsIgnoreCase, singleItemOrArray } from '../utils';
 
 import { SCATTER, SCATTER_LINE, BUBBLE, LOGARITHMIC } from '../constants';
 
@@ -38,8 +38,10 @@ var XYPlotArea = (function (PlotAreaBase) {
         var this$1 = this;
         if ( panes === void 0 ) panes = this.panes;
 
-        var seriesByPane = this.groupSeriesByPane();
+        this.series = [].concat( this.originalSeries );
+        this.createTrendlineSeries();
 
+        var seriesByPane = this.groupSeriesByPane();
         for (var i = 0; i < panes.length; i++) {
             var pane = panes[i];
             var paneSeries = seriesByPane[pane.options.name || "default"] || [];
@@ -265,6 +267,37 @@ var XYPlotArea = (function (PlotAreaBase) {
         updateAxisOptions(this.originalOptions, index, vertical, options);
     };
 
+    XYPlotArea.prototype.trendlineFactory = function trendlineFactory$1 (options, series) {
+        var seriesValues = this.seriesValues.bind(this, series.index);
+
+        var trendline = trendlineFactory(scatterTrendlineRegistry, options.type, {
+            options: options,
+            seriesValues: seriesValues
+        });
+
+        if (trendline) {
+            // Inherit settings
+            trendline.xAxis = series.xAxis;
+            trendline.yAxis = series.yAxis;
+        }
+
+        return trendline;
+    };
+
+    XYPlotArea.prototype.seriesValues = function seriesValues (seriesIx) {
+        var this$1 = this;
+
+        var result = [];
+        var currentSeries = this.series[seriesIx];
+
+        for (var pointIx = 0; pointIx < currentSeries.data.length; pointIx++) {
+            var data = this$1.bindPoint(currentSeries, pointIx);
+            result.push({ pointIx: pointIx, valueFields: data.valueFields });
+        }
+
+        return result;
+    };
+
     return XYPlotArea;
 }(PlotAreaBase));
 
@@ -280,4 +313,4 @@ setDefaultOptions(XYPlotArea, {
 
 deepExtend(XYPlotArea.prototype, PlotAreaEventsMixin);
 
-export default XYPlotArea;
+export default XYPlotArea;