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

package/dist/es/gauges/radial/radial-scale.js

@@ -6,21 +6,19 @@ import { buildLabelElement, getRange } from '../utils';
 
 import { DEGREE, DEFAULT_LINE_WIDTH, INSIDE, OUTSIDE } from '../constants';
 
-var GEO_ARC_ADJUST_ANGLE = 180;
+const GEO_ARC_ADJUST_ANGLE = 180;
 
-var Arc = drawing.Arc;
-var Path = drawing.Path;
-var Group = drawing.Group;
+const { Arc, Path, Group } = drawing;
 
 function drawTicks(arc, tickAngles, unit, tickOptions) {
-    var ticks = new Group();
-    var center = arc.center;
-    var radius = arc.getRadiusX();
+    const ticks = new Group();
+    const center = arc.center;
+    const radius = arc.getRadiusX();
 
     if (tickOptions.visible) {
-        for (var i = 0; i < tickAngles.length; i++) {
-            var tickStart = arc.pointAt(tickAngles[i]);
-            var tickEnd = new geo.Point(center.x + radius - tickOptions.size, center.y).rotate(tickAngles[i], center);
+        for (let i = 0; i < tickAngles.length; i++) {
+            const tickStart = arc.pointAt(tickAngles[i]);
+            const tickEnd = new geo.Point(center.x + radius - tickOptions.size, center.y).rotate(tickAngles[i], center);
 
             ticks.append(new Path({
                 stroke: {
@@ -38,38 +36,34 @@ function rangeSegment(from, to, color, opacity) {
     return { from: from, to: to, color: color, opacity: opacity };
 }
 
-var RadialScale = (function (NumericAxis) {
-    function RadialScale(options, service) {
-        NumericAxis.call(this, 0, 1, options, service);
+class RadialScale extends NumericAxis {
+    constructor(options, service) {
+        super(0, 1, options, service);
     }
 
-    if ( NumericAxis ) RadialScale.__proto__ = NumericAxis;
-    RadialScale.prototype = Object.create( NumericAxis && NumericAxis.prototype );
-    RadialScale.prototype.constructor = RadialScale;
-
-    RadialScale.prototype.initUserOptions = function initUserOptions (options) {
-        var scaleOptions = deepExtend({}, this.options, options);
+    initUserOptions(options) {
+        const scaleOptions = deepExtend({}, this.options, options);
         scaleOptions.majorUnit = scaleOptions.majorUnit || autoMajorUnit(scaleOptions.min, scaleOptions.max);
         scaleOptions.minorUnit = scaleOptions.minorUnit || scaleOptions.majorUnit / 10;
 
         return scaleOptions;
-    };
+    }
 
-    RadialScale.prototype.initFields = function initFields () {
-    };
+    initFields() {
+    }
 
-    RadialScale.prototype.render = function render (center, radius) {
-        var arc = this.renderArc(center, radius);
+    render(center, radius) {
+        const arc = this.renderArc(center, radius);
 
         this.bbox = arc.bbox();
         this.labelElements = this.renderLabels();
         this.ticks = this.renderTicks();
         this.ranges = this.renderRanges();
-    };
+    }
 
-    RadialScale.prototype.reflow = function reflow (bbox) {
-        var center = bbox.center();
-        var radius = Math.min(bbox.height(), bbox.width()) / 2;
+    reflow(bbox) {
+        const center = bbox.center();
+        const radius = Math.min(bbox.height(), bbox.width()) / 2;
 
         if (defined(this.bbox)) {
             this.bbox = this.arc.bbox();
@@ -79,17 +73,12 @@ var RadialScale = (function (NumericAxis) {
         } else {
             return this.render(center, radius);
         }
-    };
-
-    RadialScale.prototype.slotAngle = function slotAngle (value) {
-        var ref = this.options;
-        var min = ref.min;
-        var max = ref.max;
-        var reverse = ref.reverse;
-        var startAngle = ref.startAngle;
-        var endAngle = ref.endAngle;
-        var angle = endAngle - startAngle;
-        var result;
+    }
+
+    slotAngle(value) {
+        const { min, max, reverse, startAngle, endAngle } = this.options;
+        const angle = endAngle - startAngle;
+        let result;
 
         if (reverse) {
             result = endAngle - (value - min) / (max - min) * angle;
@@ -98,19 +87,17 @@ var RadialScale = (function (NumericAxis) {
         }
 
         return result + GEO_ARC_ADJUST_ANGLE;
-    };
+    }
 
-    RadialScale.prototype.hasRanges = function hasRanges () {
-        var ranges = this.options.ranges;
+    hasRanges() {
+        const ranges = this.options.ranges;
 
         return ranges && ranges.length;
-    };
+    }
 
-    RadialScale.prototype.ticksSize = function ticksSize () {
-        var ref = this.options;
-        var majorTicks = ref.majorTicks;
-        var minorTicks = ref.minorTicks;
-        var size = 0;
+    ticksSize() {
+        const { majorTicks, minorTicks } = this.options;
+        let size = 0;
         if (majorTicks.visible) {
             size = majorTicks.size;
         }
@@ -120,40 +107,38 @@ var RadialScale = (function (NumericAxis) {
         }
 
         return size;
-    };
+    }
 
-    RadialScale.prototype.labelsCount = function labelsCount () {
-        var count = NumericAxis.prototype.labelsCount.call(this);
-        var options = this.options;
-        var angle = options.endAngle - options.startAngle;
+    labelsCount() {
+        let count = super.labelsCount();
+        const options = this.options;
+        const angle = options.endAngle - options.startAngle;
 
         if (angle >= 360 && (options.max % options.majorUnit === 0)) {
             count -= 1;
         }
 
         return count;
-    };
-
-    RadialScale.prototype.renderLabels = function renderLabels () {
-        var this$1 = this;
+    }
 
-        var options = this.options;
-        var arc = this.arc.clone();
-        var radius = arc.getRadiusX();
-        var tickAngles = this.tickAngles(arc, options.majorUnit);
-        var rangeSize = options.rangeSize = options.rangeSize || radius * 0.1;
-        var labelsGroup = new Group();
+    renderLabels() {
+        const options = this.options;
+        const arc = this.arc.clone();
+        let radius = arc.getRadiusX();
+        const tickAngles = this.tickAngles(arc, options.majorUnit);
+        const rangeSize = options.rangeSize = options.rangeSize || radius * 0.1;
+        const labelsGroup = new Group();
 
-        var rangeDistance = radius * 0.05;
+        let rangeDistance = radius * 0.05;
         if (defined(options.rangeDistance)) {
             rangeDistance = options.rangeDistance;
         } else {
             options.rangeDistance = rangeDistance;
         }
 
-        var labelsOptions = options.labels;
-        var isInside = labelsOptions.position === INSIDE;
-        var hasLabelElements = defined(this.labelElements);
+        const labelsOptions = options.labels;
+        const isInside = labelsOptions.position === INSIDE;
+        const hasLabelElements = defined(this.labelElements);
 
         if (isInside) {
             radius -= this.ticksSize();
@@ -164,102 +149,95 @@ var RadialScale = (function (NumericAxis) {
             arc.setRadiusX(radius).setRadiusY(radius);
         }
 
-        var labels = this.labels;
-        var count = labels.length;
-        var padding = getSpacing(labelsOptions.padding);
-        var paddingWidth = (padding.left + padding.right) / 2;
-        var paddingHeight = (padding.top + padding.bottom) / 2;
+        const labels = this.labels;
+        const count = labels.length;
+        const padding = getSpacing(labelsOptions.padding);
+        const paddingWidth = (padding.left + padding.right) / 2;
+        const paddingHeight = (padding.top + padding.bottom) / 2;
 
-        for (var i = 0; i < count; i++) {
-            var label = labels[i];
-            var halfWidth = label.box.width() / 2;
-            var halfHeight = label.box.height() / 2;
-            var angle = tickAngles[i];
-            var labelAngle = (angle - GEO_ARC_ADJUST_ANGLE) * DEGREE;
+        for (let i = 0; i < count; i++) {
+            const label = labels[i];
+            const halfWidth = label.box.width() / 2;
+            const halfHeight = label.box.height() / 2;
+            const angle = tickAngles[i];
+            const labelAngle = (angle - GEO_ARC_ADJUST_ANGLE) * DEGREE;
 
-            var lp = arc.pointAt(angle);
-            var cx = lp.x + (Math.cos(labelAngle) * (halfWidth + paddingWidth) * (isInside ? 1 : -1));
-            var cy = lp.y + (Math.sin(labelAngle) * (halfHeight + paddingHeight) * (isInside ? 1 : -1));
+            const lp = arc.pointAt(angle);
+            const cx = lp.x + (Math.cos(labelAngle) * (halfWidth + paddingWidth) * (isInside ? 1 : -1));
+            const cy = lp.y + (Math.sin(labelAngle) * (halfHeight + paddingHeight) * (isInside ? 1 : -1));
 
             label.reflow(new Box(cx - halfWidth, cy - halfHeight, cx + halfWidth, cy + halfHeight));
-            var labelPos = new geo.Point(label.box.x1, label.box.y1);
+            const labelPos = new geo.Point(label.box.x1, label.box.y1);
 
-            var labelElement = (void 0);
+            let labelElement;
             if (!hasLabelElements) {
                 labelElement = buildLabelElement(label, options.labels);
                 labelsGroup.append(labelElement);
             } else {
-                labelElement = this$1.labelElements.children[i];
-                var prevLabelPos = labelElement.bbox().origin;
+                labelElement = this.labelElements.children[i];
+                const prevLabelPos = labelElement.bbox().origin;
 
-                var labelTransform = labelElement.transform() || geo.transform();
+                const labelTransform = labelElement.transform() || geo.transform();
                 labelTransform.translate(labelPos.x - prevLabelPos.x, labelPos.y - prevLabelPos.y);
                 labelElement.transform(labelTransform);
             }
 
-            this$1.bbox = geo.Rect.union(this$1.bbox, labelElement.bbox());
+            this.bbox = geo.Rect.union(this.bbox, labelElement.bbox());
         }
 
         return labelsGroup;
-    };
+    }
 
-    RadialScale.prototype.repositionRanges = function repositionRanges () {
-        var ranges = this.ranges.children;
+    repositionRanges() {
+        const ranges = this.ranges.children;
 
         if (ranges.length > 0) {
-            var ref = this.options;
-            var rangeDistance = ref.rangeDistance;
-            var rangeSize = ref.rangeSize;
-            var rangeRadius = this.getRangeRadius();
+            const { rangeDistance, rangeSize } = this.options;
+            let rangeRadius = this.getRangeRadius();
 
             if (this.options.labels.position === INSIDE) {
                 rangeRadius += rangeSize + rangeDistance;
             }
 
-            var newRadius = rangeRadius + (rangeSize / 2);
+            const newRadius = rangeRadius + (rangeSize / 2);
 
-            for (var i = 0; i < ranges.length; i++) {
+            for (let i = 0; i < ranges.length; i++) {
                 ranges[i]._geometry.setRadiusX(newRadius).setRadiusY(newRadius);
             }
 
             this.bbox = geo.Rect.union(this.bbox, this.ranges.bbox());
         }
-    };
-
-    RadialScale.prototype.renderRanges = function renderRanges () {
-        var this$1 = this;
+    }
 
-        var segments = this.rangeSegments();
-        var segmentsCount = segments.length;
-        var result = new Group();
+    renderRanges() {
+        const segments = this.rangeSegments();
+        const segmentsCount = segments.length;
+        const result = new Group();
 
         if (segmentsCount) {
-            var ref = this.options;
-            var rangeSize = ref.rangeSize;
-            var reverse = ref.reverse;
-            var rangeDistance = ref.rangeDistance;
-            var rangeRadius = this.getRangeRadius();
+            const { rangeSize, reverse, rangeDistance } = this.options;
+            const rangeRadius = this.getRangeRadius();
 
             // move the ticks with a range distance and a range size
             this.radius(this.radius() - rangeSize - rangeDistance);
 
-            for (var i = 0; i < segmentsCount; i++) {
-                var segment = segments[i];
-                var from = this$1.slotAngle(segment[reverse ? "to" : "from"]);
-                var to = this$1.slotAngle(segment[!reverse ? "to" : "from"]);
+            for (let i = 0; i < segmentsCount; i++) {
+                const segment = segments[i];
+                const from = this.slotAngle(segment[reverse ? "to" : "from"]);
+                const to = this.slotAngle(segment[!reverse ? "to" : "from"]);
 
                 if (to - from !== 0) {
-                    result.append(this$1.createRange(from, to, rangeRadius, segment));
+                    result.append(this.createRange(from, to, rangeRadius, segment));
                 }
             }
         }
 
         return result;
-    };
+    }
 
-    RadialScale.prototype.createRange = function createRange (startAngle, endAngle, rangeRadius, options) {
-        var rangeSize = this.options.rangeSize;
-        var rangeGeom = new geo.Arc(this.arc.center, {
+    createRange(startAngle, endAngle, rangeRadius, options) {
+        const rangeSize = this.options.rangeSize;
+        const rangeGeom = new geo.Arc(this.arc.center, {
             radiusX: rangeRadius + (rangeSize / 2),
             radiusY: rangeRadius + (rangeSize / 2),
             startAngle: startAngle,
@@ -274,26 +252,24 @@ var RadialScale = (function (NumericAxis) {
                 lineCap: options.lineCap
             }
         });
-    };
+    }
 
-    RadialScale.prototype.rangeSegments = function rangeSegments () {
-        var options = this.options;
-        var ranges = options.ranges || [];
-        var count = ranges.length;
-        var segments = [];
+    rangeSegments() {
+        const options = this.options;
+        const ranges = options.ranges || [];
+        const count = ranges.length;
+        const segments = [];
 
         if (count) {
-            var min = options.min;
-            var max = options.max;
-            var defaultColor = options.rangePlaceholderColor;
+            const { min, max, rangePlaceholderColor: defaultColor } = options;
             segments.push(rangeSegment(min, max, defaultColor));
 
-            for (var i = 0; i < count; i++) {
-                var range = getRange(ranges[i], min, max);
-                var segmentsCount = segments.length;
+            for (let i = 0; i < count; i++) {
+                const range = getRange(ranges[i], min, max);
+                const segmentsCount = segments.length;
 
-                for (var j = 0; j < segmentsCount; j++) {
-                    var segment = segments[j];
+                for (let j = 0; j < segmentsCount; j++) {
+                    const segment = segments[j];
 
                     if (segment.from <= range.from && range.from <= segment.to) {
                         segments.push(rangeSegment(range.from, range.to, range.color, range.opacity));
@@ -311,16 +287,12 @@ var RadialScale = (function (NumericAxis) {
         }
 
         return segments;
-    };
+    }
 
-    RadialScale.prototype.getRangeRadius = function getRangeRadius () {
-        var ref = this;
-        var arc = ref.arc;
-        var options = ref.options;
-        var rangeSize = options.rangeSize;
-        var rangeDistance = options.rangeDistance;
-        var majorTickSize = options.majorTicks.size;
-        var radius;
+    getRangeRadius() {
+        const { arc, options } = this;
+        const { rangeSize, rangeDistance, majorTicks: { size: majorTickSize } } = options;
+        let radius;
 
         if (options.labels.position === OUTSIDE) {
             radius = arc.getRadiusX() - majorTickSize - rangeDistance - rangeSize;
@@ -329,12 +301,12 @@ var RadialScale = (function (NumericAxis) {
         }
 
         return radius;
-    };
+    }
 
-    RadialScale.prototype.renderArc = function renderArc (center, radius) {
-        var options = this.options;
+    renderArc(center, radius) {
+        const options = this.options;
 
-        var arc = this.arc = new geo.Arc(center, {
+        const arc = this.arc = new geo.Arc(center, {
             radiusX: radius,
             radiusY: radius,
             startAngle: options.startAngle + GEO_ARC_ADJUST_ANGLE,
@@ -342,27 +314,25 @@ var RadialScale = (function (NumericAxis) {
         });
 
         return arc;
-    };
+    }
 
-    RadialScale.prototype.renderTicks = function renderTicks () {
-        var ref = this;
-        var arc = ref.arc;
-        var options = ref.options;
-        var tickArc = arc.clone();
+    renderTicks() {
+        const { arc, options } = this;
+        const tickArc = arc.clone();
 
         this.majorTickAngles = this.tickAngles(arc, options.majorUnit);
         this.majorTicks = drawTicks(tickArc, this.majorTickAngles, options.majorUnit, options.majorTicks);
 
-        var allTicks = new Group();
+        const allTicks = new Group();
         allTicks.append(this.majorTicks);
 
-        var majorTickSize = options.majorTicks.size;
-        var minorTickSize = options.minorTicks.size;
+        const majorTickSize = options.majorTicks.size;
+        const minorTickSize = options.minorTicks.size;
 
         this._tickDifference = majorTickSize - minorTickSize;
 
         if (options.labels.position === OUTSIDE) {
-            var radius = tickArc.getRadiusX();
+            const radius = tickArc.getRadiusX();
             tickArc.setRadiusX(radius - majorTickSize + minorTickSize)
                 .setRadiusY(radius - majorTickSize + minorTickSize);
         }
@@ -372,29 +342,29 @@ var RadialScale = (function (NumericAxis) {
         allTicks.append(this.minorTicks);
 
         return allTicks;
-    };
+    }
 
-    RadialScale.prototype.normalizeTickAngles = function normalizeTickAngles (angles) {
-        var options = this.options;
-        var skip = options.majorUnit / options.minorUnit;
+    normalizeTickAngles(angles) {
+        const options = this.options;
+        const skip = options.majorUnit / options.minorUnit;
 
-        for (var i = angles.length - 1; i >= 0; i--) {
+        for (let i = angles.length - 1; i >= 0; i--) {
             if (i % skip === 0) {
                 angles.splice(i, 1);
             }
         }
 
         return angles;
-    };
+    }
 
-    RadialScale.prototype.tickAngles = function tickAngles (ring, stepValue) {
-        var options = this.options;
-        var reverse = options.reverse;
-        var range = options.max - options.min;
-        var angle = ring.endAngle - ring.startAngle;
-        var tickCount = range / stepValue;
-        var pos = ring.startAngle;
-        var step = angle / tickCount;
+    tickAngles(ring, stepValue) {
+        const options = this.options;
+        const reverse = options.reverse;
+        const range = options.max - options.min;
+        const angle = ring.endAngle - ring.startAngle;
+        let tickCount = range / stepValue;
+        let pos = ring.startAngle;
+        let step = angle / tickCount;
 
         if (reverse) {
             pos += angle;
@@ -405,8 +375,8 @@ var RadialScale = (function (NumericAxis) {
             tickCount -= 1;
         }
 
-        var positions = [];
-        for (var i = 0; i < tickCount; i++) {
+        const positions = [];
+        for (let i = 0; i < tickCount; i++) {
             positions.push(round(pos, COORD_PRECISION));
             pos += step;
         }
@@ -416,9 +386,9 @@ var RadialScale = (function (NumericAxis) {
         }
 
         return positions;
-    };
+    }
 
-    RadialScale.prototype.radius = function radius (value) {
+    radius(value) {
         if (value) {
             this.arc.setRadiusX(value).setRadiusY(value);
             this.repositionTicks(this.majorTicks.children, this.majorTickAngles);
@@ -426,30 +396,28 @@ var RadialScale = (function (NumericAxis) {
         } else {
             return this.arc.getRadiusX();
         }
-    };
+    }
 
-    RadialScale.prototype.repositionTicks = function repositionTicks (ticks, tickAngles, minor) {
-        var diff = minor ? (this._tickDifference || 0) : 0;
-        var tickArc = this.arc;
-        var radius = tickArc.getRadiusX();
+    repositionTicks(ticks, tickAngles, minor) {
+        const diff = minor ? (this._tickDifference || 0) : 0;
+        let tickArc = this.arc;
+        const radius = tickArc.getRadiusX();
 
         if (minor && this.options.labels.position === OUTSIDE && diff !== 0) {
             tickArc = this.arc.clone();
             tickArc.setRadiusX(radius - diff).setRadiusY(radius - diff);
         }
 
-        for (var i = 0; i < ticks.length; i++) {
-            var newPoint = tickArc.pointAt(tickAngles[i]);
-            var segments = ticks[i].segments;
-            var xDiff = newPoint.x - segments[0].anchor().x;
-            var yDiff = newPoint.y - segments[0].anchor().y;
+        for (let i = 0; i < ticks.length; i++) {
+            const newPoint = tickArc.pointAt(tickAngles[i]);
+            const segments = ticks[i].segments;
+            const xDiff = newPoint.x - segments[0].anchor().x;
+            const yDiff = newPoint.y - segments[0].anchor().y;
 
             ticks[i].transform(new geo.transform().translate(xDiff, yDiff));
         }
-    };
-
-    return RadialScale;
-}(NumericAxis));
+    }
+}
 
 setDefaultOptions(RadialScale, {
     min: 0,

package/dist/es/gauges/utils/build-label-element.js

@@ -1,28 +1,26 @@
 import { geometry as geo, drawing } from '@progress/kendo-drawing';
 import pad from './pad';
 
-var Group = drawing.Group;
-var Path = drawing.Path;
-var Text = drawing.Text;
+const { Group, Path, Text } = drawing;
 
 export default function buildLabelElement(label, options) {
-    var labelBox = label.box;
-    var textBox = label.children[0].box;
-    var border = options.border || {};
-    var background = options.background || "";
+    const labelBox = label.box;
+    const textBox = label.children[0].box;
+    const border = options.border || {};
+    const background = options.background || "";
 
-    var wrapper = Path.fromRect(new geo.Rect([ labelBox.x1, labelBox.y1 ], [ labelBox.width(), labelBox.height() ]), {
+    const wrapper = Path.fromRect(new geo.Rect([ labelBox.x1, labelBox.y1 ], [ labelBox.width(), labelBox.height() ]), {
         stroke: {}
     });
 
-    var text = new Text(label.text, new geo.Point(textBox.x1, textBox.y1), {
+    const text = new Text(label.text, new geo.Point(textBox.x1, textBox.y1), {
         font: options.font,
         fill: { color: options.color }
     });
 
-    var styleGeometry = pad(text.bbox().clone(), options.padding);
+    const styleGeometry = pad(text.bbox().clone(), options.padding);
 
-    var styleBox = Path.fromRect(styleGeometry, {
+    const styleBox = Path.fromRect(styleGeometry, {
         stroke: {
             color: border.width ? border.color : "",
             width: border.width,
@@ -36,7 +34,7 @@ export default function buildLabelElement(label, options) {
         }
     });
 
-    var elements = new Group();
+    const elements = new Group();
     elements.append(wrapper);
     elements.append(styleBox);
     elements.append(text);

package/dist/es/gauges/utils/get-range.js

@@ -2,8 +2,8 @@ import { defined } from '../../common';
 import { MIN_VALUE, MAX_VALUE } from '../../common/constants';
 
 export default function getRange(range, min, max) {
-    var from = defined(range.from) ? range.from : MIN_VALUE;
-    var to = defined(range.to) ? range.to : MAX_VALUE;
+    const from = defined(range.from) ? range.from : MIN_VALUE;
+    const to = defined(range.to) ? range.to : MAX_VALUE;
 
     range.from = Math.max(Math.min(to, from), min);
     range.to = Math.min(Math.max(to, from), max);

package/dist/es/gauges/utils/pad.js

@@ -1,9 +1,9 @@
 import { getSpacing } from '../../common';
 
 export default function pad(bbox, value) {
-    var origin = bbox.getOrigin();
-    var size = bbox.getSize();
-    var spacing = getSpacing(value);
+    const origin = bbox.getOrigin();
+    const size = bbox.getSize();
+    const spacing = getSpacing(value);
 
     bbox.setOrigin([ origin.x - spacing.left, origin.y - spacing.top ]);
     bbox.setSize([ size.width + (spacing.left + spacing.right), size.height + (spacing.top + spacing.bottom) ]);

package/dist/es/gauges/utils/unpad.js

@@ -2,7 +2,7 @@ import { getSpacing } from '../../common';
 import pad from './pad';
 
 export default function unpad(bbox, value) {
-    var spacing = getSpacing(value);
+    const spacing = getSpacing(value);
 
     spacing.left = -spacing.left; spacing.top = -spacing.top;
     spacing.right = -spacing.right; spacing.bottom = -spacing.bottom;