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

package/dist/es/chart/legend/legend.js

@@ -6,13 +6,11 @@ import LegendItem from './legend-item';
 import { TOP, RIGHT, BOTTOM, LEFT, CENTER, X, Y, BLACK, CIRCLE, POINTER, START, END, HORIZONTAL, SQUARE } from '../../common/constants';
 import { deepExtend, defined, getTemplate, getSpacing, inArray, setDefaultOptions } from '../../common';
 
-var CUSTOM = "custom";
+const CUSTOM = "custom";
 
-var Legend = (function (ChartElement) {
-    function Legend(options, chartService) {
-        if ( chartService === void 0 ) chartService = {};
-
-        ChartElement.call(this, options);
+class Legend extends ChartElement {
+    constructor(options, chartService = {}) {
+        super(options);
 
         this.chartService = chartService;
 
@@ -27,16 +25,11 @@ var Legend = (function (ChartElement) {
         this.createItems();
     }
 
-    if ( ChartElement ) Legend.__proto__ = ChartElement;
-    Legend.prototype = Object.create( ChartElement && ChartElement.prototype );
-    Legend.prototype.constructor = Legend;
-
-    Legend.prototype.createContainers = function createContainers () {
-        var options = this.options;
-        var position = options.position;
-        var userAlign = options.align;
-        var align = position;
-        var vAlign = CENTER;
+    createContainers() {
+        const options = this.options;
+        const { position, align: userAlign } = options;
+        let align = position;
+        let vAlign = CENTER;
 
         if (position === CUSTOM) {
             align = LEFT;
@@ -80,36 +73,32 @@ var Legend = (function (ChartElement) {
         }
 
         this.append(this.container);
-    };
+    }
 
-    Legend.prototype.createItems = function createItems () {
-        var chartService = this.getService();
-        var options = this.options;
-        var vertical = this.isVertical();
-        var innerElement = new LegendLayout({
+    createItems() {
+        const chartService = this.getService();
+        const options = this.options;
+        const vertical = this.isVertical();
+        const innerElement = new LegendLayout({
             vertical: vertical,
             spacing: options.spacing,
             rtl: chartService.rtl
         }, chartService);
-        var data = options.data;
+        let data = options.data;
 
         if (options.reverse) {
             data = data.slice(0).reverse();
         }
 
-        var count = data.length;
+        const count = data.length;
 
-        for (var i = 0; i < count; i++) {
-            var dataItem = data[i];
-            var ref = dataItem.series || {};
-            var markers = ref.markers; if ( markers === void 0 ) markers = {};
-            var dashType = ref.dashType;
-            var legendItem = ref.legendItem;
-            var opacity = ref.opacity;
-            var markersOptions = deepExtend({ visible: markers.visible !== false, type: CIRCLE }, markers);
+        for (let i = 0; i < count; i++) {
+            let dataItem = data[i];
+            const { markers = {}, dashType, legendItem, opacity } = dataItem.series || {};
+            const markersOptions = deepExtend({ visible: markers.visible !== false, type: CIRCLE }, markers);
             delete markersOptions.size;
 
-            var itemOptions = deepExtend({},
+            const itemOptions = deepExtend({},
                 {
                     markers: markersOptions,
                     labels: options.labels,
@@ -133,29 +122,27 @@ var Legend = (function (ChartElement) {
 
         innerElement.render();
         this.itemsContainer.append(innerElement);
-    };
+    }
 
-    Legend.prototype.isVertical = function isVertical () {
-        var ref = this.options;
-        var orientation = ref.orientation;
-        var position = ref.position;
-        var vertical = (position === CUSTOM && orientation !== HORIZONTAL) ||
+    isVertical() {
+        const { orientation, position } = this.options;
+        const vertical = (position === CUSTOM && orientation !== HORIZONTAL) ||
                (defined(orientation) ? orientation !== HORIZONTAL : inArray(position, [ LEFT, RIGHT ]));
 
         return vertical;
-    };
+    }
 
-    Legend.prototype.hasItems = function hasItems () {
+    hasItems() {
         return this.container.children[0].children.length > 0;
-    };
+    }
 
-    Legend.prototype.getItems = function getItems () {
+    getItems() {
         return this.itemsContainer.children[0].children;
-    };
+    }
 
-    Legend.prototype.reflow = function reflow (targetBox) {
-        var options = this.options;
-        var legendBox = targetBox.clone();
+    reflow(targetBox) {
+        const options = this.options;
+        const legendBox = targetBox.clone();
 
         if (!this.hasItems()) {
             this.box = legendBox;
@@ -172,19 +159,15 @@ var Legend = (function (ChartElement) {
         if (this.hasTitle()) {
             this.title.reflow(new Box(this.container.box.x1, this.title.box.y1, this.container.box.x2, this.title.box.y2));
         }
-    };
-
-    Legend.prototype.containerReflow = function containerReflow (targetBox) {
-        var ref = this;
-        var options = ref.options;
-        var container = ref.container;
-        var position = options.position;
-        var width = options.width;
-        var height = options.height;
-        var pos = position === TOP || position === BOTTOM ? X : Y;
-        var vertical = this.isVertical();
-        var alignTarget = targetBox.clone();
-        var containerBox = targetBox.clone();
+    }
+
+    containerReflow(targetBox) {
+        const { options, container } = this;
+        const { position, width, height } = options;
+        const pos = position === TOP || position === BOTTOM ? X : Y;
+        const vertical = this.isVertical();
+        const alignTarget = targetBox.clone();
+        let containerBox = targetBox.clone();
 
         if (position === LEFT || position === RIGHT) {
             containerBox.y1 = alignTarget.y1 = 0;
@@ -201,7 +184,7 @@ var Legend = (function (ChartElement) {
         container.reflow(containerBox);
         containerBox = container.box;
 
-        var box = containerBox.clone();
+        const box = containerBox.clone();
 
         if (options.offsetX || options.offsetY) {
             containerBox.translate(options.offsetX, options.offsetY);
@@ -212,18 +195,13 @@ var Legend = (function (ChartElement) {
         box[pos + 2] = targetBox[pos + 2];
 
         this.box = box;
-    };
-
-    Legend.prototype.containerCustomReflow = function containerCustomReflow (targetBox) {
-        var ref = this;
-        var options = ref.options;
-        var container = ref.container;
-        var offsetX = options.offsetX;
-        var offsetY = options.offsetY;
-        var width = options.width;
-        var height = options.height;
-        var vertical = this.isVertical();
-        var containerBox = targetBox.clone();
+    }
+
+    containerCustomReflow(targetBox) {
+        const { options, container } = this;
+        const { offsetX, offsetY, width, height } = options;
+        const vertical = this.isVertical();
+        let containerBox = targetBox.clone();
 
         if (vertical && height) {
             containerBox.y2 = containerBox.y1 + height;
@@ -237,28 +215,28 @@ var Legend = (function (ChartElement) {
             offsetX, offsetY,
             offsetX + containerBox.width(), offsetY + containerBox.height()
         ));
-    };
+    }
 
-    Legend.prototype.renderVisual = function renderVisual () {
+    renderVisual() {
         if (this.hasItems()) {
-            ChartElement.prototype.renderVisual.call(this);
+            super.renderVisual();
         }
-    };
+    }
 
-    Legend.prototype.createLegendTitle = function createLegendTitle (title) {
-        var titleOptions = deepExtend({}, {
+    createLegendTitle(title) {
+        let titleOptions = deepExtend({}, {
             color: BLACK,
             position: TOP,
             align: CENTER
         }, title);
-        var text = titleOptions.text;
+        let text = titleOptions.text;
 
         if (!title || title.visible === false || !title.text) {
             return;
         }
 
         if (defined(titleOptions) && titleOptions.visible) {
-            var labelTemplate = getTemplate(titleOptions);
+            const labelTemplate = getTemplate(titleOptions);
             if (labelTemplate) {
                 text = labelTemplate({ text: text });
             } else if (titleOptions.format) {
@@ -271,23 +249,23 @@ var Legend = (function (ChartElement) {
         this.createTitleLayout();
 
         this.appendTitleLayoutContent();
-    };
+    }
 
-    Legend.prototype.createTitleLayout = function createTitleLayout () {
+    createTitleLayout() {
         this.layout = new FloatElement({
             vertical: true,
             wrap: false
         });
 
         this.container.append(this.layout);
-    };
+    }
 
-    Legend.prototype.hasTitle = function hasTitle () {
+    hasTitle() {
         return Boolean(this.options.title && this.options.title.visible !== false && this.options.title.text);
-    };
+    }
 
-    Legend.prototype.appendTitleLayoutContent = function appendTitleLayoutContent () {
-        var options = this.options;
+    appendTitleLayoutContent() {
+        const options = this.options;
 
         if (options.title.position === BOTTOM) {
             this.layout.append(this.itemsContainer);
@@ -296,10 +274,8 @@ var Legend = (function (ChartElement) {
             this.layout.append(this.title);
             this.layout.append(this.itemsContainer);
         }
-    };
-
-    return Legend;
-}(ChartElement));
+    }
+}
 
 setDefaultOptions(Legend, {
     position: RIGHT,

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

@@ -10,32 +10,23 @@ import { ZERO, SMOOTH, STEP } from '../constants';
 
 import { deepExtend, defined, isFunction } from '../../common';
 
-var LineChart = (function (CategoricalChart) {
-    function LineChart () {
-        CategoricalChart.apply(this, arguments);
-    }
-
-    if ( CategoricalChart ) LineChart.__proto__ = CategoricalChart;
-    LineChart.prototype = Object.create( CategoricalChart && CategoricalChart.prototype );
-    LineChart.prototype.constructor = LineChart;
-
-    LineChart.prototype.render = function render () {
+class LineChart extends CategoricalChart {
+    render() {
 
-        CategoricalChart.prototype.render.call(this);
+        super.render();
 
         this.updateStackRange();
         this.renderSegments();
-    };
+    }
 
-    LineChart.prototype.pointType = function pointType () {
+    pointType() {
         return LinePoint;
-    };
+    }
 
-    LineChart.prototype.createPoint = function createPoint (data, fields) {
-        var series = fields.series;
-        var seriesIx = fields.seriesIx;
-        var missingValues = this.seriesMissingValues(series);
-        var value = data.valueFields.value;
+    createPoint(data, fields) {
+        const { series, seriesIx } = fields;
+        const missingValues = this.seriesMissingValues(series);
+        let value = data.valueFields.value;
 
         if (!defined(value) || value === null) {
             if (missingValues === ZERO) {
@@ -45,41 +36,39 @@ var LineChart = (function (CategoricalChart) {
             }
         }
 
-        var pointOptions = this.pointOptions(series, seriesIx);
+        let pointOptions = this.pointOptions(series, seriesIx);
         pointOptions = this.evalPointOptions(pointOptions, value, fields);
 
-        var color = data.fields.color || series.color;
+        let color = data.fields.color || series.color;
         if (isFunction(series.color)) {
             color = pointOptions.color;
         }
 
-        var point = new LinePoint(value, pointOptions);
+        const point = new LinePoint(value, pointOptions);
         point.color = color;
 
         this.append(point);
 
         return point;
-    };
-
-    LineChart.prototype.plotRange = function plotRange (point) {
-        var this$1 = this;
+    }
 
-        var plotValue = this.plotValue(point);
+    plotRange(point) {
+        let plotValue = this.plotValue(point);
 
         if (this.options.isStacked) {
-            var categoryIx = point.categoryIx;
-            var categoryPoints = this.categoryPoints[categoryIx];
+            const categoryIx = point.categoryIx;
+            const categoryPoints = this.categoryPoints[categoryIx];
 
-            for (var i = 0; i < categoryPoints.length; i++) {
-                var other = categoryPoints[i];
+            for (let i = 0; i < categoryPoints.length; i++) {
+                const other = categoryPoints[i];
 
                 if (point === other) {
                     break;
                 }
 
-                plotValue += this$1.plotValue(other);
+                plotValue += this.plotValue(other);
 
-                if (this$1.options.isStacked100) {
+                if (this.options.isStacked100) {
                     plotValue = Math.min(plotValue, 1);
                 }
             }
@@ -87,11 +76,11 @@ var LineChart = (function (CategoricalChart) {
         }
 
         return [ plotValue, plotValue ];
-    };
+    }
 
-    LineChart.prototype.createSegment = function createSegment (linePoints, currentSeries, seriesIx) {
-        var style = currentSeries.style;
-        var pointType;
+    createSegment(linePoints, currentSeries, seriesIx) {
+        const style = currentSeries.style;
+        let pointType;
 
         if (style === STEP) {
             pointType = StepLineSegment;
@@ -102,23 +91,21 @@ var LineChart = (function (CategoricalChart) {
         }
 
         return new pointType(linePoints, currentSeries, seriesIx);
-    };
+    }
 
-    LineChart.prototype.animationPoints = function animationPoints () {
-        var points = this.points;
-        var result = [];
-        for (var idx = 0; idx < points.length; idx++) {
+    animationPoints() {
+        const points = this.points;
+        const result = [];
+        for (let idx = 0; idx < points.length; idx++) {
             result.push((points[idx] || {}).marker);
         }
         return result.concat(this._segments);
-    };
+    }
 
-    LineChart.prototype.supportsPointInactiveOpacity = function supportsPointInactiveOpacity () {
+    supportsPointInactiveOpacity() {
         return false;
-    };
-
-    return LineChart;
-}(CategoricalChart));
+    }
+}
 
 deepExtend(LineChart.prototype, LineChartMixin, ClipAnimationMixin);