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

package/dist/es/core/polar-axis.js

@@ -10,113 +10,99 @@ import Box from './box';
 import { BLACK } from '../common/constants';
 import { deepExtend, deg, getSpacing, inArray, limitValue, setDefaultOptions } from '../common';
 
-var PolarAxis = (function (Axis) {
-    function PolarAxis(options, chartService) {
-        Axis.call(this, options, chartService);
+class PolarAxis extends Axis {
+    constructor(options, chartService) {
+        super(options, chartService);
 
-        var instanceOptions = this.options;
+        const instanceOptions = this.options;
 
         instanceOptions.minorUnit = instanceOptions.minorUnit || instanceOptions.majorUnit / 2;
     }
 
-    if ( Axis ) PolarAxis.__proto__ = Axis;
-    PolarAxis.prototype = Object.create( Axis && Axis.prototype );
-    PolarAxis.prototype.constructor = PolarAxis;
-
-    PolarAxis.prototype.getDivisions = function getDivisions (stepValue) {
+    getDivisions(stepValue) {
         return NumericAxis.prototype.getDivisions.call(this, stepValue) - 1;
-    };
+    }
 
-    PolarAxis.prototype.reflow = function reflow (box) {
+    reflow(box) {
         this.box = box;
         this.reflowLabels();
-    };
-
-    PolarAxis.prototype.reflowLabels = function reflowLabels () {
-        var this$1 = this;
+    }
 
-        var ref = this;
-        var options = ref.options;
-        var labels = ref.labels;
-        var labelOptions = ref.options.labels;
-        var skip = labelOptions.skip || 0;
-        var step = labelOptions.step || 1;
+    reflowLabels() {
+        const { options, labels, options: { labels: labelOptions } } = this;
+        const skip = labelOptions.skip || 0;
+        const step = labelOptions.step || 1;
 
-        var measureBox = new Box();
-        var divs = this.intervals(options.majorUnit, skip, step);
+        const measureBox = new Box();
+        const divs = this.intervals(options.majorUnit, skip, step);
 
-        for (var i = 0; i < labels.length; i++) {
+        for (let i = 0; i < labels.length; i++) {
             labels[i].reflow(measureBox);
-            var labelBox = labels[i].box;
+            const labelBox = labels[i].box;
 
-            labels[i].reflow(this$1.getSlot(divs[i]).adjacentBox(0, labelBox.width(), labelBox.height()));
+            labels[i].reflow(this.getSlot(divs[i]).adjacentBox(0, labelBox.width(), labelBox.height()));
         }
-    };
+    }
 
-    PolarAxis.prototype.lineBox = function lineBox () {
+    lineBox() {
         return this.box;
-    };
-
-    PolarAxis.prototype.intervals = function intervals (size, skipOption, stepOption, skipAngles) {
-        if ( skipAngles === void 0 ) skipAngles = false;
+    }
 
-        var min = this.options.min;
-        var divisions = this.getDivisions(size);
-        var divs = [];
-        var skip = skipOption || 0;
-        var step = stepOption || 1;
+    intervals(size, skipOption, stepOption, skipAngles = false) {
+        const min = this.options.min;
+        const divisions = this.getDivisions(size);
+        const divs = [];
+        const skip = skipOption || 0;
+        const step = stepOption || 1;
 
-        for (var i = skip; i < divisions; i += step) {
-            var current = (360 + min + i * size) % 360;
+        for (let i = skip; i < divisions; i += step) {
+            const current = (360 + min + i * size) % 360;
             if (!(skipAngles && inArray(current, skipAngles))) {
                 divs.push(current);
             }
         }
 
         return divs;
-    };
+    }
 
-    PolarAxis.prototype.majorIntervals = function majorIntervals () {
+    majorIntervals() {
         return this.intervals(this.options.majorUnit);
-    };
+    }
 
-    PolarAxis.prototype.minorIntervals = function minorIntervals () {
+    minorIntervals() {
         return this.intervals(this.options.minorUnit);
-    };
+    }
 
-    PolarAxis.prototype.intervalAngle = function intervalAngle (i) {
+    intervalAngle(i) {
         return (540 - i - this.options.startAngle) % 360;
-    };
+    }
 
-    PolarAxis.prototype.createLine = function createLine () {
+    createLine() {
         return [];
-    };
+    }
 
-    PolarAxis.prototype.majorGridLineAngles = function majorGridLineAngles (altAxis) {
-        var majorGridLines = this.options.majorGridLines;
+    majorGridLineAngles(altAxis) {
+        const majorGridLines = this.options.majorGridLines;
         return this.gridLineAngles(altAxis, this.options.majorUnit, majorGridLines.skip, majorGridLines.step);
-    };
+    }
 
-    PolarAxis.prototype.minorGridLineAngles = function minorGridLineAngles (altAxis, skipMajor) {
-        var options = this.options;
-        var minorGridLines = options.minorGridLines;
-        var majorGridLines = options.majorGridLines;
-        var majorGridLineAngles = skipMajor ? this.intervals(options.majorUnit, majorGridLines.skip, majorGridLines.step) : null;
+    minorGridLineAngles(altAxis, skipMajor) {
+        const options = this.options;
+        const { minorGridLines, majorGridLines } = options;
+        const majorGridLineAngles = skipMajor ? this.intervals(options.majorUnit, majorGridLines.skip, majorGridLines.step) : null;
 
         return this.gridLineAngles(altAxis, options.minorUnit, minorGridLines.skip, minorGridLines.step, majorGridLineAngles);
-    };
+    }
 
-    PolarAxis.prototype.plotBandSlot = function plotBandSlot (band) {
+    plotBandSlot(band) {
         return this.getSlot(band.from, band.to);
-    };
+    }
 
-    PolarAxis.prototype.getSlot = function getSlot (a, b) {
-        var ref = this;
-        var options = ref.options;
-        var box = ref.box;
-        var startAngle = options.startAngle;
-        var start = limitValue(a, options.min, options.max);
-        var end = limitValue(b || start, start, options.max);
+    getSlot(a, b) {
+        const { options, box } = this;
+        const startAngle = options.startAngle;
+        let start = limitValue(a, options.min, options.max);
+        let end = limitValue(b || start, start, options.max);
 
         if (options.reverse) {
             start *= -1;
@@ -127,23 +113,21 @@ var PolarAxis = (function (Axis) {
         end = (540 - end - startAngle) % 360;
 
         if (end < start) {
-            var tmp = start;
+            const tmp = start;
             start = end;
             end = tmp;
         }
 
         return new Ring(box.center(), 0, box.height() / 2, start, end - start);
-    };
-
-    PolarAxis.prototype.slot = function slot (from, to) {
-        if ( to === void 0 ) to = from;
+    }
 
-        var options = this.options;
-        var start = 360 - options.startAngle;
-        var slot = this.getSlot(from, to);
-        var min = Math.min(from, to);
-        var max = Math.max(from, to);
-        var startAngle, endAngle;
+    slot(from, to = from) {
+        const options = this.options;
+        const start = 360 - options.startAngle;
+        const slot = this.getSlot(from, to);
+        const min = Math.min(from, to);
+        const max = Math.max(from, to);
+        let startAngle, endAngle;
 
         if (options.reverse) {
             startAngle = min;
@@ -162,15 +146,15 @@ var PolarAxis = (function (Axis) {
             radiusX: slot.radius,
             radiusY: slot.radius
         });
-    };
+    }
 
-    PolarAxis.prototype.getValue = function getValue (point) {
-        var options = this.options;
-        var center = this.box.center();
-        var dx = point.x - center.x;
-        var dy = point.y - center.y;
-        var theta = Math.round(deg(Math.atan2(dy, dx)));
-        var start = options.startAngle;
+    getValue(point) {
+        const options = this.options;
+        const center = this.box.center();
+        const dx = point.x - center.x;
+        const dy = point.y - center.y;
+        let theta = Math.round(deg(Math.atan2(dy, dx)));
+        let start = options.startAngle;
 
         if (!options.reverse) {
             theta *= -1;
@@ -178,17 +162,15 @@ var PolarAxis = (function (Axis) {
         }
 
         return (theta + start + 360) % 360;
-    };
+    }
 
-    PolarAxis.prototype.valueRange = function valueRange () {
+    valueRange() {
         return {
             min: 0,
             max: Math.PI * 2
         };
-    };
-
-    return PolarAxis;
-}(Axis));
+    }
+}
 
 setDefaultOptions(PolarAxis, {
     type: "polar",

package/dist/es/core/radar-category-axis.js

@@ -9,61 +9,47 @@ import Box from './box';
 import { COORD_PRECISION, ARC } from '../common/constants';
 import { deepExtend, getSpacing, inArray, limitValue, map, rad, round, setDefaultOptions } from '../common';
 
-var RadarCategoryAxis = (function (CategoryAxis) {
-    function RadarCategoryAxis () {
-        CategoryAxis.apply(this, arguments);
-    }
-
-    if ( CategoryAxis ) RadarCategoryAxis.__proto__ = CategoryAxis;
-    RadarCategoryAxis.prototype = Object.create( CategoryAxis && CategoryAxis.prototype );
-    RadarCategoryAxis.prototype.constructor = RadarCategoryAxis;
-
-    RadarCategoryAxis.prototype.range = function range () {
+class RadarCategoryAxis extends CategoryAxis {
+    range() {
         return { min: 0, max: this.options.categories.length };
-    };
+    }
 
-    RadarCategoryAxis.prototype.reflow = function reflow (box) {
+    reflow(box) {
         this.box = box;
         this.reflowLabels();
-    };
+    }
 
-    RadarCategoryAxis.prototype.lineBox = function lineBox () {
+    lineBox() {
         return this.box;
-    };
-
-    RadarCategoryAxis.prototype.reflowLabels = function reflowLabels () {
-        var this$1 = this;
+    }
 
-        var ref = this;
-        var labels = ref.labels;
-        var labelOptions = ref.options.labels;
-        var skip = labelOptions.skip || 0;
-        var step = labelOptions.step || 1;
-        var measureBox = new Box();
+    reflowLabels() {
+        const { labels, options: { labels: labelOptions } } = this;
+        const skip = labelOptions.skip || 0;
+        const step = labelOptions.step || 1;
+        const measureBox = new Box();
 
-        for (var i = 0; i < labels.length; i++) {
+        for (let i = 0; i < labels.length; i++) {
             labels[i].reflow(measureBox);
-            var labelBox = labels[i].box;
+            const labelBox = labels[i].box;
 
-            labels[i].reflow(this$1.getSlot(skip + i * step).adjacentBox(
+            labels[i].reflow(this.getSlot(skip + i * step).adjacentBox(
                 0, labelBox.width(), labelBox.height()
             ));
         }
-    };
-
-    RadarCategoryAxis.prototype.intervals = function intervals (size, skipOption, stepOption, skipAngles) {
-        if ( skipAngles === void 0 ) skipAngles = false;
-
-        var options = this.options;
-        var categories = options.categories.length;
-        var divCount = categories / size || 1;
-        var divAngle = 360 / divCount;
-        var skip = skipOption || 0;
-        var step = stepOption || 1;
-        var divs = [];
-        var angle = 0;
+    }
 
-        for (var i = skip; i < divCount; i += step) {
+    intervals(size, skipOption, stepOption, skipAngles = false) {
+        const options = this.options;
+        const categories = options.categories.length;
+        const divCount = categories / size || 1;
+        const divAngle = 360 / divCount;
+        const skip = skipOption || 0;
+        const step = stepOption || 1;
+        const divs = [];
+        let angle = 0;
+
+        for (let i = skip; i < divCount; i += step) {
             if (options.reverse) {
                 angle = 360 - i * divAngle;
             } else {
@@ -78,51 +64,47 @@ var RadarCategoryAxis = (function (CategoryAxis) {
         }
 
         return divs;
-    };
+    }
 
-    RadarCategoryAxis.prototype.majorIntervals = function majorIntervals () {
+    majorIntervals() {
         return this.intervals(1);
-    };
+    }
 
-    RadarCategoryAxis.prototype.minorIntervals = function minorIntervals () {
+    minorIntervals() {
         return this.intervals(0.5);
-    };
+    }
 
-    RadarCategoryAxis.prototype.intervalAngle = function intervalAngle (interval) {
+    intervalAngle(interval) {
         return (360 + interval + this.options.startAngle) % 360;
-    };
-
-    RadarCategoryAxis.prototype.majorAngles = function majorAngles () {
-        var this$1 = this;
+    }
 
-        return map(this.majorIntervals(), function (interval) { return this$1.intervalAngle(interval); });
-    };
+    majorAngles() {
+        return map(this.majorIntervals(), (interval) => this.intervalAngle(interval));
+    }
 
-    RadarCategoryAxis.prototype.createLine = function createLine () {
+    createLine() {
         return [];
-    };
+    }
 
-    RadarCategoryAxis.prototype.majorGridLineAngles = function majorGridLineAngles (altAxis) {
-        var majorGridLines = this.options.majorGridLines;
+    majorGridLineAngles(altAxis) {
+        const majorGridLines = this.options.majorGridLines;
         return this.gridLineAngles(altAxis, 1, majorGridLines.skip, majorGridLines.step);
-    };
+    }
 
-    RadarCategoryAxis.prototype.minorGridLineAngles = function minorGridLineAngles (altAxis, skipMajor) {
-        var ref = this.options;
-        var minorGridLines = ref.minorGridLines;
-        var majorGridLines = ref.majorGridLines;
-        var majorGridLineAngles = skipMajor ? this.intervals(1, majorGridLines.skip, majorGridLines.step) : null;
+    minorGridLineAngles(altAxis, skipMajor) {
+        const { minorGridLines, majorGridLines } = this.options;
+        const majorGridLineAngles = skipMajor ? this.intervals(1, majorGridLines.skip, majorGridLines.step) : null;
 
         return this.gridLineAngles(altAxis, 0.5, minorGridLines.skip, minorGridLines.step, majorGridLineAngles);
-    };
+    }
 
-    RadarCategoryAxis.prototype.radiusCallback = function radiusCallback (radius, altAxis, skipMajor) {
+    radiusCallback(radius, altAxis, skipMajor) {
         if (altAxis.options.type !== ARC) {
-            var minorAngle = rad(360 / (this.options.categories.length * 2));
-            var minorRadius = Math.cos(minorAngle) * radius;
-            var majorAngles = this.majorAngles();
+            const minorAngle = rad(360 / (this.options.categories.length * 2));
+            const minorRadius = Math.cos(minorAngle) * radius;
+            const majorAngles = this.majorAngles();
 
-            var radiusCallback = function(angle) {
+            const radiusCallback = function(angle) {
                 if (!skipMajor && inArray(angle, majorAngles)) {
                     return radius;
                 }
@@ -131,29 +113,27 @@ var RadarCategoryAxis = (function (CategoryAxis) {
             };
             return radiusCallback;
         }
-    };
-
-    RadarCategoryAxis.prototype.createPlotBands = function createPlotBands () {
-        var this$1 = this;
+    }
 
-        var plotBands = this.options.plotBands || [];
+    createPlotBands() {
+        const plotBands = this.options.plotBands || [];
 
-        var group = this._plotbandGroup = new draw.Group({
+        const group = this._plotbandGroup = new draw.Group({
             zIndex: -1
         });
 
-        for (var i = 0; i < plotBands.length; i++) {
-            var band = plotBands[i];
-            var slot = this$1.plotBandSlot(band);
-            var singleSlot = this$1.getSlot(band.from);
+        for (let i = 0; i < plotBands.length; i++) {
+            const band = plotBands[i];
+            const slot = this.plotBandSlot(band);
+            const singleSlot = this.getSlot(band.from);
 
-            var head = band.from - Math.floor(band.from);
+            const head = band.from - Math.floor(band.from);
             slot.startAngle += head * singleSlot.angle;
 
-            var tail = Math.ceil(band.to) - band.to;
+            const tail = Math.ceil(band.to) - band.to;
             slot.angle -= (tail + head) * singleSlot.angle;
 
-            var ring = ShapeBuilder.current.createRing(slot, {
+            const ring = ShapeBuilder.current.createRing(slot, {
                 fill: {
                     color: band.color,
                     opacity: band.opacity
@@ -166,27 +146,27 @@ var RadarCategoryAxis = (function (CategoryAxis) {
         }
 
         this.appendVisual(group);
-    };
+    }
 
-    RadarCategoryAxis.prototype.plotBandSlot = function plotBandSlot (band) {
+    plotBandSlot(band) {
         return this.getSlot(band.from, band.to - 1);
-    };
+    }
 
-    RadarCategoryAxis.prototype.getSlot = function getSlot (from, to) {
-        var options = this.options;
-        var justified = options.justified;
-        var box = this.box;
-        var divs = this.majorAngles();
-        var totalDivs = divs.length;
-        var slotAngle = 360 / totalDivs;
-        var fromValue = from;
+    getSlot(from, to) {
+        const options = this.options;
+        const justified = options.justified;
+        const box = this.box;
+        const divs = this.majorAngles();
+        const totalDivs = divs.length;
+        const slotAngle = 360 / totalDivs;
+        let fromValue = from;
 
         if (options.reverse && !justified) {
             fromValue = (fromValue + 1) % totalDivs;
         }
 
         fromValue = limitValue(Math.floor(fromValue), 0, totalDivs - 1);
-        var slotStart = divs[fromValue];
+        let slotStart = divs[fromValue];
 
         if (justified) {
             slotStart = slotStart - slotAngle / 2;
@@ -196,17 +176,17 @@ var RadarCategoryAxis = (function (CategoryAxis) {
             }
         }
 
-        var toValue = limitValue(Math.ceil(to || fromValue), fromValue, totalDivs - 1);
-        var slots = toValue - fromValue + 1;
-        var angle = slotAngle * slots;
+        const toValue = limitValue(Math.ceil(to || fromValue), fromValue, totalDivs - 1);
+        const slots = toValue - fromValue + 1;
+        const angle = slotAngle * slots;
 
         return new Ring(box.center(), 0, box.height() / 2, slotStart, angle);
-    };
+    }
 
-    RadarCategoryAxis.prototype.slot = function slot (from, to) {
-        var slot = this.getSlot(from, to);
-        var startAngle = slot.startAngle + 180;
-        var endAngle = startAngle + slot.angle;
+    slot(from, to) {
+        const slot = this.getSlot(from, to);
+        const startAngle = slot.startAngle + 180;
+        const endAngle = startAngle + slot.angle;
 
         return new geom.Arc([ slot.center.x, slot.center.y ], {
             startAngle: startAngle,
@@ -214,16 +194,14 @@ var RadarCategoryAxis = (function (CategoryAxis) {
             radiusX: slot.radius,
             radiusY: slot.radius
         });
-    };
-
-    RadarCategoryAxis.prototype.pointCategoryIndex = function pointCategoryIndex (point) {
-        var this$1 = this;
+    }
 
-        var length = this.options.categories.length;
-        var index = null;
+    pointCategoryIndex(point) {
+        const length = this.options.categories.length;
+        let index = null;
 
-        for (var i = 0; i < length; i++) {
-            var slot = this$1.getSlot(i);
+        for (let i = 0; i < length; i++) {
+            const slot = this.getSlot(i);
             if (slot.containsPoint(point)) {
                 index = i;
                 break;
@@ -231,10 +209,8 @@ var RadarCategoryAxis = (function (CategoryAxis) {
         }
 
         return index;
-    };
-
-    return RadarCategoryAxis;
-}(CategoryAxis));
+    }
+}
 
 setDefaultOptions(RadarCategoryAxis, {
     startAngle: 90,

package/dist/es/core/radar-logarithmic-axis.js

@@ -3,41 +3,31 @@ import RadarNumericAxisMixin from './mixins/radar-numeric-axis-mixin';
 
 import { deepExtend } from '../common';
 
-var RadarLogarithmicAxis = (function (LogarithmicAxis) {
-    function RadarLogarithmicAxis () {
-        LogarithmicAxis.apply(this, arguments);
-    }
-
-    if ( LogarithmicAxis ) RadarLogarithmicAxis.__proto__ = LogarithmicAxis;
-    RadarLogarithmicAxis.prototype = Object.create( LogarithmicAxis && LogarithmicAxis.prototype );
-    RadarLogarithmicAxis.prototype.constructor = RadarLogarithmicAxis;
-
-    RadarLogarithmicAxis.prototype.radarMajorGridLinePositions = function radarMajorGridLinePositions () {
-        var positions = [];
+class RadarLogarithmicAxis extends LogarithmicAxis {
+    radarMajorGridLinePositions() {
+        const positions = [];
 
         this.traverseMajorTicksPositions(function(position) {
             positions.push(position);
         }, this.options.majorGridLines);
 
         return positions;
-    };
+    }
 
-    RadarLogarithmicAxis.prototype.radarMinorGridLinePositions = function radarMinorGridLinePositions () {
-        var positions = [];
+    radarMinorGridLinePositions() {
+        const positions = [];
 
         this.traverseMinorTicksPositions(function(position) {
             positions.push(position);
         }, this.options.minorGridLines);
 
         return positions;
-    };
+    }
 
-    RadarLogarithmicAxis.prototype.axisType = function axisType () {
+    axisType() {
         return LogarithmicAxis;
-    };
-
-    return RadarLogarithmicAxis;
-}(LogarithmicAxis));
+    }
+}
 
 deepExtend(RadarLogarithmicAxis.prototype, RadarNumericAxisMixin);
 

package/dist/es/core/radar-numeric-axis.js

@@ -3,35 +3,25 @@ import RadarNumericAxisMixin from './mixins/radar-numeric-axis-mixin';
 
 import { deepExtend } from '../common';
 
-var RadarNumericAxis = (function (NumericAxis) {
-    function RadarNumericAxis () {
-        NumericAxis.apply(this, arguments);
-    }
-
-    if ( NumericAxis ) RadarNumericAxis.__proto__ = NumericAxis;
-    RadarNumericAxis.prototype = Object.create( NumericAxis && NumericAxis.prototype );
-    RadarNumericAxis.prototype.constructor = RadarNumericAxis;
-
-    RadarNumericAxis.prototype.radarMajorGridLinePositions = function radarMajorGridLinePositions () {
+class RadarNumericAxis extends NumericAxis {
+    radarMajorGridLinePositions() {
         return this.getTickPositions(this.options.majorUnit);
-    };
+    }
 
-    RadarNumericAxis.prototype.radarMinorGridLinePositions = function radarMinorGridLinePositions () {
-        var options = this.options;
-        var minorSkipStep = 0;
+    radarMinorGridLinePositions() {
+        const options = this.options;
+        let minorSkipStep = 0;
 
         if (options.majorGridLines.visible) {
             minorSkipStep = options.majorUnit;
         }
         return this.getTickPositions(options.minorUnit, minorSkipStep);
-    };
+    }
 
-    RadarNumericAxis.prototype.axisType = function axisType () {
+    axisType() {
         return NumericAxis;
-    };
-
-    return RadarNumericAxis;
-}(NumericAxis));
+    }
+}
 
 deepExtend(RadarNumericAxis.prototype, RadarNumericAxisMixin);