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

package/dist/es/core/text-box.js

@@ -10,11 +10,12 @@ import rectToBox from './utils/rect-to-box';
 import { getSpacing, deepExtend, defined } from '../common';
 import { X, Y } from '../common/constants';
 
-var ROWS_SPLIT_REGEX = /\n/m;
+const ROWS_SPLIT_REGEX = /\n/m;
 
-var TextBox = (function (BoxElement) {
-    function TextBox(content, options, data) {
-        BoxElement.call(this, options);
+class TextBox extends BoxElement {
+
+    constructor(content, options, data) {
+        super(options);
         this.content = content;
         this.data = data;
 
@@ -24,39 +25,35 @@ var TextBox = (function (BoxElement) {
         }
     }
 
-    if ( BoxElement ) TextBox.__proto__ = BoxElement;
-    TextBox.prototype = Object.create( BoxElement && BoxElement.prototype );
-    TextBox.prototype.constructor = TextBox;
-
-    TextBox.prototype._initContainer = function _initContainer () {
-        var options = this.options;
-        var rows = String(this.content).split(ROWS_SPLIT_REGEX);
-        var floatElement = new FloatElement({ vertical: true, align: options.align, wrap: false });
-        var textOptions = deepExtend({ }, options, { opacity: 1, animation: null });
+    _initContainer() {
+        const options = this.options;
+        const rows = String(this.content).split(ROWS_SPLIT_REGEX);
+        const floatElement = new FloatElement({ vertical: true, align: options.align, wrap: false });
+        const textOptions = deepExtend({ }, options, { opacity: 1, animation: null });
 
         this.container = floatElement;
         this.append(floatElement);
 
-        for (var rowIdx = 0; rowIdx < rows.length; rowIdx++) {
-            var text = new Text(rows[rowIdx].trim(), textOptions);
+        for (let rowIdx = 0; rowIdx < rows.length; rowIdx++) {
+            let text = new Text(rows[rowIdx].trim(), textOptions);
             floatElement.append(text);
         }
-    };
+    }
 
-    TextBox.prototype.reflow = function reflow (targetBox) {
-        var options = this.options;
-        var visualFn = options.visual;
+    reflow(targetBox) {
+        const options = this.options;
+        const visualFn = options.visual;
         this.container.options.align = options.align;
 
         if (visualFn && !this._boxReflow) {
-            var visualBox = targetBox;
+            let visualBox = targetBox;
             if (!visualBox.hasSize()) {
                 this._boxReflow = true;
                 this.reflow(visualBox);
                 this._boxReflow = false;
                 visualBox = this.box;
             }
-            var visual = this.visual = visualFn(this.visualContext(visualBox));
+            const visual = this.visual = visualFn(this.visualContext(visualBox));
 
             if (visual) {
                 visualBox = rectToBox(visual.clippedBBox() || new geom.Rect());
@@ -66,11 +63,11 @@ var TextBox = (function (BoxElement) {
 
             this.box = this.contentBox = this.paddingBox = visualBox;
         } else {
-            BoxElement.prototype.reflow.call(this, targetBox);
+            super.reflow(targetBox);
 
             if (options.rotation) {
-                var margin = getSpacing(options.margin);
-                var box = this.box.unpad(margin);
+                const margin = getSpacing(options.margin);
+                let box = this.box.unpad(margin);
 
                 this.targetBox = targetBox;
                 this.normalBox = box.clone();
@@ -83,10 +80,10 @@ var TextBox = (function (BoxElement) {
                 box.pad(margin);
             }
         }
-    };
+    }
 
-    TextBox.prototype.createVisual = function createVisual () {
-        var options = this.options;
+    createVisual() {
+        const options = this.options;
 
         this.visual = new draw.Group({
             transform: this.rotationTransform(),
@@ -95,41 +92,39 @@ var TextBox = (function (BoxElement) {
         });
 
         if (this.hasBox()) {
-            var box = draw.Path.fromRect(this.paddingBox.toRect(), this.visualStyle());
+            const box = draw.Path.fromRect(this.paddingBox.toRect(), this.visualStyle());
             this.visual.append(box);
         }
-    };
+    }
 
-    TextBox.prototype.renderVisual = function renderVisual () {
+    renderVisual() {
         if (!this.options.visible) {
             return;
         }
 
         if (this.options.visual) {
-            var visual = this.visual;
+            const visual = this.visual;
             if (visual && !defined(visual.options.noclip)) {
                 visual.options.noclip = this.options.noclip;
             }
             this.addVisual();
             this.createAnimation();
         } else {
-            BoxElement.prototype.renderVisual.call(this);
+            super.renderVisual();
         }
-    };
-
-    TextBox.prototype.visualContext = function visualContext (targetBox) {
-        var this$1 = this;
+    }
 
-        var context = {
+    visualContext(targetBox) {
+        const context = {
             text: this.content,
             rect: targetBox.toRect(),
             sender: this.getSender(),
             options: this.options,
-            createVisual: function () {
-                this$1._boxReflow = true;
-                this$1.reflow(targetBox);
-                this$1._boxReflow = false;
-                return this$1.getDefaultVisual();
+            createVisual: () => {
+                this._boxReflow = true;
+                this.reflow(targetBox);
+                this._boxReflow = false;
+                return this.getDefaultVisual();
             }
         };
         if (this.data) {
@@ -137,41 +132,37 @@ var TextBox = (function (BoxElement) {
         }
 
         return context;
-    };
+    }
 
-    TextBox.prototype.getDefaultVisual = function getDefaultVisual () {
+    getDefaultVisual() {
         this.createVisual();
         this.renderChildren();
-        var visual = this.visual;
+        const visual = this.visual;
         delete this.visual;
         return visual;
-    };
+    }
 
-    TextBox.prototype.rotate = function rotate () {
-        var options = this.options;
+    rotate() {
+        const options = this.options;
         this.box.rotate(options.rotation);
         this.align(this.targetBox, X, options.align);
         this.align(this.targetBox, Y, options.vAlign);
         return this.box;
-    };
+    }
 
-    TextBox.prototype.rotationTransform = function rotationTransform () {
-        var rotation = this.options.rotation;
+    rotationTransform() {
+        const rotation = this.options.rotation;
         if (!rotation) {
             return null;
         }
 
-        var ref = this.normalBox.center();
-        var cx = ref.x;
-        var cy = ref.y;
-        var boxCenter = this.rotatedBox.center();
+        const { x: cx, y: cy } = this.normalBox.center();
+        const boxCenter = this.rotatedBox.center();
 
         return geom.transform()
             .translate(boxCenter.x - cx, boxCenter.y - cy)
             .rotate(rotation, [ cx, cy ]);
-    };
-
-    return TextBox;
-}(BoxElement));
+    }
+}
 
 export default TextBox;

package/dist/es/core/text.js

@@ -6,11 +6,12 @@ import Box from './box';
 import { DEFAULT_FONT, BLACK } from '../common/constants';
 import { setDefaultOptions } from '../common';
 
-var DrawingText = draw.Text;
+const DrawingText = draw.Text;
 
-var Text = (function (ChartElement) {
-    function Text(content, options) {
-        ChartElement.call(this, options);
+class Text extends ChartElement {
+
+    constructor(content, options) {
+        super(options);
 
         this.content = content;
 
@@ -18,28 +19,18 @@ var Text = (function (ChartElement) {
         this.reflow(new Box());
     }
 
-    if ( ChartElement ) Text.__proto__ = ChartElement;
-    Text.prototype = Object.create( ChartElement && ChartElement.prototype );
-    Text.prototype.constructor = Text;
-
-    Text.prototype.reflow = function reflow (targetBox) {
-        var options = this.options;
-        var size = options.size = draw.util.measureText(this.content, { font: options.font });
+    reflow(targetBox) {
+        const options = this.options;
+        const size = options.size = draw.util.measureText(this.content, { font: options.font });
 
         this.baseline = size.baseline;
 
         this.box = new Box(targetBox.x1, targetBox.y1,
             targetBox.x1 + size.width, targetBox.y1 + size.height);
-    };
+    }
 
-    Text.prototype.createVisual = function createVisual () {
-        var ref = this.options;
-        var font = ref.font;
-        var color = ref.color;
-        var opacity = ref.opacity;
-        var cursor = ref.cursor;
-        var stroke = ref.stroke;
-        var paintOrder = ref.paintOrder;
+    createVisual() {
+        const { font, color, opacity, cursor, stroke, paintOrder } = this.options;
 
         this.visual = new DrawingText(this.content, this.box.toRect().topLeft(), {
             font: font,
@@ -48,10 +39,8 @@ var Text = (function (ChartElement) {
             stroke: stroke,
             paintOrder: paintOrder
         });
-    };
-
-    return Text;
-}(ChartElement));
+    }
+}
 
 setDefaultOptions(Text, {
     font: DEFAULT_FONT,

package/dist/es/core/title.js

@@ -4,9 +4,9 @@ import TextBox from './text-box';
 import { X, BLACK, TOP, CENTER, BOTTOM } from '../common/constants';
 import { getSpacing, setDefaultOptions } from '../common';
 
-var Title = (function (ChartElement) {
-    function Title(options) {
-        ChartElement.call(this, options);
+class Title extends ChartElement {
+    constructor(options) {
+        super(options);
 
         this._textBox = new TextBox(this.options.text, Object.assign({}, this.options, {
             vAlign: this.options.position
@@ -15,17 +15,13 @@ var Title = (function (ChartElement) {
         this.append(this._textBox);
     }
 
-    if ( ChartElement ) Title.__proto__ = ChartElement;
-    Title.prototype = Object.create( ChartElement && ChartElement.prototype );
-    Title.prototype.constructor = Title;
-
-    Title.prototype.reflow = function reflow (targetBox) {
-        ChartElement.prototype.reflow.call(this, targetBox);
+    reflow(targetBox) {
+        super.reflow(targetBox);
         this.box.snapTo(targetBox, X);
-    };
+    }
 
-    Title.buildTitle = function buildTitle (options, defaultOptions) {
-        var titleOptions = options;
+    static buildTitle(options, defaultOptions) {
+        let titleOptions = options;
 
         if (typeof options === "string") {
             titleOptions = { text: options };
@@ -33,33 +29,31 @@ var Title = (function (ChartElement) {
 
         titleOptions = Object.assign({ visible: true }, defaultOptions, titleOptions);
 
-        var title;
+        let title;
         if (titleOptions && titleOptions.visible && titleOptions.text) {
             title = new Title(titleOptions);
         }
 
         return title;
-    };
+    }
 
-    Title.orderTitles = function orderTitles (titles) {
-        var items = [].concat(titles);
-        var top = items.filter(function (item) { return item && item.options.position !== BOTTOM; });
-        var bottom = items.filter(function (item) { return item && item.options.position === BOTTOM; });
+    static orderTitles(titles) {
+        const items = [].concat(titles);
+        const top = items.filter(item => item && item.options.position !== BOTTOM);
+        const bottom = items.filter(item => item && item.options.position === BOTTOM);
 
         collapseVerticalMargins(top);
         collapseVerticalMargins(bottom);
 
         bottom.reverse();
         return top.concat(bottom);
-    };
-
-    return Title;
-}(ChartElement));
+    }
+}
 
 function collapseVerticalMargins(items) {
-    for (var i = 1; i < items.length; i++) {
-        var box = items[i]._textBox;
-        var prevBox = items[i - 1]._textBox;
+    for (let i = 1; i < items.length; i++) {
+        const box = items[i]._textBox;
+        const prevBox = items[i - 1]._textBox;
         prevBox.options.margin = Object.assign(getSpacing(prevBox.options.margin), { bottom: 0 });
         box.options.margin = Object.assign(getSpacing(box.options.margin), { top: 0 });
     }

package/dist/es/core/utils/auto-axis-max.js

@@ -5,12 +5,12 @@ export default function autoAxisMax(min, max, narrow) {
         return 1;
     }
 
-    var axisMax;
+    let axisMax;
 
     if (min <= 0 && max <= 0) {
-        var maxValue = min === max ? 0 : max;
+        const maxValue = min === max ? 0 : max;
 
-        var diff = Math.abs((maxValue - min) / maxValue);
+        let diff = Math.abs((maxValue - min) / maxValue);
         if (narrow === false || (!narrow && diff > ZERO_THRESHOLD)) {
             return 0;
         }

package/dist/es/core/utils/auto-axis-min.js

@@ -5,12 +5,12 @@ export default function autoAxisMin(min, max, narrow) {
         return 0;
     }
 
-    var axisMin;
+    let axisMin;
 
     if (min >= 0 && max >= 0) {
-        var minValue = min === max ? 0 : min;
+        const minValue = min === max ? 0 : min;
 
-        var diff = (max - minValue) / max;
+        let diff = (max - minValue) / max;
         if (narrow === false || (!narrow && diff > ZERO_THRESHOLD)) {
             return 0;
         }

package/dist/es/core/utils/auto-major-unit.js

@@ -2,7 +2,7 @@ import { DEFAULT_PRECISION } from '../../common/constants';
 import { round } from '../../common';
 
 export default function autoMajorUnit(min, max) {
-    var diff = round(max - min, DEFAULT_PRECISION - 1);
+    let diff = round(max - min, DEFAULT_PRECISION - 1);
 
     if (diff === 0) {
         if (max === 0) {
@@ -12,9 +12,9 @@ export default function autoMajorUnit(min, max) {
         diff = Math.abs(max);
     }
 
-    var scale = Math.pow(10, Math.floor(Math.log(diff) / Math.log(10)));
-    var relativeValue = round((diff / scale), DEFAULT_PRECISION);
-    var scaleMultiplier = 1;
+    const scale = Math.pow(10, Math.floor(Math.log(diff) / Math.log(10)));
+    const relativeValue = round((diff / scale), DEFAULT_PRECISION);
+    let scaleMultiplier = 1;
 
     if (relativeValue < 1.904762) {
         scaleMultiplier = 0.2;

package/dist/es/core/utils/box-diff.js

@@ -6,15 +6,15 @@ export default function boxDiff(r, s) {
         return s;
     }
 
-    var a = Math.min(r.x1, s.x1);
-    var b = Math.max(r.x1, s.x1);
-    var c = Math.min(r.x2, s.x2);
-    var d = Math.max(r.x2, s.x2);
-    var e = Math.min(r.y1, s.y1);
-    var f = Math.max(r.y1, s.y1);
-    var g = Math.min(r.y2, s.y2);
-    var h = Math.max(r.y2, s.y2);
-    var boxes = [];
+    const a = Math.min(r.x1, s.x1);
+    const b = Math.max(r.x1, s.x1);
+    const c = Math.min(r.x2, s.x2);
+    const d = Math.max(r.x2, s.x2);
+    const e = Math.min(r.y1, s.y1);
+    const f = Math.max(r.y1, s.y1);
+    const g = Math.min(r.y2, s.y2);
+    const h = Math.max(r.y2, s.y2);
+    const boxes = [];
 
     // X = intersection, 0-7 = possible difference areas
     // h +-+-+-+

package/dist/es/core/utils/create-axis-grid-line.js

@@ -3,11 +3,9 @@ import { drawing as draw } from '@progress/kendo-drawing';
 import { alignPathToPixel } from '../../common';
 
 export default function createAxisGridLine(options, gridLine) {
-    var lineStart = options.lineStart;
-    var lineEnd = options.lineEnd;
-    var position = options.position;
+    const { lineStart, lineEnd, position } = options;
 
-    var line = new draw.Path({
+    const line = new draw.Path({
         stroke: {
             width: gridLine.width,
             color: gridLine.color,

package/dist/es/core/utils/create-axis-tick.js

@@ -3,11 +3,9 @@ import { drawing as draw } from '@progress/kendo-drawing';
 import { alignPathToPixel } from '../../common';
 
 export default function createAxisTick(options, tickOptions) {
-    var tickX = options.tickX;
-    var tickY = options.tickY;
-    var position = options.position;
+    const { tickX, tickY, position } = options;
 
-    var tick = new draw.Path({
+    const tick = new draw.Path({
         stroke: {
             width: tickOptions.width,
             color: tickOptions.color

package/dist/es/core/utils/guid.js

@@ -1,7 +1,7 @@
 export default function guid() {
-    var id = "";
-    var i;
-    var random;
+    let id = "";
+    let i;
+    let random;
 
     for (i = 0; i < 32; i++) {
         random = Math.random() * 16 | 0;

package/dist/es/core/utils/rect-to-box.js

@@ -1,8 +1,8 @@
 import Box from '../box';
 
 export default function rectToBox(rect) {
-    var origin = rect.origin;
-    var bottomRight = rect.bottomRight();
+    const origin = rect.origin;
+    const bottomRight = rect.bottomRight();
 
     return new Box(origin.x, origin.y, bottomRight.x, bottomRight.y);
 }

package/dist/es/date-utils/absolute-date-diff.js

@@ -1,8 +1,8 @@
 import { TIME_PER_MINUTE } from './constants';
 
 export default function absoluteDateDiff(a, b) {
-    var diff = a.getTime() - b;
-    var offsetDiff = a.getTimezoneOffset() - b.getTimezoneOffset();
+    const diff = a.getTime() - b;
+    const offsetDiff = a.getTimezoneOffset() - b.getTimezoneOffset();
 
     return diff - (offsetDiff * TIME_PER_MINUTE);
 }

package/dist/es/date-utils/add-duration.js

@@ -14,21 +14,21 @@ function adjustDST(date, hours) {
 }
 
 function addHours(date, hours) {
-    var roundedDate = new Date(date);
+    const roundedDate = new Date(date);
 
     roundedDate.setMinutes(0, 0, 0);
 
-    var tzDiff = (date.getTimezoneOffset() - roundedDate.getTimezoneOffset()) * TIME_PER_MINUTE;
+    const tzDiff = (date.getTimezoneOffset() - roundedDate.getTimezoneOffset()) * TIME_PER_MINUTE;
 
     return addTicks(roundedDate, tzDiff + hours * TIME_PER_HOUR);
 }
 
 export default function addDuration(dateValue, value, unit, weekStartDay) {
-    var result = dateValue;
+    let result = dateValue;
 
     if (dateValue) {
-        var date = toDate(dateValue);
-        var hours = date.getHours();
+        let date = toDate(dateValue);
+        const hours = date.getHours();
 
         if (unit === YEARS) {
             result = new Date(date.getFullYear() + value, 0, 1);

package/dist/es/date-utils/ceil-date.js

@@ -3,7 +3,7 @@ import addDuration from './add-duration';
 import toDate from './to-date';
 
 export default function ceilDate(dateValue, unit, weekStartDay) {
-    var date = toDate(dateValue);
+    const date = toDate(dateValue);
 
     if (date && floorDate(date, unit, weekStartDay).getTime() === date.getTime()) {
         return date;

package/dist/es/date-utils/constants.js

@@ -1,21 +1,21 @@
-export var MILLISECONDS = "milliseconds";
-export var SECONDS = "seconds";
-export var MINUTES = "minutes";
-export var HOURS = "hours";
-export var DAYS = "days";
-export var WEEKS = "weeks";
-export var MONTHS = "months";
-export var YEARS = "years";
+export const MILLISECONDS = "milliseconds";
+export const SECONDS = "seconds";
+export const MINUTES = "minutes";
+export const HOURS = "hours";
+export const DAYS = "days";
+export const WEEKS = "weeks";
+export const MONTHS = "months";
+export const YEARS = "years";
 
-export var TIME_PER_MILLISECOND = 1;
-export var TIME_PER_SECOND = 1000;
-export var TIME_PER_MINUTE = 60 * TIME_PER_SECOND;
-export var TIME_PER_HOUR = 60 * TIME_PER_MINUTE;
-export var TIME_PER_DAY = 24 * TIME_PER_HOUR;
-export var TIME_PER_WEEK = 7 * TIME_PER_DAY;
-export var TIME_PER_MONTH = 31 * TIME_PER_DAY;
-export var TIME_PER_YEAR = 365 * TIME_PER_DAY;
-export var TIME_PER_UNIT = {
+export const TIME_PER_MILLISECOND = 1;
+export const TIME_PER_SECOND = 1000;
+export const TIME_PER_MINUTE = 60 * TIME_PER_SECOND;
+export const TIME_PER_HOUR = 60 * TIME_PER_MINUTE;
+export const TIME_PER_DAY = 24 * TIME_PER_HOUR;
+export const TIME_PER_WEEK = 7 * TIME_PER_DAY;
+export const TIME_PER_MONTH = 31 * TIME_PER_DAY;
+export const TIME_PER_YEAR = 365 * TIME_PER_DAY;
+export const TIME_PER_UNIT = {
     "years": TIME_PER_YEAR,
     "months": TIME_PER_MONTH,
     "weeks": TIME_PER_WEEK,

package/dist/es/date-utils/date-index.js

@@ -8,9 +8,9 @@ function timeIndex(date, start, baseUnit) {
 }
 
 export default function dateIndex(value, start, baseUnit, baseUnitStep) {
-    var date = toDate(value);
-    var startDate = toDate(start);
-    var index;
+    const date = toDate(value);
+    const startDate = toDate(start);
+    let index;
 
     if (baseUnit === MONTHS) {
         index = (date.getMonth() - startDate.getMonth() + (date.getFullYear() - startDate.getFullYear()) * 12) +

package/dist/es/date-utils/duration.js

@@ -2,7 +2,7 @@ import { DAYS, MONTHS, YEARS, TIME_PER_DAY, TIME_PER_UNIT } from './constants';
 import dateDiff from './date-diff';
 
 export default function duration(a, b, unit) {
-    var diff;
+    let diff;
 
     if (unit === YEARS) {
         diff = b.getFullYear() - a.getFullYear();

package/dist/es/date-utils/lte-date-index.js

@@ -1,13 +1,13 @@
 import dateEquals from './date-equals';
 
 export default function lteDateIndex(date, sortedDates) {
-    var low = 0;
-    var high = sortedDates.length - 1;
-    var index;
+    let low = 0;
+    let high = sortedDates.length - 1;
+    let index;
 
     while (low <= high) {
         index = Math.floor((low + high) / 2);
-        var currentDate = sortedDates[index];
+        const currentDate = sortedDates[index];
 
         if (currentDate < date) {
             low = index + 1;

package/dist/es/date-utils/parse-date.js

@@ -2,7 +2,7 @@ import { isString } from '../common';
 import toDate from './to-date';
 
 export default function parseDate(intlService, date) {
-    var result;
+    let result;
     if (isString(date)) {
         result = intlService.parseDate(date) || toDate(date);
     } else {

package/dist/es/date-utils/parse-dates.js

@@ -4,8 +4,8 @@ import { isArray } from '../common';
 
 export default function parseDates(intlService, dates) {
     if (isArray(dates)) {
-        var result = [];
-        for (var idx = 0; idx < dates.length; idx++) {
+        const result = [];
+        for (let idx = 0; idx < dates.length; idx++) {
             result.push(parseDate(intlService, dates[idx]));
         }
 

package/dist/es/date-utils/start-of-week.js

@@ -1,11 +1,9 @@
 import { TIME_PER_DAY } from './constants';
 import addTicks from './add-ticks';
 
-export default function startOfWeek(date, weekStartDay) {
-    if ( weekStartDay === void 0 ) weekStartDay = 0;
-
-    var daysToSubtract = 0;
-    var day = date.getDay();
+export default function startOfWeek(date, weekStartDay = 0) {
+    let daysToSubtract = 0;
+    let day = date.getDay();
 
     if (!isNaN(day)) {
         while (day !== weekStartDay) {