@progress/kendo-charts 2.7.2-dev.202502101310 → 2.7.2-develop.1

package/dist/es/chart/range-area-chart/range-area-point.js

@@ -10,13 +10,13 @@ import { WHITE, CIRCLE, HIGHLIGHT_ZINDEX, LEFT, RIGHT, BOTTOM, CENTER } from '..
 import { deepExtend, valueOrDefault, getSpacing } from '../../common';
 import guid from '../../core/utils/guid';
 
-var AUTO = 'auto';
-var DEFAULT_FROM_FORMAT = '{0}';
-var DEFAULT_TO_FORMAT = '{1}';
+const AUTO = 'auto';
+const DEFAULT_FROM_FORMAT = '{0}';
+const DEFAULT_TO_FORMAT = '{1}';
 
-var RangeAreaPoint = (function (ChartElement) {
-    function RangeAreaPoint(value, options) {
-        ChartElement.call(this);
+class RangeAreaPoint extends ChartElement {
+    constructor(value, options) {
+        super();
 
         this.value = value;
         this.options = options;
@@ -26,28 +26,22 @@ var RangeAreaPoint = (function (ChartElement) {
         this.initLabelsFormat();
     }
 
-    if ( ChartElement ) RangeAreaPoint.__proto__ = ChartElement;
-    RangeAreaPoint.prototype = Object.create( ChartElement && ChartElement.prototype );
-    RangeAreaPoint.prototype.constructor = RangeAreaPoint;
-
-    RangeAreaPoint.prototype.render = function render () {
+    render() {
         if (this._rendered) {
             return;
         }
 
         this._rendered = true;
 
-        var ref = this.options;
-        var markers = ref.markers;
-        var labels = ref.labels;
-        var value = this.value;
+        const { markers, labels } = this.options;
+        const value = this.value;
 
-        var fromPoint = this.fromPoint = new RangeLinePoint(value, deepExtend({}, this.options, {
+        const fromPoint = this.fromPoint = new RangeLinePoint(value, deepExtend({}, this.options, {
             labels: labels.from,
             markers: markers.from
         }));
 
-        var toPoint = this.toPoint = new RangeLinePoint(value, deepExtend({}, this.options, {
+        const toPoint = this.toPoint = new RangeLinePoint(value, deepExtend({}, this.options, {
             labels: labels.to,
             markers: markers.to
         }));
@@ -57,13 +51,12 @@ var RangeAreaPoint = (function (ChartElement) {
 
         this.append(fromPoint);
         this.append(toPoint);
-    };
+    }
 
-    RangeAreaPoint.prototype.reflow = function reflow (targetBox) {
+    reflow(targetBox) {
         this.render();
 
-        var fromBox = targetBox.from;
-        var toBox = targetBox.to;
+        const { from: fromBox, to: toBox } = targetBox;
 
         this.positionLabels(fromBox, toBox);
 
@@ -71,45 +64,45 @@ var RangeAreaPoint = (function (ChartElement) {
         this.toPoint.reflow(toBox);
 
         this.box = this.fromPoint.markerBox().clone().wrap(this.toPoint.markerBox());
-    };
+    }
 
-    RangeAreaPoint.prototype.createHighlight = function createHighlight () {
-        var group = new draw.Group();
+    createHighlight() {
+        const group = new draw.Group();
         group.append(this.fromPoint.createHighlight());
         group.append(this.toPoint.createHighlight());
 
         return group;
-    };
+    }
 
-    RangeAreaPoint.prototype.highlightVisual = function highlightVisual () {
+    highlightVisual() {
         return this.visual;
-    };
+    }
 
-    RangeAreaPoint.prototype.highlightVisualArgs = function highlightVisualArgs () {
+    highlightVisualArgs() {
         return {
             options: this.options,
             from: this.fromPoint.highlightVisualArgs(),
             to: this.toPoint.highlightVisualArgs()
         };
-    };
+    }
 
-    RangeAreaPoint.prototype.createFocusHighlight = function createFocusHighlight () {
-        var group = new draw.Group();
+    createFocusHighlight() {
+        const group = new draw.Group();
         group.append(this.fromPoint.createFocusHighlight());
         group.append(this.toPoint.createFocusHighlight());
 
         return group;
-    };
+    }
 
-    RangeAreaPoint.prototype.tooltipAnchor = function tooltipAnchor () {
-        var clipBox = this.owner.pane.clipBox();
-        var showTooltip = !clipBox || clipBox.overlaps(this.box);
+    tooltipAnchor() {
+        const clipBox = this.owner.pane.clipBox();
+        const showTooltip = !clipBox || clipBox.overlaps(this.box);
 
         if (showTooltip) {
-            var box = this.box;
-            var center = box.center();
-            var horizontalAlign = LEFT;
-            var x, y, verticalAlign;
+            const box = this.box;
+            const center = box.center();
+            const horizontalAlign = LEFT;
+            let x, y, verticalAlign;
 
             if (this.options.vertical) {
                 x = center.x;
@@ -129,23 +122,23 @@ var RangeAreaPoint = (function (ChartElement) {
                 }
             };
         }
-    };
+    }
 
-    RangeAreaPoint.prototype.formatValue = function formatValue (format) {
+    formatValue(format) {
         return this.owner.formatPointValue(this, format);
-    };
+    }
 
-    RangeAreaPoint.prototype.overlapsBox = function overlapsBox (box) {
+    overlapsBox(box) {
         return this.box.overlaps(box);
-    };
+    }
 
-    RangeAreaPoint.prototype.unclipElements = function unclipElements () {
+    unclipElements() {
         this.fromPoint.unclipElements();
         this.toPoint.unclipElements();
-    };
+    }
 
-    RangeAreaPoint.prototype.initLabelsFormat = function initLabelsFormat () {
-        var labels = this.options.labels;
+    initLabelsFormat() {
+        const labels = this.options.labels;
         if (!labels.format) {
             if (!labels.from || !labels.from.format) {
                 labels.from = Object.assign({}, labels.from, {
@@ -159,15 +152,13 @@ var RangeAreaPoint = (function (ChartElement) {
                 });
             }
         }
-    };
+    }
 
-    RangeAreaPoint.prototype.positionLabels = function positionLabels (fromBox, toBox) {
-        var ref = this.options;
-        var labels = ref.labels;
-        var vertical = ref.vertical;
+    positionLabels(fromBox, toBox) {
+        const { labels, vertical } = this.options;
 
         if (labels.position === AUTO) {
-            var fromLabelPosition, toLabelPosition;
+            let fromLabelPosition, toLabelPosition;
             if (vertical) {
                 if (toBox.y1 <= fromBox.y1) {
                     toLabelPosition = ABOVE;
@@ -194,30 +185,28 @@ var RangeAreaPoint = (function (ChartElement) {
                 this.toPoint.options.labels.position = toLabelPosition;
             }
         }
-    };
+    }
 
-    RangeAreaPoint.prototype.copyFields = function copyFields (point) {
+    copyFields(point) {
         point.dataItem = this.dataItem;
         point.category = this.category;
         point.series = this.series;
         point.color = this.color;
         point.owner = this.owner;
-    };
+    }
 
-    RangeAreaPoint.prototype.focusVisual = function focusVisual () {
+    focusVisual() {
         this.fromPoint.focusVisual();
-    };
+    }
 
-    RangeAreaPoint.prototype.clearFocusFromVisual = function clearFocusFromVisual () {
+    clearFocusFromVisual() {
         this.toPoint.clearFocusFromVisual();
-    };
+    }
 
-    RangeAreaPoint.prototype.getIndex = function getIndex () {
+    getIndex() {
         return this.categoryIx;
-    };
-
-    return RangeAreaPoint;
-}(ChartElement));
+    }
+}
 
 deepExtend(RangeAreaPoint.prototype, PointEventsMixin);
 deepExtend(RangeAreaPoint.prototype, NoteMixin);

package/dist/es/chart/range-area-chart/range-area-segment.js

@@ -1,52 +1,43 @@
 import { drawing as draw } from '@progress/kendo-drawing';
 import AreaSegment from '../area-chart/area-segment';
 
-var RangeAreaSegment = (function (AreaSegment) {
-    function RangeAreaSegment () {
-        AreaSegment.apply(this, arguments);
-    }
-
-    if ( AreaSegment ) RangeAreaSegment.__proto__ = AreaSegment;
-    RangeAreaSegment.prototype = Object.create( AreaSegment && AreaSegment.prototype );
-    RangeAreaSegment.prototype.constructor = RangeAreaSegment;
+class RangeAreaSegment extends AreaSegment {
 
-    RangeAreaSegment.prototype.createStrokeSegments = function createStrokeSegments () {
+    createStrokeSegments() {
         return this.segmentsFromPoints(this.toGeometryPoints(this.toPoints()));
-    };
+    }
 
-    RangeAreaSegment.prototype.stackSegments = function stackSegments () {
-        var fromSegments = this.fromSegments;
+    stackSegments() {
+        let fromSegments = this.fromSegments;
         if (!this.fromSegments) {
             fromSegments = this.fromSegments = this.segmentsFromPoints(this.toGeometryPoints(this.fromPoints().reverse()));
         }
 
         return fromSegments;
-    };
+    }
 
-    RangeAreaSegment.prototype.createStroke = function createStroke (style) {
-        var toPath = new draw.Path(style);
-        var fromPath = new draw.Path(style);
+    createStroke(style) {
+        const toPath = new draw.Path(style);
+        const fromPath = new draw.Path(style);
 
         toPath.segments.push.apply(toPath.segments, this.strokeSegments());
         fromPath.segments.push.apply(fromPath.segments, this.stackSegments());
 
         this.visual.append(toPath);
         this.visual.append(fromPath);
-    };
+    }
 
-    RangeAreaSegment.prototype.hasStackSegment = function hasStackSegment () {
+    hasStackSegment() {
         return true;
-    };
-
-    RangeAreaSegment.prototype.fromPoints = function fromPoints () {
-        return this.linePoints.map(function (point) { return point.fromPoint; });
-    };
+    }
 
-    RangeAreaSegment.prototype.toPoints = function toPoints () {
-        return this.linePoints.map(function (point) { return point.toPoint; });
-    };
+    fromPoints() {
+        return this.linePoints.map(point => point.fromPoint);
+    }
 
-    return RangeAreaSegment;
-}(AreaSegment));
+    toPoints() {
+        return this.linePoints.map(point => point.toPoint);
+    }
+}
 
 export default RangeAreaSegment;

package/dist/es/chart/range-area-chart/range-line-point.js

@@ -1,19 +1,9 @@
 import LinePoint from '../line-chart/line-point';
 
-var RangeLinePoint = (function (LinePoint) {
-    function RangeLinePoint () {
-        LinePoint.apply(this, arguments);
-    }
-
-    if ( LinePoint ) RangeLinePoint.__proto__ = LinePoint;
-    RangeLinePoint.prototype = Object.create( LinePoint && LinePoint.prototype );
-    RangeLinePoint.prototype.constructor = RangeLinePoint;
-
-    RangeLinePoint.prototype.aliasFor = function aliasFor () {
+class RangeLinePoint extends LinePoint {
+    aliasFor() {
         return this.parent;
-    };
-
-    return RangeLinePoint;
-}(LinePoint));
+    }
+}
 
 export default RangeLinePoint;

package/dist/es/chart/range-area-chart/spline-range-area-segment.js

@@ -2,35 +2,28 @@ import { CurveProcessor } from '../../core';
 
 import RangeAreaSegment from './range-area-segment';
 
-var SplineRangeAreaSegment = (function (RangeAreaSegment) {
-    function SplineRangeAreaSegment () {
-        RangeAreaSegment.apply(this, arguments);
-    }
-
-    if ( RangeAreaSegment ) SplineRangeAreaSegment.__proto__ = RangeAreaSegment;
-    SplineRangeAreaSegment.prototype = Object.create( RangeAreaSegment && RangeAreaSegment.prototype );
-    SplineRangeAreaSegment.prototype.constructor = SplineRangeAreaSegment;
+class SplineRangeAreaSegment extends RangeAreaSegment {
 
-    SplineRangeAreaSegment.prototype.createStrokeSegments = function createStrokeSegments () {
+    createStrokeSegments() {
         return this.createCurveSegments(this.toPoints());
-    };
+    }
 
-    SplineRangeAreaSegment.prototype.stackSegments = function stackSegments () {
-        var fromSegments = this.fromSegments;
+    stackSegments() {
+        let fromSegments = this.fromSegments;
         if (!this.fromSegments) {
             fromSegments = this.fromSegments = this.createCurveSegments(this.fromPoints().reverse());
         }
 
         return fromSegments;
-    };
+    }
 
-    SplineRangeAreaSegment.prototype.createCurveSegments = function createCurveSegments (points) {
-        var curveProcessor = new CurveProcessor();
+    createCurveSegments(points) {
+        const curveProcessor = new CurveProcessor();
 
         return curveProcessor.process(this.toGeometryPoints(points));
-    };
+    }
+
 
-    return SplineRangeAreaSegment;
-}(RangeAreaSegment));
+}
 
 export default SplineRangeAreaSegment;

package/dist/es/chart/range-area-chart/step-range-area-segment.js

@@ -2,31 +2,22 @@ import StepLineMixin from '../line-chart/step-line-mixin';
 import RangeAreaSegment from './range-area-segment';
 import { deepExtend } from '../../common';
 
-var StepRangeAreaSegment = (function (RangeAreaSegment) {
-    function StepRangeAreaSegment () {
-        RangeAreaSegment.apply(this, arguments);
-    }
-
-    if ( RangeAreaSegment ) StepRangeAreaSegment.__proto__ = RangeAreaSegment;
-    StepRangeAreaSegment.prototype = Object.create( RangeAreaSegment && RangeAreaSegment.prototype );
-    StepRangeAreaSegment.prototype.constructor = StepRangeAreaSegment;
+class StepRangeAreaSegment extends RangeAreaSegment {
 
-    StepRangeAreaSegment.prototype.createStrokeSegments = function createStrokeSegments () {
+    createStrokeSegments() {
         return this.segmentsFromPoints(this.calculateStepPoints(this.toPoints()));
-    };
+    }
 
-    StepRangeAreaSegment.prototype.stackSegments = function stackSegments () {
-        var fromSegments = this.fromSegments;
+    stackSegments() {
+        let fromSegments = this.fromSegments;
         if (!this.fromSegments) {
             fromSegments = this.fromSegments = this.segmentsFromPoints(this.calculateStepPoints(this.fromPoints()));
             fromSegments.reverse();
         }
 
         return fromSegments;
-    };
-
-    return StepRangeAreaSegment;
-}(RangeAreaSegment));
+    }
+}
 
 deepExtend(StepRangeAreaSegment.prototype, StepLineMixin);
 

package/dist/es/chart/range-bar-chart/range-bar-chart.js

@@ -5,44 +5,35 @@ import CategoricalChart from '../categorical-chart';
 import { MIN_VALUE, MAX_VALUE } from '../../common/constants';
 import { isNumber } from '../../common';
 
-var RangeBarChart = (function (BarChart) {
-    function RangeBarChart () {
-        BarChart.apply(this, arguments);
-    }
-
-    if ( BarChart ) RangeBarChart.__proto__ = BarChart;
-    RangeBarChart.prototype = Object.create( BarChart && BarChart.prototype );
-    RangeBarChart.prototype.constructor = RangeBarChart;
-
-    RangeBarChart.prototype.pointType = function pointType () {
+class RangeBarChart extends BarChart {
+    pointType() {
         return RangeBar;
-    };
+    }
 
-    RangeBarChart.prototype.pointValue = function pointValue (data) {
+    pointValue(data) {
         return data.valueFields;
-    };
+    }
 
-    RangeBarChart.prototype.formatPointValue = function formatPointValue (point, format) {
+    formatPointValue(point, format) {
         if (point.value.from === null && point.value.to === null) {
             return "";
         }
 
         return this.chartService.format.auto(format, point.value.from, point.value.to);
-    };
+    }
 
-    RangeBarChart.prototype.plotRange = function plotRange (point) {
+    plotRange(point) {
         if (!point) {
             return 0;
         }
 
         return [ point.value.from, point.value.to ];
-    };
+    }
 
-    RangeBarChart.prototype.updateRange = function updateRange (value, fields) {
-        var axisName = fields.series.axis;
-        var from = value.from;
-        var to = value.to;
-        var axisRange = this.valueAxisRanges[axisName];
+    updateRange(value, fields) {
+        const axisName = fields.series.axis;
+        const { from, to } = value;
+        let axisRange = this.valueAxisRanges[axisName];
 
         if (value !== null && isNumber(from) && isNumber(to)) {
             axisRange = this.valueAxisRanges[axisName] = axisRange || { min: MAX_VALUE, max: MIN_VALUE };
@@ -53,15 +44,13 @@ var RangeBarChart = (function (BarChart) {
             axisRange.min = Math.min(axisRange.min, to);
             axisRange.max = Math.max(axisRange.max, to);
         }
-    };
+    }
 
-    RangeBarChart.prototype.aboveAxis = function aboveAxis (point) {
-        var value = point.value;
+    aboveAxis(point) {
+        const value = point.value;
         return value.from < value.to;
-    };
-
-    return RangeBarChart;
-}(BarChart));
+    }
+}
 
 RangeBarChart.prototype.plotLimits = CategoricalChart.prototype.plotLimits;
 

package/dist/es/chart/range-bar-chart/range-bar.js

@@ -2,19 +2,11 @@ import Bar from '../bar-chart/bar';
 
 import { deepExtend } from '../../common';
 
-var RangeBar = (function (Bar) {
-    function RangeBar () {
-        Bar.apply(this, arguments);
-    }
-
-    if ( Bar ) RangeBar.__proto__ = Bar;
-    RangeBar.prototype = Object.create( Bar && Bar.prototype );
-    RangeBar.prototype.constructor = RangeBar;
-
-    RangeBar.prototype.createLabel = function createLabel () {
-        var labels = this.options.labels;
-        var fromOptions = deepExtend({}, labels, labels.from);
-        var toOptions = deepExtend({}, labels, labels.to);
+class RangeBar extends Bar {
+    createLabel() {
+        const labels = this.options.labels;
+        const fromOptions = deepExtend({}, labels, labels.from);
+        const toOptions = deepExtend({}, labels, labels.to);
 
         if (fromOptions.visible) {
             this.labelFrom = this.createLabelElement(fromOptions);
@@ -25,15 +17,12 @@ var RangeBar = (function (Bar) {
             this.labelTo = this.createLabelElement(toOptions);
             this.append(this.labelTo);
         }
-    };
+    }
 
-    RangeBar.prototype.reflow = function reflow (targetBox) {
+    reflow(targetBox) {
         this.render();
 
-        var ref = this;
-        var labelFrom = ref.labelFrom;
-        var labelTo = ref.labelTo;
-        var value = ref.value;
+        const { labelFrom, labelTo, value } = this;
 
         this.box = targetBox;
 
@@ -50,10 +39,8 @@ var RangeBar = (function (Bar) {
         if (this.note) {
             this.note.reflow(targetBox);
         }
-    };
-
-    return RangeBar;
-}(Bar));
+    }
+}
 
 RangeBar.prototype.defaults = deepExtend({}, RangeBar.prototype.defaults, {
     labels: {

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

@@ -18,36 +18,40 @@ import { COLUMN, DONUT, PIE, FUNNEL, PYRAMID, BAR, LINE, VERTICAL_LINE, AREA, VE
     ERROR_LOW_FIELD, ERROR_HIGH_FIELD, HEATMAP, DRILLDOWN_FIELD, TRENDLINE_SERIES, PATTERN_FIELD } from './constants';
 import { X, Y, VALUE } from '../common/constants';
 
-var COLOR = "color";
-var FIRST = "first";
-var FROM = "from";
-var MAX = "max";
-var MIN = "min";
-var NOTE_TEXT = "noteText";
-var SUMMARY_FIELD = "summary";
-var TO = "to";
+const COLOR = "color";
+const FIRST = "first";
+const FROM = "from";
+const MAX = "max";
+const MIN = "min";
+const NOTE_TEXT = "noteText";
+const SUMMARY_FIELD = "summary";
+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 ].concat( TRENDLINE_SERIES
-));
+    RANGE_COLUMN, RANGE_BAR, WATERFALL, HORIZONTAL_WATERFALL, RANGE_AREA, VERTICAL_RANGE_AREA,
+    ...TRENDLINE_SERIES
+]);
 
 PlotAreaFactory.current.register(XYPlotArea, [
-    SCATTER, SCATTER_LINE, BUBBLE ].concat( TRENDLINE_SERIES
-));
+    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 ].concat( TRENDLINE_SERIES
-));
+    POLAR_AREA, POLAR_LINE, POLAR_SCATTER,
+    ...TRENDLINE_SERIES
+]);
 
 PlotAreaFactory.current.register(RadarPlotArea, [
-    RADAR_AREA, RADAR_COLUMN, RADAR_LINE ].concat( TRENDLINE_SERIES
-));
+    RADAR_AREA, RADAR_COLUMN, RADAR_LINE,
+    ...TRENDLINE_SERIES
+]);
 
 PlotAreaFactory.current.register(HeatmapPlotArea, [ HEATMAP ]);