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

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

@@ -12,50 +12,39 @@ import anyHasZIndex from '../utils/any-has-z-index';
 import { OBJECT, STRING, X, Y } from '../../common/constants';
 import { defined, isFunction, setDefaultOptions } from '../../common';
 
-var BarChart = (function (CategoricalChart) {
-    function BarChart () {
-        CategoricalChart.apply(this, arguments);
-    }
-
-    if ( CategoricalChart ) BarChart.__proto__ = CategoricalChart;
-    BarChart.prototype = Object.create( CategoricalChart && CategoricalChart.prototype );
-    BarChart.prototype.constructor = BarChart;
+class BarChart extends CategoricalChart {
 
-    BarChart.prototype.render = function render () {
-        CategoricalChart.prototype.render.call(this);
+    render() {
+        super.render();
         this.updateStackRange();
-    };
+    }
 
-    BarChart.prototype.pointType = function pointType () {
+    pointType() {
         return Bar;
-    };
+    }
 
-    BarChart.prototype.clusterType = function clusterType () {
+    clusterType() {
         return ClusterLayout;
-    };
+    }
 
-    BarChart.prototype.stackType = function stackType () {
+    stackType() {
         return StackWrap;
-    };
+    }
 
-    BarChart.prototype.stackLimits = function stackLimits (axisName, stackName) {
-        var limits = CategoricalChart.prototype.stackLimits.call(this, axisName, stackName);
+    stackLimits(axisName, stackName) {
+        const limits = super.stackLimits(axisName, stackName);
 
         return limits;
-    };
-
-    BarChart.prototype.createPoint = function createPoint (data, fields) {
-        var categoryIx = fields.categoryIx;
-        var series = fields.series;
-        var seriesIx = fields.seriesIx;
-        var ref = this;
-        var options = ref.options;
-        var children = ref.children;
-        var stackOrDefault = defined(series.stack) ? series.stack : options.defaultStack;
-        var value = this.pointValue(data);
-        var pointOptions = this.pointOptions(series, seriesIx);
-
-        var labelOptions = pointOptions.labels;
+    }
+
+    createPoint(data, fields) {
+        const { categoryIx, series, seriesIx } = fields;
+        const { options, children } = this;
+        const stackOrDefault = defined(series.stack) ? series.stack : options.defaultStack;
+        const value = this.pointValue(data);
+        let pointOptions = this.pointOptions(series, seriesIx);
+
+        const labelOptions = pointOptions.labels;
         if (stackOrDefault) {
             if (labelOptions.position === OUTSIDE_END) {
                 labelOptions.position = INSIDE_END;
@@ -64,7 +53,7 @@ var BarChart = (function (CategoricalChart) {
 
         pointOptions.isStacked = stackOrDefault;
 
-        var color = data.fields.color || series.color;
+        let color = data.fields.color || series.color;
         if (value < 0 && pointOptions.negativeColor) {
             color = pointOptions.negativeColor;
         }
@@ -74,13 +63,13 @@ var BarChart = (function (CategoricalChart) {
             color = pointOptions.color;
         }
 
-        var pointType = this.pointType();
-        var point = new pointType(value, pointOptions);
+        const pointType = this.pointType();
+        const point = new pointType(value, pointOptions);
         point.color = color;
 
-        var cluster = children[categoryIx];
+        let cluster = children[categoryIx];
         if (!cluster) {
-            var clusterType = this.clusterType();
+            const clusterType = this.clusterType();
             cluster = new clusterType({
                 vertical: options.invertAxes,
                 gap: options.gap,
@@ -91,22 +80,22 @@ var BarChart = (function (CategoricalChart) {
         }
 
         if (options.isStacked) {
-            var stackWrap = this.getStackWrap(stackOrDefault, cluster);
+            const stackWrap = this.getStackWrap(stackOrDefault, cluster);
             stackWrap.append(point);
         } else {
             cluster.append(point);
         }
 
         return point;
-    };
+    }
 
-    BarChart.prototype.getStackWrap = function getStackWrap (stack, cluster) {
-        var stackGroup = (typeof stack === OBJECT) ? (stack.group || true) : stack;
-        var wraps = cluster.children;
-        var stackWrap;
+    getStackWrap(stack, cluster) {
+        const stackGroup = (typeof stack === OBJECT) ? (stack.group || true) : stack;
+        const wraps = cluster.children;
+        let stackWrap;
 
         if (typeof stackGroup === STRING || stackGroup === true) {
-            for (var i = 0; i < wraps.length; i++) {
+            for (let i = 0; i < wraps.length; i++) {
                 if (wraps[i]._stackGroup === stackGroup) {
                     stackWrap = wraps[i];
                     break;
@@ -115,7 +104,7 @@ var BarChart = (function (CategoricalChart) {
         }
 
         if (!stackWrap) {
-            var stackType = this.stackType();
+            const stackType = this.stackType();
             stackWrap = new stackType({
                 vertical: !this.options.invertAxes
             });
@@ -124,62 +113,60 @@ var BarChart = (function (CategoricalChart) {
         }
 
         return stackWrap;
-    };
+    }
 
-    BarChart.prototype.categorySlot = function categorySlot (categoryAxis, categoryIx, valueAxis) {
-        var options = this.options;
-        var categorySlot = categoryAxis.getSlot(categoryIx);
-        var startValue = valueAxis.startValue();
+    categorySlot(categoryAxis, categoryIx, valueAxis) {
+        const options = this.options;
+        const categorySlot = categoryAxis.getSlot(categoryIx);
+        const startValue = valueAxis.startValue();
 
         if (options.isStacked) {
-            var zeroSlot = valueAxis.getSlot(startValue, startValue, true);
-            var stackAxis = options.invertAxes ? X : Y;
+            const zeroSlot = valueAxis.getSlot(startValue, startValue, true);
+            const stackAxis = options.invertAxes ? X : Y;
             categorySlot[stackAxis + 1] = categorySlot[stackAxis + 2] = zeroSlot[stackAxis + 1];
         }
 
         return categorySlot;
-    };
+    }
 
-    BarChart.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]);
         }
-    };
+    }
 
-    BarChart.prototype.createAnimation = function createAnimation () {
+    createAnimation() {
         this._setAnimationOptions();
-        CategoricalChart.prototype.createAnimation.call(this);
+        super.createAnimation();
 
         if (anyHasZIndex(this.options.series)) {
             this._setChildrenAnimation();
         }
-    };
-
-    BarChart.prototype._setChildrenAnimation = function _setChildrenAnimation () {
-        var this$1 = this;
+    }
 
-        var points = this.points;
+    _setChildrenAnimation() {
+        const points = this.points;
 
-        for (var idx = 0; idx < points.length; idx++) {
-            var point = points[idx];
-            var pointVisual = point.visual;
+        for (let idx = 0; idx < points.length; idx++) {
+            const point = points[idx];
+            const pointVisual = point.visual;
             if (pointVisual && defined(pointVisual.options.zIndex)) {
-                point.options.animation = this$1.options.animation;
+                point.options.animation = this.options.animation;
                 point.createAnimation();
             }
         }
-    };
+    }
 
-    BarChart.prototype._setAnimationOptions = function _setAnimationOptions () {
-        var options = this.options;
-        var animation = options.animation || {};
-        var origin;
+    _setAnimationOptions() {
+        const options = this.options;
+        const animation = options.animation || {};
+        let origin;
 
         if (options.isStacked) {
-            var valueAxis = this.seriesValueAxis(options.series[0]);
+            const valueAxis = this.seriesValueAxis(options.series[0]);
             origin = valueAxis.getSlot(valueAxis.startValue());
         } else {
             origin = this.categoryAxis.getSlot(0);
@@ -187,10 +174,8 @@ var BarChart = (function (CategoricalChart) {
 
         animation.origin = new geom.Point(origin.x1, origin.y1);
         animation.vertical = !options.invertAxes;
-    };
-
-    return BarChart;
-}(CategoricalChart));
+    }
+}
 
 setDefaultOptions(BarChart, {
     animation: {

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

@@ -4,31 +4,26 @@ import { FADEIN, INITIAL_ANIMATION_DURATION, INSIDE_END, INSIDE_BASE, OUTSIDE_EN
 import { CENTER, TOP, BOTTOM, LEFT, RIGHT, X, Y, BLACK } from '../../common/constants';
 import { getSpacing, setDefaultOptions } from '../../common';
 
-var BarLabel = (function (ChartElement) {
-    function BarLabel(content, options, pointData) {
-        ChartElement.call(this, options);
+class BarLabel extends ChartElement {
+    constructor(content, options, pointData) {
+        super(options);
 
         this.textBox = new TextBox(content, this.options, pointData);
         this.append(this.textBox);
     }
 
-    if ( ChartElement ) BarLabel.__proto__ = ChartElement;
-    BarLabel.prototype = Object.create( ChartElement && ChartElement.prototype );
-    BarLabel.prototype.constructor = BarLabel;
-
-    BarLabel.prototype.createVisual = function createVisual () {
+    createVisual() {
         this.textBox.options.noclip = this.options.noclip;
-    };
+    }
 
-    BarLabel.prototype.reflow = function reflow (targetBox) {
-        var options = this.options;
-        var vertical = options.vertical;
-        var aboveAxis = options.aboveAxis;
-        var text = this.children[0];
-        var textOptions = text.options;
-        var box = text.box;
-        var padding = text.options.padding;
-        var labelBox = targetBox;
+    reflow(targetBox) {
+        const options = this.options;
+        const { vertical, aboveAxis } = options;
+        const text = this.children[0];
+        const textOptions = text.options;
+        const box = text.box;
+        const padding = text.options.padding;
+        let labelBox = targetBox;
 
         textOptions.align = vertical ? CENTER : LEFT;
         textOptions.vAlign = vertical ? TOP : CENTER;
@@ -55,7 +50,7 @@ var BarLabel = (function (ChartElement) {
         } else if (options.position === OUTSIDE_END) {
             if (vertical) {
                 if (aboveAxis) {
-                    var boxesDiff = (box.width() - targetBox.width() - padding.left - padding.right) / 2;
+                    const boxesDiff = (box.width() - targetBox.width() - padding.left - padding.right) / 2;
                     labelBox = new Box(
                         targetBox.x1 - boxesDiff, targetBox.y1 - box.height(),
                         targetBox.x2 + boxesDiff, targetBox.y1
@@ -93,27 +88,25 @@ var BarLabel = (function (ChartElement) {
         }
 
         text.reflow(labelBox);
-    };
+    }
 
-    BarLabel.prototype.alignToClipBox = function alignToClipBox (clipBox) {
-        var vertical = this.options.vertical;
-        var field = vertical ? Y : X;
-        var start = field + "1";
-        var end = field + "2";
-        var text = this.children[0];
-        var parentBox = this.parent.box;
+    alignToClipBox(clipBox) {
+        const vertical = this.options.vertical;
+        const field = vertical ? Y : X;
+        const start = field + "1";
+        const end = field + "2";
+        const text = this.children[0];
+        const parentBox = this.parent.box;
 
         if (parentBox[start] < clipBox[start] || clipBox[end] < parentBox[end]) {
-            var targetBox = text.paddingBox.clone();
+            const targetBox = text.paddingBox.clone();
             targetBox[start] = Math.max(parentBox[start], clipBox[start]);
             targetBox[end] = Math.min(parentBox[end], clipBox[end]);
 
             this.reflow(targetBox);
         }
-    };
-
-    return BarLabel;
-}(ChartElement));
+    }
+}
 
 setDefaultOptions(BarLabel, {
     position: OUTSIDE_END,

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

@@ -15,11 +15,11 @@ import AccessibilityAttributesMixin from '../mixins/accessibility-attributes-mix
 import { WHITE, LEFT, RIGHT, BOTTOM, TOP } from '../../common/constants';
 import { alignPathToPixel, deepExtend, defined, getTemplate, valueOrDefault } from '../../common';
 
-var BAR_ALIGN_MIN_WIDTH = 6;
+const BAR_ALIGN_MIN_WIDTH = 6;
 
-var Bar = (function (ChartElement) {
-    function Bar(value, options) {
-        ChartElement.call(this);
+class Bar extends ChartElement {
+    constructor(value, options) {
+        super();
 
         this.options = options;
         this.color = options.color || WHITE;
@@ -27,11 +27,7 @@ var Bar = (function (ChartElement) {
         this.value = value;
     }
 
-    if ( ChartElement ) Bar.__proto__ = ChartElement;
-    Bar.prototype = Object.create( ChartElement && ChartElement.prototype );
-    Bar.prototype.constructor = Bar;
-
-    Bar.prototype.render = function render () {
+    render() {
         if (this._rendered) {
             return;
         }
@@ -44,47 +40,45 @@ var Bar = (function (ChartElement) {
         if (this.errorBar) {
             this.append(this.errorBar);
         }
-    };
+    }
 
-    Bar.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);
         }
-    };
+    }
 
-    Bar.prototype.createLabelElement = function createLabelElement (options) {
+    createLabelElement(options) {
         return new BarLabel(this.getLabelText(options),
             deepExtend({
                 vertical: this.options.vertical
             },
             options
             ), this.pointData());
-    };
+    }
 
-    Bar.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);
-    };
+    }
 
-    Bar.prototype.formatValue = function formatValue (format) {
+    formatValue(format) {
         return this.owner.formatPointValue(this, format);
-    };
-
-    Bar.prototype.reflow = function reflow (targetBox) {
-        var this$1 = this;
+    }
 
+    reflow(targetBox) {
         this.render();
 
-        var label = this.label;
+        const label = this.label;
 
         this.box = targetBox;
 
@@ -98,27 +92,23 @@ var Bar = (function (ChartElement) {
         }
 
         if (this.errorBars) {
-            for (var i = 0; i < this.errorBars.length; i++) {
-                this$1.errorBars[i].reflow(targetBox);
+            for (let i = 0; i < this.errorBars.length; i++) {
+                this.errorBars[i].reflow(targetBox);
             }
         }
-    };
-
-    Bar.prototype.createVisual = function createVisual () {
-        var this$1 = this;
+    }
 
-        var ref = this;
-        var box = ref.box;
-        var options = ref.options;
-        var customVisual = options.visual;
+    createVisual() {
+        const { box, options } = this;
+        const customVisual = options.visual;
 
         if (this.visible !== false) {
-            ChartElement.prototype.createVisual.call(this);
+            super.createVisual();
 
             this.addAccessibilityAttributesToVisual();
 
             if (customVisual) {
-                var visual = this.rectVisual = customVisual({
+                const visual = this.rectVisual = customVisual({
                     category: this.category,
                     dataItem: this.dataItem,
                     value: this.value,
@@ -129,9 +119,9 @@ var Bar = (function (ChartElement) {
                     runningTotal: this.runningTotal,
                     total: this.total,
                     rect: box.toRect(),
-                    createVisual: function () {
-                        var group = new draw.Group();
-                        this$1.createRect(group);
+                    createVisual: () => {
+                        const group = new draw.Group();
+                        this.createRect(group);
                         return group;
                     },
                     options: options
@@ -144,17 +134,17 @@ var Bar = (function (ChartElement) {
                 this.createRect(this.visual);
             }
         }
-    };
+    }
 
-    Bar.prototype.createRect = function createRect (visual) {
-        var options = this.options;
-        var border = options.border;
-        var strokeOpacity = defined(border.opacity) ? border.opacity : options.opacity;
-        var rect = this.box.toRect();
+    createRect(visual) {
+        const options = this.options;
+        const border = options.border;
+        const strokeOpacity = defined(border.opacity) ? border.opacity : options.opacity;
+        const rect = this.box.toRect();
 
         rect.size.width = Math.round(rect.size.width);
 
-        var path = this.rectVisual = draw.Path.fromRect(rect, {
+        const path = this.rectVisual = draw.Path.fromRect(rect, {
             fill: createPatternFill(options.pattern, {
                 color: this.color,
                 opacity: options.opacity
@@ -167,10 +157,10 @@ var Bar = (function (ChartElement) {
             }
         });
 
-        var width = this.box.width();
-        var height = this.box.height();
+        const width = this.box.width();
+        const height = this.box.height();
 
-        var size = options.vertical ? width : height;
+        const size = options.vertical ? width : height;
 
         if (size > BAR_ALIGN_MIN_WIDTH) {
             alignPathToPixel(path);
@@ -184,61 +174,58 @@ var Bar = (function (ChartElement) {
         visual.append(path);
 
         if (hasGradientOverlay(options)) {
-            var overlay = this.createGradientOverlay(path, { baseColor: this.color }, deepExtend({
+            const overlay = this.createGradientOverlay(path, { baseColor: this.color }, deepExtend({
                 end: !options.vertical ? [ 0, 1 ] : undefined
             }, options.overlay));
 
             visual.append(overlay);
         }
-    };
+    }
 
-    Bar.prototype.createHighlight = function createHighlight (style) {
-        var highlight = draw.Path.fromRect(this.box.toRect(), style);
+    createHighlight(style) {
+        const highlight = draw.Path.fromRect(this.box.toRect(), style);
 
         return alignPathToPixel(highlight);
-    };
+    }
 
-    Bar.prototype.highlightVisual = function highlightVisual () {
+    highlightVisual() {
         return this.rectVisual;
-    };
+    }
 
-    Bar.prototype.highlightVisualArgs = function highlightVisualArgs () {
+    highlightVisualArgs() {
         return {
             options: this.options,
             rect: this.box.toRect(),
             visual: this.rectVisual
         };
-    };
+    }
 
-    Bar.prototype.createFocusHighlight = function createFocusHighlight (style) {
-        var borderWidth = this.options.focusHighlight.border.width;
-        var highlight = draw.Path.fromRect(this.box.pad(borderWidth / 2).toRect(), style);
+    createFocusHighlight(style) {
+        const borderWidth = this.options.focusHighlight.border.width;
+        const highlight = draw.Path.fromRect(this.box.pad(borderWidth / 2).toRect(), style);
 
         return alignPathToPixel(highlight);
-    };
+    }
 
-    Bar.prototype.getBorderColor = function getBorderColor () {
-        var color = this.color;
-        var border = this.options.border;
-        var brightness = border._brightness || BORDER_BRIGHTNESS;
-        var borderColor = border.color;
+    getBorderColor() {
+        const color = this.color;
+        const border = this.options.border;
+        const brightness = border._brightness || BORDER_BRIGHTNESS;
+        let borderColor = border.color;
 
         if (!defined(borderColor)) {
             borderColor = new Color(color).brightness(brightness).toHex();
         }
 
         return borderColor;
-    };
-
-    Bar.prototype.tooltipAnchor = function tooltipAnchor () {
-        var ref = this;
-        var options = ref.options;
-        var box = ref.box;
-        var aboveAxis = ref.aboveAxis;
-        var clipBox = this.owner.pane.clipBox() || box;
-        var horizontalAlign = LEFT;
-        var verticalAlign = TOP;
-        var x, y;
+    }
+
+    tooltipAnchor() {
+        const { options, box, aboveAxis } = this;
+        const clipBox = this.owner.pane.clipBox() || box;
+        let horizontalAlign = LEFT;
+        let verticalAlign = TOP;
+        let x, y;
 
         if (options.vertical) {
             x = Math.min(box.x2, clipBox.x2) + TOOLTIP_OFFSET;
@@ -249,8 +236,8 @@ var Bar = (function (ChartElement) {
                 verticalAlign = BOTTOM;
             }
         } else {
-            var x1 = Math.max(box.x1, clipBox.x1);
-            var x2 = Math.min(box.x2, clipBox.x2);
+            const x1 = Math.max(box.x1, clipBox.x1);
+            const x2 = Math.min(box.x2, clipBox.x2);
 
             if (options.isStacked) {
                 verticalAlign = BOTTOM;
@@ -279,13 +266,13 @@ var Bar = (function (ChartElement) {
                 vertical: verticalAlign
             }
         };
-    };
+    }
 
-    Bar.prototype.overlapsBox = function overlapsBox (box) {
+    overlapsBox(box) {
         return this.box.overlaps(box);
-    };
+    }
 
-    Bar.prototype.pointData = function pointData () {
+    pointData() {
         return {
             dataItem: this.dataItem,
             category: this.category,
@@ -296,14 +283,12 @@ var Bar = (function (ChartElement) {
             total: this.total,
             series: this.series
         };
-    };
+    }
 
-    Bar.prototype.getIndex = function getIndex () {
+    getIndex() {
         return this.categoryIx;
-    };
-
-    return Bar;
-}(ChartElement));
+    }
+}
 
 deepExtend(Bar.prototype, PointEventsMixin);
 deepExtend(Bar.prototype, NoteMixin);