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

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

@@ -10,11 +10,11 @@ import { bindSegments, evalOptions } from '../utils';
 import { CIRCLE, RIGHT, CENTER } from '../../common/constants';
 import { deepExtend, defined, find, isFunction, last, round, setDefaultOptions, valueOrDefault } from '../../common';
 
-var PIE_SECTOR_ANIM_DELAY = 70;
+const PIE_SECTOR_ANIM_DELAY = 70;
 
-var PieChart = (function (ChartElement) {
-    function PieChart(plotArea, options) {
-        ChartElement.call(this, options);
+class PieChart extends ChartElement {
+    constructor(plotArea, options) {
+        super(options);
 
         this.plotArea = plotArea;
         this.chartService = plotArea.chartService;
@@ -23,37 +23,26 @@ var PieChart = (function (ChartElement) {
         this.render();
     }
 
-    if ( ChartElement ) PieChart.__proto__ = ChartElement;
-    PieChart.prototype = Object.create( ChartElement && ChartElement.prototype );
-    PieChart.prototype.constructor = PieChart;
-
-    PieChart.prototype.render = function render () {
+    render() {
         this.traverseDataPoints(this.addValue.bind(this));
-    };
-
-    PieChart.prototype.traverseDataPoints = function traverseDataPoints (callback) {
-        var this$1 = this;
-
-        var ref = this;
-        var options = ref.options;
-        var seriesColors = ref.plotArea.options.seriesColors; if ( seriesColors === void 0 ) seriesColors = [];
-        var colorsCount = seriesColors.length;
-        var series = options.series;
-        var seriesCount = series.length;
-
-        for (var seriesIx = 0; seriesIx < seriesCount; seriesIx++) {
-            var currentSeries = series[seriesIx];
-            var data = currentSeries.data;
-            var ref$1 = bindSegments(currentSeries);
-            var total = ref$1.total;
-            var points = ref$1.points;
-            var count = ref$1.count;
-            var anglePerValue = 360 / total;
-            var constantAngle = (void 0);
+    }
+
+    traverseDataPoints(callback) {
+        const { options, plotArea: { options: { seriesColors = [] } } } = this;
+        const colorsCount = seriesColors.length;
+        const series = options.series;
+        const seriesCount = series.length;
+
+        for (let seriesIx = 0; seriesIx < seriesCount; seriesIx++) {
+            const currentSeries = series[seriesIx];
+            const data = currentSeries.data;
+            const { total, points, count } = bindSegments(currentSeries);
+            const anglePerValue = 360 / total;
+            let constantAngle;
             if (!isFinite(anglePerValue)) {
                 constantAngle = 360 / count;
             }
-            var currentAngle = (void 0);
+            let currentAngle;
 
             if (defined(currentSeries.startAngle)) {
                 currentAngle = currentSeries.startAngle;
@@ -67,24 +56,22 @@ var PieChart = (function (ChartElement) {
                 }
             }
 
-            for (var i = 0; i < points.length; i++) {
-                var pointData = points[i];
+            for (let i = 0; i < points.length; i++) {
+                const pointData = points[i];
                 if (!pointData) {
                     continue;
                 }
 
-                var fields = pointData.fields;
-                var value = pointData.value;
-                var visible = pointData.visible;
-                var angle = value !== 0 ? (constantAngle || (value * anglePerValue)) : 0;
-                var explode = data.length !== 1 && Boolean(fields.explode);
+                const { fields, value, visible } = pointData;
+                const angle = value !== 0 ? (constantAngle || (value * anglePerValue)) : 0;
+                const explode = data.length !== 1 && Boolean(fields.explode);
 
                 if (!isFunction(currentSeries.color)) {
                     currentSeries.color = fields.color || seriesColors[i % colorsCount];
                 }
 
                 callback(value, new Ring(null, 0, 0, currentAngle, angle), {
-                    owner: this$1,
+                    owner: this,
                     category: defined(fields.category) ? fields.category : "",
                     pattern: defined(fields.pattern) ? fields.pattern : currentSeries.pattern,
                     index: i,
@@ -96,7 +83,7 @@ var PieChart = (function (ChartElement) {
                     visibleInLegend: fields.visibleInLegend,
                     visible: visible,
                     zIndex: seriesCount - seriesIx,
-                    animationDelay: this$1.animationDelay(i, seriesIx, seriesCount)
+                    animationDelay: this.animationDelay(i, seriesIx, seriesCount)
                 });
 
                 if (visible !== false) {
@@ -104,10 +91,10 @@ var PieChart = (function (ChartElement) {
                 }
             }
         }
-    };
+    }
 
-    PieChart.prototype.evalSegmentOptions = function evalSegmentOptions (options, value, fields) {
-        var series = fields.series;
+    evalSegmentOptions(options, value, fields) {
+        const series = fields.series;
 
         evalOptions(options, {
             value: value,
@@ -119,10 +106,10 @@ var PieChart = (function (ChartElement) {
             "data", "content", "template", "visual", "toggle",
             "ariaTemplate", "ariaContent"
         ] });
-    };
+    }
 
-    PieChart.prototype.addValue = function addValue (value, sector, fields) {
-        var segmentOptions = deepExtend({}, fields.series, { index: fields.index });
+    addValue(value, sector, fields) {
+        const segmentOptions = deepExtend({}, fields.series, { index: fields.index });
         segmentOptions.pattern = fields.pattern || segmentOptions.pattern;
         this.evalSegmentOptions(segmentOptions, value, fields);
 
@@ -132,51 +119,48 @@ var PieChart = (function (ChartElement) {
             return;
         }
 
-        var segment = new PieSegment(value, sector, segmentOptions);
+        const segment = new PieSegment(value, sector, segmentOptions);
         Object.assign(segment, fields);
         this.append(segment);
         this.points.push(segment);
-    };
-
-    PieChart.prototype.reflow = function reflow (targetBox) {
-        var ref = this;
-        var options = ref.options;
-        var points = ref.points;
-        var seriesConfigs = ref.seriesConfigs; if ( seriesConfigs === void 0 ) seriesConfigs = [];
-        var count = points.length;
-        var box = targetBox.clone();
-        var space = 5;
-        var minWidth = Math.min(box.width(), box.height());
-        var halfMinWidth = minWidth / 2;
-        var defaultPadding = minWidth - minWidth * 0.85;
-        var newBox = new Box(box.x1, box.y1, box.x1 + minWidth, box.y1 + minWidth);
-        var newBoxCenter = newBox.center();
-        var boxCenter = box.center();
-        var seriesCount = options.series.length;
-        var leftSideLabels = [];
-        var rightSideLabels = [];
-        var padding = valueOrDefault(options.padding, defaultPadding);
+    }
+
+    reflow(targetBox) {
+        const { options, points, seriesConfigs = [] } = this;
+        const count = points.length;
+        const box = targetBox.clone();
+        const space = 5;
+        const minWidth = Math.min(box.width(), box.height());
+        const halfMinWidth = minWidth / 2;
+        const defaultPadding = minWidth - minWidth * 0.85;
+        const newBox = new Box(box.x1, box.y1, box.x1 + minWidth, box.y1 + minWidth);
+        const newBoxCenter = newBox.center();
+        const boxCenter = box.center();
+        const seriesCount = options.series.length;
+        const leftSideLabels = [];
+        const rightSideLabels = [];
+        let padding = valueOrDefault(options.padding, defaultPadding);
 
         this.targetBox = targetBox;
 
         padding = padding > halfMinWidth - space ? halfMinWidth - space : padding;
         newBox.translate(boxCenter.x - newBoxCenter.x, boxCenter.y - newBoxCenter.y);
 
-        var radius = halfMinWidth - padding;
-        var center = new Point(
+        const radius = halfMinWidth - padding;
+        const center = new Point(
             radius + newBox.x1 + padding,
             radius + newBox.y1 + padding
         );
 
-        for (var i = 0; i < count; i++) {
-            var segment = points[i];
-            var sector = segment.sector;
-            var seriesIndex = segment.seriesIx;
+        for (let i = 0; i < count; i++) {
+            const segment = points[i];
+            const sector = segment.sector;
+            const seriesIndex = segment.seriesIx;
             sector.radius = radius;
             sector.center = center;
 
             if (seriesConfigs.length) {
-                var seriesConfig = seriesConfigs[seriesIndex];
+                const seriesConfig = seriesConfigs[seriesIndex];
                 sector.innerRadius = seriesConfig.innerRadius;
                 sector.radius = seriesConfig.radius;
             }
@@ -187,7 +171,7 @@ var PieChart = (function (ChartElement) {
 
             segment.reflow(newBox);
 
-            var label = segment.label;
+            const label = segment.label;
             if (label) {
                 if (label.options.position === OUTSIDE_END) {
                     if (seriesIndex === seriesCount - 1) {
@@ -212,33 +196,33 @@ var PieChart = (function (ChartElement) {
         }
 
         this.box = newBox;
-    };
+    }
 
-    PieChart.prototype.leftLabelsReflow = function leftLabelsReflow (labels) {
-        var distances = this.distanceBetweenLabels(labels);
+    leftLabelsReflow(labels) {
+        const distances = this.distanceBetweenLabels(labels);
 
         this.distributeLabels(distances, labels);
-    };
+    }
 
-    PieChart.prototype.rightLabelsReflow = function rightLabelsReflow (labels) {
-        var distances = this.distanceBetweenLabels(labels);
+    rightLabelsReflow(labels) {
+        const distances = this.distanceBetweenLabels(labels);
 
         this.distributeLabels(distances, labels);
-    };
+    }
 
-    PieChart.prototype.distanceBetweenLabels = function distanceBetweenLabels (labels) {
-        var segment = last(this.points);
-        var sector = segment.sector;
-        var count = labels.length - 1;
-        var lr = sector.radius + segment.options.labels.distance;
-        var distances = [];
-        var firstBox = labels[0].box;
-        var distance = round(firstBox.y1 - (sector.center.y - lr - firstBox.height() - firstBox.height() / 2));
+    distanceBetweenLabels(labels) {
+        const segment = last(this.points);
+        const sector = segment.sector;
+        const count = labels.length - 1;
+        const lr = sector.radius + segment.options.labels.distance;
+        const distances = [];
+        let firstBox = labels[0].box;
+        let distance = round(firstBox.y1 - (sector.center.y - lr - firstBox.height() - firstBox.height() / 2));
 
         distances.push(distance);
 
-        for (var i = 0; i < count; i++) {
-            var secondBox = labels[i + 1].box;
+        for (let i = 0; i < count; i++) {
+            const secondBox = labels[i + 1].box;
 
             firstBox = labels[i].box;
             distance = round(secondBox.y1 - firstBox.y2);
@@ -248,57 +232,53 @@ var PieChart = (function (ChartElement) {
         distances.push(distance);
 
         return distances;
-    };
-
-    PieChart.prototype.distributeLabels = function distributeLabels (distances, labels) {
-        var this$1 = this;
+    }
 
-        var count = distances.length;
-        var left, right, remaining;
+    distributeLabels(distances, labels) {
+        const count = distances.length;
+        let left, right, remaining;
 
-        for (var i = 0; i < count; i++) {
+        for (let i = 0; i < count; i++) {
             remaining = -distances[i];
             left = right = i;
 
             while (remaining > 0 && (left >= 0 || right < count)) {
-                remaining = this$1._takeDistance(distances, i, --left, remaining);
-                remaining = this$1._takeDistance(distances, i, ++right, remaining);
+                remaining = this._takeDistance(distances, i, --left, remaining);
+                remaining = this._takeDistance(distances, i, ++right, remaining);
             }
         }
 
         this.reflowLabels(distances, labels);
-    };
+    }
 
-    PieChart.prototype._takeDistance = function _takeDistance (distances, anchor, position, amount) {
-        var result = amount;
+    _takeDistance(distances, anchor, position, amount) {
+        let result = amount;
         if (distances[position] > 0) {
-            var available = Math.min(distances[position], result);
+            const available = Math.min(distances[position], result);
             result -= available;
             distances[position] -= available;
             distances[anchor] += available;
         }
 
         return result;
-    };
-
-    PieChart.prototype.reflowLabels = function reflowLabels (distances, labels) {
-        var this$1 = this;
+    }
 
-        var segment = last(this.points);
-        var sector = segment.sector;
-        var labelOptions = segment.options.labels;
-        var labelsCount = labels.length;
-        var labelDistance = labelOptions.distance;
-        var boxY = sector.center.y - (sector.radius + labelDistance) - labels[0].box.height();
-        var boxX;
+    reflowLabels(distances, labels) {
+        const segment = last(this.points);
+        const sector = segment.sector;
+        const labelOptions = segment.options.labels;
+        const labelsCount = labels.length;
+        const labelDistance = labelOptions.distance;
+        let boxY = sector.center.y - (sector.radius + labelDistance) - labels[0].box.height();
+        let boxX;
 
         distances[0] += 2;
-        for (var i = 0; i < labelsCount; i++) {
-            var label = labels[i];
-            var box = label.box;
+        for (let i = 0; i < labelsCount; i++) {
+            const label = labels[i];
+            const box = label.box;
 
             boxY += distances[i];
-            boxX = this$1.hAlignLabel(
+            boxX = this.hAlignLabel(
                 box.x2,
                 sector.clone().expand(labelDistance),
                 boxY,
@@ -319,30 +299,25 @@ var PieChart = (function (ChartElement) {
 
             boxY += box.height();
         }
-    };
-
-    PieChart.prototype.createVisual = function createVisual () {
-        var this$1 = this;
+    }
 
-        var ref = this;
-        var connectors = ref.options.connectors;
-        var points = ref.points;
-        var count = points.length;
-        var space = 4;
+    createVisual() {
+        const { options: { connectors }, points } = this;
+        const count = points.length;
+        const space = 4;
 
-        ChartElement.prototype.createVisual.call(this);
+        super.createVisual();
 
         this._connectorLines = [];
 
-        for (var i = 0; i < count; i++) {
-            var segment = points[i];
-            var sector = segment.sector;
-            var label = segment.label;
-            var angle = sector.middle();
-            var connectorsColor = (segment.options.connectors || {}).color || connectors.color;
+        for (let i = 0; i < count; i++) {
+            const segment = points[i];
+            const { sector, label } = segment;
+            const angle = sector.middle();
+            const connectorsColor = (segment.options.connectors || {}).color || connectors.color;
 
             if (label) {
-                var connectorLine = new draw.Path({
+                const connectorLine = new draw.Path({
                     stroke: {
                         color: connectorsColor,
                         width: connectors.width
@@ -354,11 +329,11 @@ var PieChart = (function (ChartElement) {
                 });
 
                 if (label.options.position === OUTSIDE_END) {
-                    var box = label.box;
-                    var centerPoint = sector.center;
-                    var start = sector.point(angle);
-                    var middle = new Point(box.x1, box.center().y);
-                    var sr = (void 0), end = (void 0), crossing = (void 0);
+                    const box = label.box;
+                    const centerPoint = sector.center;
+                    let start = sector.point(angle);
+                    let middle = new Point(box.x1, box.center().y);
+                    let sr, end, crossing;
 
                     start = sector.clone().expand(connectors.padding).point(angle);
                     connectorLine.moveTo(start.x, start.y);
@@ -370,7 +345,7 @@ var PieChart = (function (ChartElement) {
                         crossing = crossing || middle;
                         crossing.x = Math.min(crossing.x, middle.x);
 
-                        if (this$1.pointInCircle(crossing, sector.center, sector.radius + space) ||
+                        if (this.pointInCircle(crossing, sector.center, sector.radius + space) ||
                             crossing.x < sector.center.x) {
                             sr = sector.center.x + sector.radius + space;
                             if (segment.options.labels.align !== COLUMN) {
@@ -394,7 +369,7 @@ var PieChart = (function (ChartElement) {
                         crossing = crossing || middle;
                         crossing.x = Math.max(crossing.x, middle.x);
 
-                        if (this$1.pointInCircle(crossing, sector.center, sector.radius + space) ||
+                        if (this.pointInCircle(crossing, sector.center, sector.radius + space) ||
                             crossing.x > sector.center.x) {
                             sr = sector.center.x - sector.radius - space;
                             if (segment.options.labels.align !== COLUMN) {
@@ -415,27 +390,27 @@ var PieChart = (function (ChartElement) {
 
                     connectorLine.lineTo(end.x, end.y);
 
-                    this$1._connectorLines.push(connectorLine);
-                    this$1.visual.append(connectorLine);
+                    this._connectorLines.push(connectorLine);
+                    this.visual.append(connectorLine);
                 }
             }
         }
-    };
+    }
 
-    PieChart.prototype.renderVisual = function renderVisual () {
-        ChartElement.prototype.renderVisual.call(this);
+    renderVisual() {
+        super.renderVisual();
 
-        if (find(this.options.series, function (options) { return options.autoFit; })) {
-            var targetBox = this.targetBox;
-            var pieCenter = this.box.center();
-            var bbox = this.visual.bbox();
+        if (find(this.options.series, options => options.autoFit)) {
+            const targetBox = this.targetBox;
+            const pieCenter = this.box.center();
+            const bbox = this.visual.bbox();
             if (!bbox) {
                 return;
             }
 
-            var bboxBottom = bbox.bottomRight();
+            const bboxBottom = bbox.bottomRight();
 
-            var scale = Math.min(
+            const scale = Math.min(
                 (pieCenter.y - targetBox.y1) / (pieCenter.y - bbox.origin.y),
                 (targetBox.y2 - pieCenter.y) / (bboxBottom.y - pieCenter.y),
                 (pieCenter.x - targetBox.x1) / (pieCenter.x - bbox.origin.x),
@@ -446,58 +421,53 @@ var PieChart = (function (ChartElement) {
                 this.visual.transform(geometry.transform().scale(scale, scale, [ pieCenter.x, pieCenter.y ]));
             }
         }
-    };
+    }
 
-    PieChart.prototype.labelComparator = function labelComparator (reverse) {
-        var reverseValue = reverse ? -1 : 1;
+    labelComparator(reverse) {
+        const reverseValue = reverse ? -1 : 1;
 
         return function(a, b) {
-            var first = (a.parent.sector.middle() + 270) % 360;
-            var second = (b.parent.sector.middle() + 270) % 360;
+            const first = (a.parent.sector.middle() + 270) % 360;
+            const second = (b.parent.sector.middle() + 270) % 360;
             return (first - second) * reverseValue;
         };
-    };
+    }
 
-    PieChart.prototype.hAlignLabel = function hAlignLabel (originalX, sector, y1, y2, direction) {
-        var radius = sector.radius;
-        var sector_center = sector.center;
-        var cx = sector_center.x;
-        var cy = sector_center.y;
-        var t = Math.min(Math.abs(cy - y1), Math.abs(cy - y2));
+    hAlignLabel(originalX, sector, y1, y2, direction) {
+        const { radius, center: { x: cx, y: cy } } = sector;
+        const t = Math.min(Math.abs(cy - y1), Math.abs(cy - y2));
 
         if (t > radius) {
             return originalX;
         }
 
         return cx + Math.sqrt((radius * radius) - (t * t)) * (direction ? 1 : -1);
-    };
+    }
 
-    PieChart.prototype.pointInCircle = function pointInCircle (point, center, radius) {
+    pointInCircle(point, center, radius) {
         return Math.pow(center.x - point.x, 2) + Math.pow(center.y - point.y, 2) < Math.pow(radius, 2);
-    };
+    }
 
-    PieChart.prototype.formatPointValue = function formatPointValue (point, format) {
+    formatPointValue(point, format) {
         return this.chartService.format.auto(format, point.value);
-    };
+    }
 
-    PieChart.prototype.animationDelay = function animationDelay (categoryIndex) {
+    animationDelay(categoryIndex) {
         return categoryIndex * PIE_SECTOR_ANIM_DELAY;
-    };
+    }
 
-    PieChart.prototype.stackRoot = function stackRoot () {
+    stackRoot() {
         return this;
-    };
-
-    return PieChart;
-}(ChartElement));
+    }
+}
 
 function intersection(a1, a2, b1, b2) {
-    var uat = (b2.x - b1.x) * (a1.y - b1.y) - (b2.y - b1.y) * (a1.x - b1.x);
-    var ub = (b2.y - b1.y) * (a2.x - a1.x) - (b2.x - b1.x) * (a2.y - a1.y);
+    const uat = (b2.x - b1.x) * (a1.y - b1.y) - (b2.y - b1.y) * (a1.x - b1.x);
+    const ub = (b2.y - b1.y) * (a2.x - a1.x) - (b2.x - b1.x) * (a2.y - a1.y);
 
-    var result;
+    let result;
     if (ub !== 0) {
-        var ua = (uat / ub);
+        const ua = (uat / ub);
 
         result = new Point(
             a1.x + ua * (a2.x - a1.x),