@progress/kendo-charts 1.31.0 → 1.32.0

package/dist/es2015/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';
 
@@ -420,9 +418,9 @@ class CategoricalChart extends ChartElement {
     }
 
     limitPoint(point) {
-        const limittedSlot = this.categoryAxis.limitSlot(point.box);
-        if (!limittedSlot.equals(point.box)) {
-            point.reflow(limittedSlot);
+        const limitedSlot = this.categoryAxis.limitSlot(point.box);
+        if (!limitedSlot.equals(point.box)) {
+            point.reflow(limitedSlot);
         }
     }
 
@@ -476,7 +474,7 @@ class CategoricalChart extends ChartElement {
             for (let seriesIx = 0; seriesIx < seriesCount; seriesIx++) {
                 const currentSeries = series[seriesIx];
                 const currentCategory = this.categoryAxis.categoryAt(categoryIx);
-                const pointData = this._bindPoint(currentSeries, seriesIx, categoryIx);
+                const pointData = this.plotArea.bindPoint(currentSeries, categoryIx);
 
                 callback(pointData, {
                     category: currentCategory,
@@ -497,7 +495,7 @@ class CategoricalChart extends ChartElement {
         const outOfRangePoint = series[field];
         if (outOfRangePoint) {
             const categoryIx = outOfRangePoint.categoryIx;
-            const pointData = this._bindPoint(series, seriesIx, categoryIx, outOfRangePoint.item);
+            const pointData = this.plotArea.bindPoint(series, categoryIx, outOfRangePoint.item);
 
             callback(pointData, {
                 category: outOfRangePoint.category,
@@ -509,24 +507,6 @@ class CategoricalChart extends ChartElement {
         }
     }
 
-    _bindPoint(series, seriesIx, categoryIx, item) {
-        if (!this._bindCache) {
-            this._bindCache = [];
-        }
-
-        let bindCache = this._bindCache[seriesIx];
-        if (!bindCache) {
-            bindCache = this._bindCache[seriesIx] = [];
-        }
-
-        let data = bindCache[categoryIx];
-        if (!data) {
-            data = bindCache[categoryIx] = SeriesBinder.current.bindPoint(series, categoryIx, item);
-        }
-
-        return data;
-    }
-
     formatPointValue(point, format) {
         if (point.value === null) {
             return "";

package/dist/es2015/chart/constants.js

@@ -62,6 +62,12 @@ const EQUALLY_SPACED_SERIES = [
     BULLET, RANGE_COLUMN, RANGE_BAR, WATERFALL, HORIZONTAL_WATERFALL
 ];
 
+const TRENDLINE_LINEAR = 'linearTrendline';
+const TRENDLINE_MOVING_AVERAGE = 'movingAverageTrendline';
+const TRENDLINE_SERIES = [
+    TRENDLINE_LINEAR, TRENDLINE_MOVING_AVERAGE
+];
+
 const LEGEND_ITEM_CLICK = "legendItemClick";
 const LEGEND_ITEM_HOVER = "legendItemHover";
 const LEGEND_ITEM_LEAVE = "legendItemLeave";
@@ -100,6 +106,8 @@ const MOUSEWHEEL_ZOOM_RATE = 0.3;
 const DRILLDOWN = "drilldown";
 const DRILLDOWN_FIELD = "drilldown";
 
+const 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/es2015/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';
@@ -36,7 +35,7 @@ class HeatmapChart extends ChartElement {
             const currentSeries = series[seriesIx];
 
             for (let pointIx = 0; pointIx < currentSeries.data.length; pointIx++) {
-                const { valueFields } = this._bindPoint(currentSeries, seriesIx, pointIx);
+                const { valueFields } = this.plotArea.bindPoint(currentSeries, pointIx);
                 if (defined(valueFields.value) && valueFields.value !== null) {
                     this.valueRange.min = Math.min(this.valueRange.min, valueFields.value);
                     this.valueRange.max = Math.max(this.valueRange.max, valueFields.value);
@@ -191,7 +190,7 @@ class HeatmapChart extends ChartElement {
             const yRange = yAxis.currentRangeIndices();
 
             for (let pointIx = 0; pointIx < currentSeries.data.length; pointIx++) {
-                const { valueFields: value, fields } = this._bindPoint(currentSeries, seriesIx, pointIx);
+                const { valueFields: value, fields } = this.plotArea.bindPoint(currentSeries, pointIx);
                 const xIndex = xAxis.totalIndex(value.x);
                 const yIndex = yAxis.totalIndex(value.y);
                 const xIn = xRange.min <= xIndex && xIndex <= xRange.max;
@@ -234,8 +233,5 @@ setDefaultOptions(HeatmapChart, {
     },
     clip: true
 });
-deepExtend(HeatmapChart.prototype, {
-    _bindPoint: CategoricalChart.prototype._bindPoint
-});
 
 export default HeatmapChart;

package/dist/es2015/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';
 
 const AREA_SERIES = [ AREA, VERTICAL_AREA, RANGE_AREA, VERTICAL_RANGE_AREA ];
 const OUT_OF_RANGE_SERIES = [ LINE, VERTICAL_LINE ].concat(AREA_SERIES);
@@ -36,6 +38,8 @@ class CategoricalPlotArea extends PlotAreaBase {
         this.namedCategoryAxes = {};
         this.namedValueAxes = {};
         this.valueAxisRangeTracker = new AxisGroupRangeTracker();
+        this._seriesPointsCache = {};
+        this._currentPointsCache = {};
 
         if (series.length > 0) {
             this.invertAxes = inArray(
@@ -51,12 +55,15 @@ class CategoricalPlotArea extends PlotAreaBase {
                 }
             }
         }
-
     }
 
     render(panes = this.panes) {
+        this.series = [...this.originalSeries];
         this.createCategoryAxes(panes);
+
         this.aggregateCategories(panes);
+        this.createTrendlineSeries(panes);
+
         this.createCategoryAxesLabels(panes);
         this.createCharts(panes);
         this.createValueAxes(panes);
@@ -83,6 +90,60 @@ class CategoricalPlotArea extends PlotAreaBase {
         }
     }
 
+    trendlineFactory(options, series) {
+        const categoryAxis = this.seriesCategoryAxis(options);
+        const seriesValues = this.seriesValues.bind(this, series.index);
+
+        const trendline = trendlineFactory(trendlineRegistry, options.type, {
+            options,
+            categoryAxis,
+            seriesValues
+        });
+
+        if (trendline) {
+            // Inherit settings
+            trendline.categoryAxis = series.categoryAxis;
+            trendline.valueAxis = series.valueAxis;
+
+            return this.filterSeries(trendline, categoryAxis);
+        }
+
+        return trendline;
+    }
+
+    trendlineAggregateForecast() {
+        return this.series
+            .map(series => (series.trendline || {}).forecast)
+            .filter(forecast => forecast !== undefined)
+            .reduce((result, forecast) => ({
+                before: Math.max(result.before, forecast.before || 0),
+                after: Math.max(result.after, forecast.after || 0)
+            }), { before: 0, after: 0 });
+    }
+
+    seriesValues(seriesIx, range) {
+        const result = [];
+
+        let series = this.srcSeries[seriesIx];
+        const categoryAxis = this.seriesCategoryAxis(series);
+        const dateAxis = equalsIgnoreCase(categoryAxis.options.type, DATE);
+        if (dateAxis) {
+            this._seriesPointsCache = {};
+            this._currentPointsCache = {};
+            categoryAxis.options.dataItems = [];
+            series = this.aggregateSeries(series, categoryAxis, categoryAxis.totalRangeIndices());
+        }
+
+        const min = range ? range.min : 0;
+        const max = range ? range.max : series.data.length;
+        for (let categoryIx = min; categoryIx < max; categoryIx++) {
+            const data = this.bindPoint(series, categoryIx);
+            result.push({ categoryIx, category: data.fields.category, valueFields: data.valueFields });
+        }
+
+        return result;
+    }
+
     createCharts(panes) {
         const seriesByPane = this.groupSeriesByPane();
 
@@ -146,21 +207,24 @@ class CategoricalPlotArea extends PlotAreaBase {
     }
 
     aggregateCategories(panes) {
-        const series = this.srcSeries || this.series;
+        const series = [...this.series];
         const processedSeries = [];
         this._currentPointsCache = {};
         this._seriesPointsCache = this._seriesPointsCache || {};
 
         for (let i = 0; i < series.length; i++) {
             let currentSeries = series[i];
-            const categoryAxis = this.seriesCategoryAxis(currentSeries);
-            const axisPane = this.findPane(categoryAxis.options.pane);
-            const dateAxis = equalsIgnoreCase(categoryAxis.options.type, DATE);
 
-            if ((dateAxis || currentSeries.categoryField) && inArray(axisPane, panes)) {
-                currentSeries = this.aggregateSeries(currentSeries, categoryAxis);
-            } else {
-                currentSeries = this.filterSeries(currentSeries, categoryAxis);
+            if (!this.isTrendline(currentSeries)) {
+                const categoryAxis = this.seriesCategoryAxis(currentSeries);
+                const axisPane = this.findPane(categoryAxis.options.pane);
+                const dateAxis = equalsIgnoreCase(categoryAxis.options.type, DATE);
+
+                if ((dateAxis || currentSeries.categoryField) && inArray(axisPane, panes)) {
+                    currentSeries = this.aggregateSeries(currentSeries, categoryAxis, categoryAxis.currentRangeIndices());
+                } else {
+                    currentSeries = this.filterSeries(currentSeries, categoryAxis);
+                }
             }
 
             processedSeries.push(currentSeries);
@@ -177,7 +241,7 @@ class CategoricalPlotArea extends PlotAreaBase {
         const 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;
         }
 
@@ -204,7 +268,7 @@ class CategoricalPlotArea extends PlotAreaBase {
 
     seriesSourcePoints(series, categoryAxis) {
         const 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];
         }
@@ -216,7 +280,7 @@ class CategoricalPlotArea extends PlotAreaBase {
         const getFn = dateAxis ? getDateField : getField;
         const 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 (let idx = 0; idx < srcData.length; idx++) {
@@ -239,7 +303,7 @@ class CategoricalPlotArea extends PlotAreaBase {
         return result;
     }
 
-    aggregateSeries(series, categoryAxis) {
+    aggregateSeries(series, categoryAxis, range) {
         const srcData = series.data;
         if (!srcData.length) {
             return series;
@@ -249,9 +313,9 @@ class CategoricalPlotArea extends PlotAreaBase {
         const result = deepExtend({}, series);
         const aggregator = new SeriesAggregator(deepExtend({}, series), SeriesBinder.current, DefaultAggregates.current);
         const data = result.data = [];
+
         const dataItems = categoryAxis.options.dataItems || [];
 
-        const range = categoryAxis.currentRangeIndices();
         const categoryItem = (idx) => {
             const categoryIdx = idx - range.min;
             let point = srcPoints[idx];
@@ -594,6 +658,7 @@ class CategoricalPlotArea extends PlotAreaBase {
                 let categoryAxis;
 
                 if (isDateAxis(axisOptions, categories[0])) {
+                    axisOptions._forecast = this.trendlineAggregateForecast();
                     categoryAxis = new DateCategoryAxis(axisOptions, this.chartService);
                 } else {
                     categoryAxis = new CategoryAxis(axisOptions, this.chartService);
@@ -769,4 +834,4 @@ setDefaultOptions(CategoricalPlotArea, {
 
 deepExtend(CategoricalPlotArea.prototype, PlotAreaEventsMixin);
 
-export default CategoricalPlotArea;
+export default CategoricalPlotArea;

package/dist/es2015/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';
 
 class PlotAreaBase extends ChartElement {
     constructor(series, options, chartService) {
@@ -22,6 +24,8 @@ class PlotAreaBase extends ChartElement {
         this.crosshairs = [];
         this.chartService = chartService;
         this.originalOptions = options;
+        this.originalSeries = series;
+        this._bindCache = new WeakMap();
 
         this.createPanes();
         this.render();
@@ -38,6 +42,21 @@ class PlotAreaBase extends ChartElement {
         }
     }
 
+    bindPoint(series, pointIx, item) {
+        let cached = this._bindCache.get(series);
+        if (!cached) {
+            cached = [];
+            this._bindCache.set(series, cached);
+        }
+
+        let data = cached[pointIx];
+        if (!data) {
+            data = cached[pointIx] = SeriesBinder.current.bindPoint(series, pointIx, item);
+        }
+
+        return data;
+    }
+
     createPanes() {
         const titleOptions = this.options.title || {};
         const paneDefaults = this.options.paneDefaults;
@@ -317,6 +336,8 @@ class PlotAreaBase extends ChartElement {
             panesArray[i].empty();
         }
 
+        this._bindCache = new WeakMap();
+
         this.render(panesArray);
         this.detachLabels();
         this.reflowAxes(this.panes);
@@ -937,6 +958,52 @@ class PlotAreaBase extends ChartElement {
 
         return labelAxis;
     }
+
+    isTrendline(series) {
+        return series && inArray(series.type, TRENDLINE_SERIES);
+    }
+
+    trendlineFactory() { /* abstract */ }
+
+    createTrendlineSeries() {
+        const modifiedSeries = [];
+
+        this.series = this.series.map(series => {
+            if (!this.isTrendline(series)) {
+                return series;
+            }
+
+            const forSeries = this.seriesByName(series.for);
+            if (!forSeries) {
+                throw new Error('Invalid Configuration: Unable to locate linked series ' +
+                    `"${series.for}" for trendline "${series.name}".`);
+            }
+
+            const valueFields = SeriesBinder.current.valueFields(forSeries);
+            const field = last(valueFields); // Use the last field for multi-field series
+
+            const trendlineSeries = this.trendlineFactory(Object.assign({}, {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(series => series !== null);
+
+        return modifiedSeries;
+    }
+
+    seriesByName(name) {
+        return this.series.find(series => series.name === name);
+    }
 }
 
 function isSingleAxis(axis) {

package/dist/es2015/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';
 
 class PlotAreaFactory extends Class {
 
@@ -24,8 +25,9 @@ class PlotAreaFactory extends Class {
         for (let idx = 0; idx < registry.length; idx++) {
             const entry = registry[idx];
             series = filterSeriesByType(srcSeries, entry.seriesTypes);
+            const trendlines = filterSeriesByType(srcSeries, TRENDLINE_SERIES);
 
-            if (series.length > 0) {
+            if ((series.length - trendlines.length) > 0) {
                 match = entry;
                 break;
             }
@@ -37,4 +39,4 @@ class PlotAreaFactory extends Class {
 
 PlotAreaFactory.current = new PlotAreaFactory();
 
-export default PlotAreaFactory;
+export default PlotAreaFactory;

package/dist/es2015/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';
 
 class PolarPlotArea extends PolarPlotAreaBase {
     createPolarAxis() {
@@ -23,6 +24,13 @@ class PolarPlotArea extends PolarPlotAreaBase {
         this.appendAxis(polarAxis);
     }
 
+    render() {
+        this.series = [...this.originalSeries];
+        this.createTrendlineSeries();
+
+        super.render();
+    }
+
     valueAxisOptions(defaults) {
         return deepExtend(defaults, {
             majorGridLines: { type: ARC },
@@ -35,6 +43,15 @@ class PolarPlotArea extends PolarPlotAreaBase {
         this.axisY = this.valueAxis;
     }
 
+    trendlineFactory(options, series) {
+        const trendline = XYPlotArea.prototype.trendlineFactory.call(this, options, series);
+        if (trendline) {
+            trendline.type = POLAR_LINE;
+        }
+
+        return trendline;
+    }
+
     appendChart(chart, pane) {
         this.valueAxisRangeTracker.update(chart.yAxisRanges);
 
@@ -114,6 +131,8 @@ setDefaultOptions(PolarPlotArea, {
     yAxis: {}
 });
 
-deepExtend(PolarPlotArea.prototype, PlotAreaEventsMixin);
+deepExtend(PolarPlotArea.prototype, PlotAreaEventsMixin, {
+    seriesValues: XYPlotArea.prototype.seriesValues
+});
 
-export default PolarPlotArea;
+export default PolarPlotArea;

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

@@ -22,6 +22,7 @@ class RadarPlotArea extends PolarPlotAreaBase {
         this.categoryAxis = categoryAxis;
         this.appendAxis(categoryAxis);
         this.aggregateCategories();
+        this.createTrendlineSeries();
         this.createCategoryAxesLabels();
     }
 
@@ -57,6 +58,15 @@ class RadarPlotArea extends PolarPlotAreaBase {
         return currentSeries;
     }
 
+    trendlineFactory(options, series) {
+        const trendline = CategoricalPlotArea.prototype.trendlineFactory.call(this, options, series);
+        if (trendline) {
+            trendline.type = RADAR_LINE;
+        }
+
+        return trendline;
+    }
+
     createCharts() {
         const series = this.filterVisibleSeries(this.series);
         const pane = this.panes[0];
@@ -153,7 +163,8 @@ class RadarPlotArea extends 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, {
@@ -163,4 +174,4 @@ setDefaultOptions(RadarPlotArea, {
     valueAxis: {}
 });
 
-export default RadarPlotArea;
+export default RadarPlotArea;

package/dist/es2015/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';
 
@@ -27,8 +27,10 @@ class XYPlotArea extends PlotAreaBase {
     }
 
     render(panes = this.panes) {
-        const seriesByPane = this.groupSeriesByPane();
+        this.series = [...this.originalSeries];
+        this.createTrendlineSeries();
 
+        const seriesByPane = this.groupSeriesByPane();
         for (let i = 0; i < panes.length; i++) {
             const pane = panes[i];
             const paneSeries = seriesByPane[pane.options.name || "default"] || [];
@@ -251,6 +253,35 @@ class XYPlotArea extends PlotAreaBase {
         updateAxisOptions(this.options, index, vertical, options);
         updateAxisOptions(this.originalOptions, index, vertical, options);
     }
+
+    trendlineFactory(options, series) {
+        const seriesValues = this.seriesValues.bind(this, series.index);
+
+        const trendline = trendlineFactory(scatterTrendlineRegistry, options.type, {
+            options,
+            seriesValues
+        });
+
+        if (trendline) {
+            // Inherit settings
+            trendline.xAxis = series.xAxis;
+            trendline.yAxis = series.yAxis;
+        }
+
+        return trendline;
+    }
+
+    seriesValues(seriesIx) {
+        const result = [];
+        const currentSeries = this.series[seriesIx];
+
+        for (let pointIx = 0; pointIx < currentSeries.data.length; pointIx++) {
+            const data = this.bindPoint(currentSeries, pointIx);
+            result.push({ pointIx, valueFields: data.valueFields });
+        }
+
+        return result;
+    }
 }
 
 function updateAxisOptions(targetOptions, axisIndex, vertical, options) {
@@ -265,4 +296,4 @@ setDefaultOptions(XYPlotArea, {
 
 deepExtend(XYPlotArea.prototype, PlotAreaEventsMixin);
 
-export default XYPlotArea;
+export default XYPlotArea;

package/dist/es2015/chart/register-charts.js

@@ -15,7 +15,7 @@ import { COLUMN, DONUT, PIE, FUNNEL, PYRAMID, BAR, LINE, VERTICAL_LINE, AREA, VE
     RANGE_BAR, WATERFALL, HORIZONTAL_WATERFALL, SCATTER, SCATTER_LINE, BUBBLE,
     POLAR_AREA, POLAR_LINE, POLAR_SCATTER, RADAR_AREA, RADAR_COLUMN, RADAR_LINE, CATEGORY,
     RANGE_AREA, VERTICAL_RANGE_AREA, X_ERROR_LOW_FIELD, X_ERROR_HIGH_FIELD, Y_ERROR_LOW_FIELD, Y_ERROR_HIGH_FIELD,
-    ERROR_LOW_FIELD, ERROR_HIGH_FIELD, HEATMAP, DRILLDOWN_FIELD } from './constants';
+    ERROR_LOW_FIELD, ERROR_HIGH_FIELD, HEATMAP, DRILLDOWN_FIELD, TRENDLINE_SERIES } from './constants';
 import { X, Y, VALUE } from '../common/constants';
 
 const COLOR = "color";
@@ -30,19 +30,28 @@ const TO = "to";
 PlotAreaFactory.current.register(CategoricalPlotArea, [
     BAR, COLUMN, LINE, VERTICAL_LINE, AREA, VERTICAL_AREA,
     CANDLESTICK, OHLC, BULLET, VERTICAL_BULLET, BOX_PLOT, VERTICAL_BOX_PLOT,
-    RANGE_COLUMN, RANGE_BAR, WATERFALL, HORIZONTAL_WATERFALL, RANGE_AREA, VERTICAL_RANGE_AREA
+    RANGE_COLUMN, RANGE_BAR, WATERFALL, HORIZONTAL_WATERFALL, RANGE_AREA, VERTICAL_RANGE_AREA,
+    ...TRENDLINE_SERIES
 ]);
 
 PlotAreaFactory.current.register(XYPlotArea, [
-    SCATTER, SCATTER_LINE, BUBBLE
+    SCATTER, SCATTER_LINE, BUBBLE,
+    ...TRENDLINE_SERIES
 ]);
 
 PlotAreaFactory.current.register(PiePlotArea, [ PIE ]);
 PlotAreaFactory.current.register(DonutPlotArea, [ DONUT ]);
 PlotAreaFactory.current.register(FunnelPlotArea, [ FUNNEL, PYRAMID ]);
 
-PlotAreaFactory.current.register(PolarPlotArea, [ POLAR_AREA, POLAR_LINE, POLAR_SCATTER ]);
-PlotAreaFactory.current.register(RadarPlotArea, [ RADAR_AREA, RADAR_COLUMN, RADAR_LINE ]);
+PlotAreaFactory.current.register(PolarPlotArea, [
+    POLAR_AREA, POLAR_LINE, POLAR_SCATTER,
+    ...TRENDLINE_SERIES
+]);
+
+PlotAreaFactory.current.register(RadarPlotArea, [
+    RADAR_AREA, RADAR_COLUMN, RADAR_LINE,
+    ...TRENDLINE_SERIES
+]);
 
 PlotAreaFactory.current.register(HeatmapPlotArea, [ HEATMAP ]);