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

package/dist/es/sankey/title.js

@@ -3,38 +3,27 @@ import { SankeyElement } from "./element";
 import { setDefaultOptions, getSpacing } from '../common';
 import { CENTER } from "../common/constants";
 
-export var Title = (function (SankeyElement) {
-    function Title () {
-        SankeyElement.apply(this, arguments);
-    }
-
-    if ( SankeyElement ) Title.__proto__ = SankeyElement;
-    Title.prototype = Object.create( SankeyElement && SankeyElement.prototype );
-    Title.prototype.constructor = Title;
-
-    Title.prototype.getElement = function getElement () {
-        var options = this.options;
-        var drawingRect = options.drawingRect;
-        var text = options.text;
+export class Title extends SankeyElement {
+    getElement() {
+        const options = this.options;
+        const { drawingRect, text } = options;
 
         if (options.visible === false || !text) {
             return null;
         }
 
-        var title = ChartTitle.buildTitle(text, options);
+        const title = ChartTitle.buildTitle(text, options);
 
         title.reflow(drawingRect);
 
         title.renderVisual();
         return title.visual;
-    };
+    }
 
-    Title.prototype.createElement = function createElement () {
+    createElement() {
         return this.getElement();
-    };
-
-    return Title;
-}(SankeyElement));
+    }
+}
 
 setDefaultOptions(Title, {
     align: CENTER, // 'left', 'right', 'center'

package/dist/es/sankey/utils.js

@@ -1,46 +1,41 @@
-export var createSankeyData = function (data, dimensions, measure) {
-    var nodes = new Set();
-    var links = new Map();
-    var linksMap = new Map();
+export const createSankeyData = (data, dimensions, measure) => {
+    const nodes = new Set();
+    const links = new Map();
+    const linksMap = new Map();
 
-    data.forEach(function (row) {
-        dimensions.forEach(function (dimension) {
+    data.forEach((row) => {
+        dimensions.forEach((dimension) => {
             nodes.add(dimension.value(row));
         });
 
-        for (var i = 0; i < dimensions.length - 1; i++) {
-            var source = dimensions[i].value(row);
-            var target = dimensions[i + 1].value(row);
-            var key = source + "_" + target;
-            var value = measure.value(row);
-            var existingValue = links.get(key);
+        for (let i = 0; i < dimensions.length - 1; i++) {
+            const source = dimensions[i].value(row);
+            const target = dimensions[i + 1].value(row);
+            const key = `${source}_${target}`;
+            const value = measure.value(row);
+            const existingValue = links.get(key);
 
             if (existingValue !== undefined) {
                 links.set(key, existingValue + value);
             } else {
                 links.set(key, value);
-                linksMap.set(key, { source: source, target: target });
+                linksMap.set(key, { source, target });
             }
         }
     });
 
-    var nodesId = new Map();
-    var nodesArray = Array.from(nodes).map(function (node, index) {
+    const nodesId = new Map();
+    const nodesArray = Array.from(nodes).map((node, index) => {
         nodesId.set(node, index);
         return { id: index, label: { text: String(node) } };
     });
 
-    var linksArray = Array.from(links).map(function (ref) {
-        var key = ref[0];
-        var value = ref[1];
-
-        var ref$1 = linksMap.get(key);
-        var source = ref$1.source;
-        var target = ref$1.target;
+    const linksArray = Array.from(links).map(([key, value]) => {
+        const { source, target } = linksMap.get(key);
         return {
             sourceId: nodesId.get(source),
             targetId: nodesId.get(target),
-            value: value
+            value
         };
     });
 

package/dist/es/services/chart-service.js

@@ -1,38 +1,34 @@
 import IntlService from './intl-service';
 import FormatService from './format-service';
 
-var ChartService = function ChartService(chart, context) {
-    if ( context === void 0 ) context = {};
-
-    this._intlService = context.intlService;
-    this.sender = context.sender || chart;
-    this.format = new FormatService(context.intlService);
-    this.chart = chart;
-    this.rtl = Boolean(context.rtl);
-};
-
-var prototypeAccessors = { intl: { configurable: true } };
-
-prototypeAccessors.intl.get = function () {
-    return this._intlService || IntlService.implementation;
-};
+class ChartService {
+    constructor(chart, context = {}) {
+        this._intlService = context.intlService;
+        this.sender = context.sender || chart;
+        this.format = new FormatService(context.intlService);
+        this.chart = chart;
+        this.rtl = Boolean(context.rtl);
+    }
 
-prototypeAccessors.intl.set = function (value) {
-    this._intlService = value;
-    this.format.intl = value;
-};
+    get intl() {
+        return this._intlService || IntlService.implementation;
+    }
 
-ChartService.prototype.notify = function notify (name, args) {
-    if (this.chart) {
-        this.chart.trigger(name, args);
+    set intl(value) {
+        this._intlService = value;
+        this.format.intl = value;
     }
-};
 
-ChartService.prototype.isPannable = function isPannable (axis) {
-    var pannable = ((this.chart || {}).options || {}).pannable;
-    return pannable && pannable.lock !== axis;
-};
+    notify(name, args) {
+        if (this.chart) {
+            this.chart.trigger(name, args);
+        }
+    }
 
-Object.defineProperties( ChartService.prototype, prototypeAccessors );
+    isPannable(axis) {
+        const pannable = ((this.chart || {}).options || {}).pannable;
+        return pannable && pannable.lock !== axis;
+    }
+}
 
 export default ChartService;

package/dist/es/services/dom-events-builder.js

@@ -1,25 +1,25 @@
 import { UserEvents } from '../common';
 
-var current;
+let current;
 
-var DomEventsBuilder = function DomEventsBuilder () {};
+class DomEventsBuilder {
+    static register(userImplementation) {
+        current = userImplementation;
+    }
 
-DomEventsBuilder.register = function register (userImplementation) {
-    current = userImplementation;
-};
+    static create(element, events) {
+        let builder;
 
-DomEventsBuilder.create = function create (element, events) {
-    var builder;
+        if (current) {
+            builder = current.create(element, events);
+        } else {
+            builder = new UserEvents(element, Object.assign({}, {multiTouch: true},
 
-    if (current) {
-        builder = current.create(element, events);
-    } else {
-        builder = new UserEvents(element, Object.assign({}, {multiTouch: true},
+                events));
+        }
 
-            events));
+        return builder;
     }
-
-    return builder;
-};
+}
 
 export default DomEventsBuilder;

package/dist/es/services/format-service.js

@@ -3,52 +3,47 @@ import { FORMAT_REGEX } from '../common/constants';
 import { isString } from '../common';
 
 // eslint-disable-next-line no-useless-escape
-var FORMAT_REPLACE_REGEX = /\{(\d+)(:[^\}]+)?\}/g;
+const FORMAT_REPLACE_REGEX = /\{(\d+)(:[^\}]+)?\}/g;
 
-var FormatService = function FormatService(intlService) {
-    this._intlService = intlService;
-};
-
-var prototypeAccessors = { intl: { configurable: true } };
+class FormatService {
+    constructor(intlService) {
+        this._intlService = intlService;
+    }
 
-prototypeAccessors.intl.get = function () {
-    return this._intlService || IntlService.implementation;
-};
+    get intl() {
+        return this._intlService || IntlService.implementation;
+    }
 
-prototypeAccessors.intl.set = function (value) {
-    this._intlService = value;
-};
+    set intl(value) {
+        this._intlService = value;
+    }
 
-FormatService.prototype.auto = function auto (formatString) {
-        var values = [], len = arguments.length - 1;
-        while ( len-- > 0 ) values[ len ] = arguments[ len + 1 ];
+    auto(formatString, ...values) {
+        const intl = this.intl;
 
-    var intl = this.intl;
+        if (isString(formatString) && formatString.match(FORMAT_REGEX)) {
+            return intl.format(formatString, ...values);
+        }
 
-    if (isString(formatString) && formatString.match(FORMAT_REGEX)) {
-        return intl.format.apply(intl, [ formatString ].concat( values ));
+        return intl.toString(values[0], formatString);
     }
 
-    return intl.toString(values[0], formatString);
-};
+    localeAuto(formatString, values, locale) {
+        const intl = this.intl;
+        let result;
 
-FormatService.prototype.localeAuto = function localeAuto (formatString, values, locale) {
-    var intl = this.intl;
-    var result;
+        if (isString(formatString) && formatString.match(FORMAT_REGEX)) {
+            result = formatString.replace(FORMAT_REPLACE_REGEX, function(match, index, placeholderFormat) {
+                let value = values[parseInt(index, 10)];
 
-    if (isString(formatString) && formatString.match(FORMAT_REGEX)) {
-        result = formatString.replace(FORMAT_REPLACE_REGEX, function(match, index, placeholderFormat) {
-            var value = values[parseInt(index, 10)];
+                return intl.toString(value, placeholderFormat ? placeholderFormat.substring(1) : "", locale);
+            });
+        } else {
+            result = intl.toString(values[0], formatString, locale);
+        }
 
-            return intl.toString(value, placeholderFormat ? placeholderFormat.substring(1) : "", locale);
-        });
-    } else {
-        result = intl.toString(values[0], formatString, locale);
+        return result;
     }
-
-    return result;
-};
-
-Object.defineProperties( FormatService.prototype, prototypeAccessors );
+}
 
 export default FormatService;

package/dist/es/services/intl-service.js

@@ -1,27 +1,23 @@
-var defaultImplementation = {
-    format: function (format, value) { return value; },
+const defaultImplementation = {
+    format: (format, value) => value,
 
-    toString: function (value) { return value; },
+    toString: (value) => value,
 
-    parseDate: function (value) { return new Date(value); },
+    parseDate: (value) => new Date(value),
 
-    firstDay: function () { return 0; }
+    firstDay: () => 0
 };
 
-var current = defaultImplementation;
+let current = defaultImplementation;
 
-var IntlService = function IntlService () {};
+class IntlService {
+    static register(userImplementation) {
+        current = userImplementation;
+    }
 
-var staticAccessors = { implementation: { configurable: true } };
-
-IntlService.register = function register (userImplementation) {
-    current = userImplementation;
-};
-
-staticAccessors.implementation.get = function () {
-    return current;
-};
-
-Object.defineProperties( IntlService, staticAccessors );
+    static get implementation() {
+        return current;
+    }
+}
 
 export default IntlService;

package/dist/es/services/map-service.js

@@ -1,15 +1,15 @@
-var MapService = function MapService(widget, context) {
-    if ( context === void 0 ) context = {};
-
-    this.sender = context.sender || widget;
-    this.widget = widget;
-    this.rtl = Boolean(context.rtl);
-};
+class MapService {
+    constructor(widget, context = {}) {
+        this.sender = context.sender || widget;
+        this.widget = widget;
+        this.rtl = Boolean(context.rtl);
+    }
 
-MapService.prototype.notify = function notify (name, args) {
-    if (this.widget) {
-        this.widget.trigger(name, args);
+    notify(name, args) {
+        if (this.widget) {
+            this.widget.trigger(name, args);
+        }
     }
-};
+}
 
 export default MapService;

package/dist/es/services/template-service.js

@@ -1,17 +1,17 @@
-var current = {
+let current = {
     compile: function(template) {
         return template;
     }
 };
 
-var TemplateService = function TemplateService () {};
-
-TemplateService.register = function register (userImplementation) {
-    current = userImplementation;
-};
+class TemplateService {
+    static register(userImplementation) {
+        current = userImplementation;
+    }
 
-TemplateService.compile = function compile (template, options) {
-    return current.compile(template, options);
-};
+    static compile(template, options) {
+        return current.compile(template, options);
+    }
+}
 
 export default TemplateService;

package/dist/es/sparkline/shared-tooltip.js

@@ -1,20 +1,12 @@
 import { SharedTooltip as ChartSharedTooltip } from '../chart';
 import { Point } from '../core';
-var TOP_OFFSET = -2;
+const TOP_OFFSET = -2;
 
-var SharedTooltip = (function (ChartSharedTooltip) {
-    function SharedTooltip () {
-        ChartSharedTooltip.apply(this, arguments);
-    }
-
-    if ( ChartSharedTooltip ) SharedTooltip.__proto__ = ChartSharedTooltip;
-    SharedTooltip.prototype = Object.create( ChartSharedTooltip && ChartSharedTooltip.prototype );
-    SharedTooltip.prototype.constructor = SharedTooltip;
-
-    SharedTooltip.prototype._slotAnchor = function _slotAnchor (coords, slot) {
-        var axis = this.plotArea.categoryAxis;
-        var vertical = axis.options.vertical;
-        var align = vertical ? {
+class SharedTooltip extends ChartSharedTooltip {
+    _slotAnchor(coords, slot) {
+        const axis = this.plotArea.categoryAxis;
+        const vertical = axis.options.vertical;
+        const align = vertical ? {
             horizontal: "left",
             vertical: "center"
         } : {
@@ -22,7 +14,7 @@ var SharedTooltip = (function (ChartSharedTooltip) {
             vertical: "bottom"
         };
 
-        var point;
+        let point;
 
         if (vertical) {
             point = new Point(this.plotArea.box.x2, slot.center().y);
@@ -34,13 +26,11 @@ var SharedTooltip = (function (ChartSharedTooltip) {
             point: point,
             align: align
         };
-    };
+    }
 
-    SharedTooltip.prototype._defaultAnchor = function _defaultAnchor (point, slot) {
+    _defaultAnchor(point, slot) {
         return this._slotAnchor({}, slot);
-    };
-
-    return SharedTooltip;
-}(ChartSharedTooltip));
+    }
+}
 
 export default SharedTooltip;

package/dist/es/sparkline/sparkline.js

@@ -3,14 +3,14 @@ import { BAR, BULLET, PIE, COLUMN, VERTICAL_BULLET } from '../chart/constants';
 import { addClass, deepExtend, elementSize, getSpacing, inArray, isArray, isNumber, setDefaultOptions } from '../common';
 import SharedTooltip from './shared-tooltip';
 
-var DEAULT_BAR_WIDTH = 150;
-var DEAULT_BULLET_WIDTH = 150;
-var NO_CROSSHAIR = [ BAR, BULLET ];
+const DEAULT_BAR_WIDTH = 150;
+const DEAULT_BULLET_WIDTH = 150;
+const NO_CROSSHAIR = [ BAR, BULLET ];
 
 function hide(children) {
-    var state = [];
-    for (var idx = 0; idx < children.length; idx++) {
-        var child = children[idx];
+    const state = [];
+    for (let idx = 0; idx < children.length; idx++) {
+        const child = children[idx];
         state[idx] = child.style.display;
         child.style.display = "none";
     }
@@ -19,7 +19,7 @@ function hide(children) {
 }
 
 function show(children, state) {
-    for (var idx = 0; idx < children.length; idx++) {
+    for (let idx = 0; idx < children.length; idx++) {
         children[idx].style.display = state[idx];
     }
 }
@@ -28,47 +28,39 @@ function wrapNumber(value) {
     return isNumber(value) ? [ value ] : value;
 }
 
-var Sparkline = (function (Chart) {
-    function Sparkline () {
-        Chart.apply(this, arguments);
-    }
-
-    if ( Chart ) Sparkline.__proto__ = Chart;
-    Sparkline.prototype = Object.create( Chart && Chart.prototype );
-    Sparkline.prototype.constructor = Sparkline;
-
-    Sparkline.prototype._setElementClass = function _setElementClass (element) {
+class Sparkline extends Chart {
+    _setElementClass(element) {
         addClass(element, 'k-sparkline');
-    };
+    }
 
-    Sparkline.prototype._initElement = function _initElement (element) {
-        Chart.prototype._initElement.call(this, element);
+    _initElement(element) {
+        super._initElement(element);
 
         this._initialWidth = Math.floor(elementSize(element).width);
-    };
+    }
 
-    Sparkline.prototype._resize = function _resize () {
-        var element = this.element;
-        var state = hide(element.childNodes);
+    _resize() {
+        const element = this.element;
+        const state = hide(element.childNodes);
 
         this._initialWidth = Math.floor(elementSize(element).width);
 
         show(element.childNodes, state);
 
-        Chart.prototype._resize.call(this);
-    };
+        super._resize();
+    }
 
-    Sparkline.prototype._modelOptions = function _modelOptions () {
-        var chartOptions = this.options;
-        var stage = this._surfaceWrap();
-        var displayState = hide(stage.childNodes);
+    _modelOptions() {
+        const chartOptions = this.options;
+        const stage = this._surfaceWrap();
+        const displayState = hide(stage.childNodes);
 
-        var space = document.createElement('span');
+        const space = document.createElement('span');
         space.innerHTML = '&nbsp;';
 
         stage.appendChild(space);
 
-        var options = deepExtend({
+        const options = deepExtend({
             width: this._autoWidth,
             height: elementSize(stage).height,
             transitions: chartOptions.transitions
@@ -91,34 +83,34 @@ var Sparkline = (function (Chart) {
         }
 
         return options;
-    };
+    }
 
-    Sparkline.prototype._surfaceWrap = function _surfaceWrap () {
+    _surfaceWrap() {
         if (!this.stage) {
-            var stage = this.stage = document.createElement('span');
+            const stage = this.stage = document.createElement('span');
             this.element.appendChild(stage);
         }
         return this.stage;
-    };
+    }
 
-    Sparkline.prototype._createPlotArea = function _createPlotArea (skipSeries) {
-        var plotArea = Chart.prototype._createPlotArea.call(this, skipSeries);
+    _createPlotArea(skipSeries) {
+        const plotArea = super._createPlotArea(skipSeries);
         this._autoWidth = this._initialWidth || this._calculateWidth(plotArea);
 
         return plotArea;
-    };
+    }
 
-    Sparkline.prototype._calculateWidth = function _calculateWidth (plotArea) {
-        var options = this.options;
-        var margin = getSpacing(options.chartArea.margin);
-        var charts = plotArea.charts;
-        var stage = this._surfaceWrap();
-        var total = 0;
+    _calculateWidth(plotArea) {
+        const options = this.options;
+        const margin = getSpacing(options.chartArea.margin);
+        const charts = plotArea.charts;
+        const stage = this._surfaceWrap();
+        let total = 0;
 
 
-        for (var i = 0; i < charts.length; i++) {
-            var currentChart = charts[i];
-            var firstSeries = (currentChart.options.series || [])[0];
+        for (let i = 0; i < charts.length; i++) {
+            const currentChart = charts[i];
+            const firstSeries = (currentChart.options.series || [])[0];
             if (!firstSeries) {
                 continue;
             }
@@ -135,29 +127,29 @@ var Sparkline = (function (Chart) {
                 return elementSize(stage).height;
             }
 
-            var categoryAxis = currentChart.categoryAxis;
+            const categoryAxis = currentChart.categoryAxis;
             if (categoryAxis) {
-                var pointsCount = categoryAxis.categoriesCount() *
+                const pointsCount = categoryAxis.categoriesCount() *
                     (!currentChart.options.isStacked && inArray(firstSeries.type, [ COLUMN, VERTICAL_BULLET ]) ? currentChart.seriesOptions.length : 1);
 
                 total = Math.max(total, pointsCount);
             }
         }
 
-        var size = total * options.pointWidth;
+        let size = total * options.pointWidth;
         if (size > 0) {
             size += margin.left + margin.right;
         }
 
         return size;
-    };
+    }
 
-    Sparkline.prototype._createSharedTooltip = function _createSharedTooltip (options) {
+    _createSharedTooltip(options) {
         return new SharedTooltip(this._plotArea, options);
-    };
+    }
 
-    Sparkline.normalizeOptions = function normalizeOptions (userOptions) {
-        var options = wrapNumber(userOptions);
+    static normalizeOptions(userOptions) {
+        let options = wrapNumber(userOptions);
 
         if (isArray(options)) {
             options = { seriesDefaults: { data: options } };
@@ -187,10 +179,8 @@ var Sparkline = (function (Chart) {
         }
 
         return options;
-    };
-
-    return Sparkline;
-}(Chart));
+    }
+}
 
 setDefaultOptions(Sparkline, {
     chartArea: {

package/dist/es/stock/constants.js

@@ -1,5 +1,5 @@
-var NAVIGATOR_PANE = "_navigator";
-var NAVIGATOR_AXIS = NAVIGATOR_PANE;
-var DEFAULT_PANE = "_default";
+const NAVIGATOR_PANE = "_navigator";
+const NAVIGATOR_AXIS = NAVIGATOR_PANE;
+const DEFAULT_PANE = "_default";
 
 export { NAVIGATOR_AXIS, NAVIGATOR_PANE, DEFAULT_PANE };