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

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

@@ -8,60 +8,53 @@ import { BAR } from '../constants';
 import { MIN_VALUE, MAX_VALUE } from '../../common/constants';
 import { deepExtend, defined, isArray, isFunction, isObject, setDefaultOptions } from '../../common';
 
-var BulletChart = (function (CategoricalChart) {
-    function BulletChart(plotArea, options) {
+class BulletChart extends CategoricalChart {
+    constructor(plotArea, options) {
 
         wrapData(options);
 
-        CategoricalChart.call(this, plotArea, options);
+        super(plotArea, options);
     }
 
-    if ( CategoricalChart ) BulletChart.__proto__ = CategoricalChart;
-    BulletChart.prototype = Object.create( CategoricalChart && CategoricalChart.prototype );
-    BulletChart.prototype.constructor = BulletChart;
+    reflowCategories(categorySlots) {
+        const children = this.children;
+        const childrenLength = children.length;
 
-    BulletChart.prototype.reflowCategories = function reflowCategories (categorySlots) {
-        var children = this.children;
-        var childrenLength = children.length;
-
-        for (var i = 0; i < childrenLength; i++) {
+        for (let i = 0; i < childrenLength; i++) {
             children[i].reflow(categorySlots[i]);
         }
-    };
+    }
 
-    BulletChart.prototype.plotRange = function plotRange (point) {
-        var series = point.series;
-        var valueAxis = this.seriesValueAxis(series);
-        var axisCrossingValue = this.categoryAxisCrossingValue(valueAxis);
+    plotRange(point) {
+        const series = point.series;
+        const valueAxis = this.seriesValueAxis(series);
+        const axisCrossingValue = this.categoryAxisCrossingValue(valueAxis);
 
         return [ axisCrossingValue, point.value.current || axisCrossingValue ];
-    };
+    }
 
-    BulletChart.prototype.createPoint = function createPoint (data, fields) {
-        var categoryIx = fields.categoryIx;
-        var series = fields.series;
-        var ref = this;
-        var options = ref.options;
-        var children = ref.children;
-        var value = data.valueFields;
+    createPoint(data, fields) {
+        const { categoryIx, series } = fields;
+        const { options, children } = this;
+        const value = data.valueFields;
 
-        var bulletOptions = deepExtend({
+        let bulletOptions = deepExtend({
             vertical: !options.invertAxes,
             overlay: series.overlay,
             categoryIx: categoryIx,
             invertAxes: options.invertAxes
         }, series);
 
-        var color = data.fields.color || series.color;
+        let color = data.fields.color || series.color;
         bulletOptions = this.evalPointOptions(bulletOptions, value, fields);
         if (isFunction(series.color)) {
             color = bulletOptions.color;
         }
 
-        var bullet = new Bullet(value, bulletOptions);
+        const bullet = new Bullet(value, bulletOptions);
         bullet.color = color;
 
-        var cluster = children[categoryIx];
+        let cluster = children[categoryIx];
         if (!cluster) {
             cluster = new ClusterLayout({
                 vertical: options.invertAxes,
@@ -75,13 +68,12 @@ var BulletChart = (function (CategoricalChart) {
         cluster.append(bullet);
 
         return bullet;
-    };
+    }
 
-    BulletChart.prototype.updateRange = function updateRange (value, fields) {
-        var current = value.current;
-        var target = value.target;
-        var axisName = fields.series.axis;
-        var axisRange = this.valueAxisRanges[axisName];
+    updateRange(value, fields) {
+        const { current, target } = value;
+        const axisName = fields.series.axis;
+        let axisRange = this.valueAxisRanges[axisName];
 
         if (defined(current) && !isNaN(current) && defined(target && !isNaN(target))) {
             axisRange = this.valueAxisRanges[axisName] =
@@ -90,38 +82,34 @@ var BulletChart = (function (CategoricalChart) {
             axisRange.min = Math.min(axisRange.min, current, target);
             axisRange.max = Math.max(axisRange.max, current, target);
         }
-    };
+    }
 
-    BulletChart.prototype.formatPointValue = function formatPointValue (point, format) {
+    formatPointValue(point, format) {
         return this.chartService.format.auto(format, point.value.current, point.value.target);
-    };
+    }
 
-    BulletChart.prototype.pointValue = function pointValue (data) {
+    pointValue(data) {
         return data.valueFields.current;
-    };
+    }
 
-    BulletChart.prototype.aboveAxis = function aboveAxis (point) {
-        var value = point.value.current;
+    aboveAxis(point) {
+        const value = point.value.current;
 
         return value > 0;
-    };
-
-    BulletChart.prototype.createAnimation = function createAnimation () {
-        var this$1 = this;
+    }
 
-        var points = this.points;
+    createAnimation() {
+        const points = this.points;
 
         this._setAnimationOptions();
 
-        for (var idx = 0; idx < points.length; idx++) {
-            var point = points[idx];
-            point.options.animation = this$1.options.animation;
+        for (let idx = 0; idx < points.length; idx++) {
+            const point = points[idx];
+            point.options.animation = this.options.animation;
             point.createAnimation();
         }
-    };
-
-    return BulletChart;
-}(CategoricalChart));
+    }
+}
 
 BulletChart.prototype._setAnimationOptions = BarChart.prototype._setAnimationOptions;
 
@@ -132,11 +120,11 @@ setDefaultOptions(BulletChart, {
 });
 
 function wrapData(options) {
-    var series = options.series;
+    const series = options.series;
 
-    for (var i = 0; i < series.length; i++) {
-        var seriesItem = series[i];
-        var data = seriesItem.data;
+    for (let i = 0; i < series.length; i++) {
+        const seriesItem = series[i];
+        const data = seriesItem.data;
         if (data && !isArray(data[0]) && !isObject(data[0])) {
             seriesItem.data = [ data ];
         }

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

@@ -16,21 +16,17 @@ import { CHART_POINT_ROLE_DESCRIPTION, CHART_POINT_CLASSNAME, CHART_POINT_ROLE }
 import AccessibilityAttributesMixin from '../mixins/accessibility-attributes-mixin';
 import { createPatternFill } from '../../core/pattern';
 
-var Bullet = (function (ChartElement) {
-    function Bullet(value, options) {
-        ChartElement.call(this, options);
+class Bullet extends ChartElement {
+    constructor(value, options) {
+        super(options);
 
         this.aboveAxis = this.options.aboveAxis;
         this.color = options.color || WHITE;
         this.value = value;
     }
 
-    if ( ChartElement ) Bullet.__proto__ = ChartElement;
-    Bullet.prototype = Object.create( ChartElement && ChartElement.prototype );
-    Bullet.prototype.constructor = Bullet;
-
-    Bullet.prototype.render = function render () {
-        var options = this.options;
+    render() {
+        const options = this.options;
 
         if (!this._rendered) {
             this._rendered = true;
@@ -56,50 +52,47 @@ var Bullet = (function (ChartElement) {
             this.createLabel();
             this.createNote();
         }
-    };
+    }
 
-    Bullet.prototype.createLabel = function createLabel () {
-        var options = this.options;
-        var labels = options.labels;
+    createLabel() {
+        const options = this.options;
+        const labels = options.labels;
 
         if (labels.visible) {
             this.label = this.createLabelElement(labels);
             this.append(this.label);
         }
-    };
+    }
 
-    Bullet.prototype.createLabelElement = function createLabelElement (options) {
+    createLabelElement(options) {
         return new BarLabel(this.getLabelText(options),
             options,
             this.pointData());
-    };
+    }
 
-    Bullet.prototype.getLabelText = function getLabelText (options) {
-        var labelTemplate = getTemplate(options);
+    getLabelText(options) {
+        let labelTemplate = getTemplate(options);
 
         if (labelTemplate) {
             return labelTemplate(this.pointData());
         }
 
         return this.formatValue(options.format);
-    };
+    }
 
-    Bullet.prototype.reflow = function reflow (box) {
+    reflow(box) {
         this.render();
 
-        var ref = this;
-        var options = ref.options;
-        var target = ref.target;
-        var chart = ref.owner;
-        var invertAxes = options.invertAxes;
-        var valueAxis = chart.seriesValueAxis(this.options);
-        var categorySlot = chart.categorySlot(chart.categoryAxis, options.categoryIx, valueAxis);
-        var targetValueSlot = valueAxis.getSlot(this.value.target);
-        var targetSlotX = invertAxes ? targetValueSlot : categorySlot;
-        var targetSlotY = invertAxes ? categorySlot : targetValueSlot;
+        const { options, target, owner: chart } = this;
+        const invertAxes = options.invertAxes;
+        const valueAxis = chart.seriesValueAxis(this.options);
+        const categorySlot = chart.categorySlot(chart.categoryAxis, options.categoryIx, valueAxis);
+        const targetValueSlot = valueAxis.getSlot(this.value.target);
+        const targetSlotX = invertAxes ? targetValueSlot : categorySlot;
+        const targetSlotY = invertAxes ? categorySlot : targetValueSlot;
 
         if (target) {
-            var targetSlot = new Box(
+            const targetSlot = new Box(
                 targetSlotX.x1, targetSlotY.y1,
                 targetSlotX.x2, targetSlotY.y2
             );
@@ -108,7 +101,7 @@ var Bullet = (function (ChartElement) {
             target.reflow(targetSlot);
         }
 
-        var label = this.label;
+        const label = this.label;
         if (label) {
             label.options.aboveAxis = this.aboveAxis;
             label.reflow(box);
@@ -119,15 +112,15 @@ var Bullet = (function (ChartElement) {
         }
 
         this.box = box;
-    };
+    }
 
-    Bullet.prototype.createVisual = function createVisual () {
-        ChartElement.prototype.createVisual.call(this);
+    createVisual() {
+        super.createVisual();
 
         this.addAccessibilityAttributesToVisual();
 
-        var options = this.options;
-        var body = draw.Path.fromRect(this.box.toRect(), {
+        const options = this.options;
+        const body = draw.Path.fromRect(this.box.toRect(), {
             fill: createPatternFill(options.pattern, {
                 color: this.color,
                 opacity: options.opacity
@@ -148,55 +141,53 @@ var Bullet = (function (ChartElement) {
 
         alignPathToPixel(body);
         this.visual.append(body);
-    };
+    }
 
-    Bullet.prototype.createAnimation = function createAnimation () {
+    createAnimation() {
         if (this.bodyVisual) {
             this.animation = draw.Animation.create(
                 this.bodyVisual, this.options.animation
             );
         }
-    };
+    }
 
-    Bullet.prototype.createHighlight = function createHighlight (style) {
+    createHighlight(style) {
         return draw.Path.fromRect(this.box.toRect(), style);
-    };
+    }
 
-    Bullet.prototype.highlightVisual = function highlightVisual () {
+    highlightVisual() {
         return this.bodyVisual;
-    };
+    }
 
-    Bullet.prototype.highlightVisualArgs = function highlightVisualArgs () {
+    highlightVisualArgs() {
         return {
             rect: this.box.toRect(),
             visual: this.bodyVisual,
             options: this.options
         };
-    };
+    }
 
-    Bullet.prototype.formatValue = function formatValue (format) {
+    formatValue(format) {
         return this.owner.formatPointValue(this, format);
-    };
+    }
 
-    Bullet.prototype.pointData = function pointData () {
+    pointData() {
         return {
             dataItem: this.dataItem,
             category: this.category,
             value: this.value,
             series: this.series
         };
-    };
+    }
 
-    Bullet.prototype.overlapsBox = function overlapsBox (box) {
+    overlapsBox(box) {
         return this.box.overlaps(box);
-    };
+    }
 
-    Bullet.prototype.getIndex = function getIndex () {
+    getIndex() {
         return this.categoryIx;
-    };
-
-    return Bullet;
-}(ChartElement));
+    }
+}
 
 Bullet.prototype.tooltipAnchor = Bar.prototype.tooltipAnchor;
 Bullet.prototype.createFocusHighlight = Bar.prototype.createFocusHighlight;

package/dist/es/chart/bullet-chart/target.js

@@ -2,17 +2,7 @@ import { ShapeElement } from '../../core';
 import { deepExtend } from '../../common';
 import PointEventsMixin from '../mixins/point-events-mixin';
 
-var Target = (function (ShapeElement) {
-	function Target () {
-		ShapeElement.apply(this, arguments);
-	}if ( ShapeElement ) Target.__proto__ = ShapeElement;
-	Target.prototype = Object.create( ShapeElement && ShapeElement.prototype );
-	Target.prototype.constructor = Target;
-
-	
-
-	return Target;
-}(ShapeElement));
+class Target extends ShapeElement { }
 
 deepExtend(Target.prototype, PointEventsMixin);
 

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

@@ -9,38 +9,26 @@ import areNumbers from '../utils/are-numbers';
 import { MIN_VALUE, MAX_VALUE } from '../../common/constants';
 import { deepExtend, isFunction } from '../../common';
 
-var CandlestickChart = (function (CategoricalChart) {
-    function CandlestickChart () {
-        CategoricalChart.apply(this, arguments);
-    }
-
-    if ( CategoricalChart ) CandlestickChart.__proto__ = CategoricalChart;
-    CandlestickChart.prototype = Object.create( CategoricalChart && CategoricalChart.prototype );
-    CandlestickChart.prototype.constructor = CandlestickChart;
+class CandlestickChart extends CategoricalChart {
 
-    CandlestickChart.prototype.reflowCategories = function reflowCategories (categorySlots) {
-        var children = this.children;
-        var childrenLength = children.length;
+    reflowCategories(categorySlots) {
+        const children = this.children;
+        const childrenLength = children.length;
 
-        for (var i = 0; i < childrenLength; i++) {
+        for (let i = 0; i < childrenLength; i++) {
             children[i].reflow(categorySlots[i]);
         }
-    };
-
-    CandlestickChart.prototype.addValue = function addValue (data, fields) {
-        var categoryIx = fields.categoryIx;
-        var category = fields.category;
-        var series = fields.series;
-        var seriesIx = fields.seriesIx;
-        var ref = this;
-        var children = ref.children;
-        var options = ref.options;
-        var value = data.valueFields;
-        var valueParts = this.splitValue(value);
-        var hasValue = areNumbers(valueParts);
-        var dataItem = series.data[categoryIx];
-        var categoryPoints = this.categoryPoints[categoryIx];
-        var point;
+    }
+
+    addValue(data, fields) {
+        const { categoryIx, category, series, seriesIx } = fields;
+        const { children, options } = this;
+        const value = data.valueFields;
+        const valueParts = this.splitValue(value);
+        const hasValue = areNumbers(valueParts);
+        const dataItem = series.data[categoryIx];
+        let categoryPoints = this.categoryPoints[categoryIx];
+        let point;
 
         if (!categoryPoints) {
             this.categoryPoints[categoryIx] = categoryPoints = [];
@@ -50,7 +38,7 @@ var CandlestickChart = (function (CategoricalChart) {
             point = this.createPoint(data, fields);
         }
 
-        var cluster = children[categoryIx];
+        let cluster = children[categoryIx];
         if (!cluster) {
             cluster = new ClusterLayout({
                 vertical: options.invertAxes,
@@ -77,18 +65,18 @@ var CandlestickChart = (function (CategoricalChart) {
 
         this.points.push(point);
         categoryPoints.push(point);
-    };
+    }
 
-    CandlestickChart.prototype.pointType = function pointType () {
+    pointType() {
         return Candlestick;
-    };
+    }
 
-    CandlestickChart.prototype.createPoint = function createPoint (data, fields) {
-        var series = fields.series;
-        var pointType = this.pointType();
-        var value = data.valueFields;
-        var pointOptions = deepExtend({}, series);
-        var color = data.fields.color || series.color;
+    createPoint(data, fields) {
+        const { series } = fields;
+        const pointType = this.pointType();
+        const value = data.valueFields;
+        let pointOptions = deepExtend({}, series);
+        let color = data.fields.color || series.color;
 
         pointOptions = this.evalPointOptions(pointOptions, value, fields);
 
@@ -104,42 +92,40 @@ var CandlestickChart = (function (CategoricalChart) {
 
         pointOptions.vertical = !this.options.invertAxes;
 
-        var point = new pointType(value, pointOptions);
+        const point = new pointType(value, pointOptions);
         point.color = color;
 
         return point;
-    };
+    }
 
-    CandlestickChart.prototype.splitValue = function splitValue (value) {
+    splitValue(value) {
         return [ value.low, value.open, value.close, value.high ];
-    };
+    }
 
-    CandlestickChart.prototype.updateRange = function updateRange (value, fields) {
-        var axisName = fields.series.axis;
-        var parts = this.splitValue(value);
-        var axisRange = this.valueAxisRanges[axisName] || { min: MAX_VALUE, max: MIN_VALUE };
+    updateRange(value, fields) {
+        const axisName = fields.series.axis;
+        const parts = this.splitValue(value);
+        let axisRange = this.valueAxisRanges[axisName] || { min: MAX_VALUE, max: MIN_VALUE };
 
         this.valueAxisRanges[axisName] = {
             min: Math.min.apply(Math, parts.concat([ axisRange.min ])),
             max: Math.max.apply(Math, parts.concat([ axisRange.max ]))
         };
-    };
+    }
 
-    CandlestickChart.prototype.formatPointValue = function formatPointValue (point, format) {
-        var value = point.value;
+    formatPointValue(point, format) {
+        const value = point.value;
 
         return this.chartService.format.auto(format,
             value.open, value.high,
             value.low, value.close, point.category
         );
-    };
+    }
 
-    CandlestickChart.prototype.animationPoints = function animationPoints () {
+    animationPoints() {
         return this.points;
-    };
-
-    return CandlestickChart;
-}(CategoricalChart));
+    }
+}
 
 deepExtend(CandlestickChart.prototype, ClipAnimationMixin);