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

package/dist/es/core/date-value-axis.js

@@ -12,15 +12,15 @@ import ceil from './utils/ceil';
 import { toDate, toTime, floorDate, ceilDate, duration, addDuration, addTicks, dateDiff, absoluteDateDiff, dateComparer, parseDate, parseDates, firstDay } from '../date-utils';
 import { HOURS, DAYS, WEEKS, MONTHS, YEARS, TIME_PER_DAY, TIME_PER_WEEK, TIME_PER_MONTH, TIME_PER_YEAR, TIME_PER_UNIT } from '../date-utils/constants';
 
-var MIN_VALUE_RANGE = 1000;
+const MIN_VALUE_RANGE = 1000;
 
-var DateValueAxis = (function (Axis) {
-    function DateValueAxis(seriesMin, seriesMax, axisOptions, chartService) {
-        var min = toDate(seriesMin);
-        var max = toDate(seriesMax);
+class DateValueAxis extends Axis {
+    constructor(seriesMin, seriesMax, axisOptions, chartService) {
+        const min = toDate(seriesMin);
+        const max = toDate(seriesMax);
 
-        var intlService = chartService.intl;
-        var options = axisOptions || {};
+        const intlService = chartService.intl;
+        let options = axisOptions || {};
         options = deepExtend(options || {}, {
             min: parseDate(intlService, options.min),
             max: parseDate(intlService, options.max),
@@ -29,134 +29,126 @@ var DateValueAxis = (function (Axis) {
         });
         options = applyDefaults(min, max, options);
 
-        Axis.call(this, options, chartService);
+        super(options, chartService);
 
         this.intlService = intlService;
         this.seriesMin = min;
         this.seriesMax = max;
 
-        var weekStartDay = options.weekStartDay || 0;
+        const weekStartDay = options.weekStartDay || 0;
         this.totalMin = toTime(floorDate(toTime(min) - 1, options.baseUnit, weekStartDay));
         this.totalMax = toTime(ceilDate(toTime(max) + 1, options.baseUnit, weekStartDay));
     }
 
-    if ( Axis ) DateValueAxis.__proto__ = Axis;
-    DateValueAxis.prototype = Object.create( Axis && Axis.prototype );
-    DateValueAxis.prototype.constructor = DateValueAxis;
-
-    DateValueAxis.prototype.clone = function clone () {
+    clone() {
         return new DateValueAxis(this.seriesMin, this.seriesMax, Object.assign({}, this.options), this.chartService);
-    };
+    }
 
-    DateValueAxis.prototype.range = function range () {
-        var options = this.options;
+    range() {
+        const options = this.options;
         return { min: options.min, max: options.max };
-    };
+    }
 
-    DateValueAxis.prototype.getDivisions = function getDivisions (stepValue) {
-        var options = this.options;
+    getDivisions(stepValue) {
+        const options = this.options;
 
         return Math.floor(
             duration(options.min, options.max, options.baseUnit) / stepValue + 1
         );
-    };
-
-    DateValueAxis.prototype.getTickPositions = function getTickPositions (step) {
-        var options = this.options;
-        var ref = this.lineInfo();
-        var dir = ref.axisDir;
-        var lineSize = ref.lineSize;
-        var start = ref.lineStart;
-        var divisions = this.getDivisions(step);
-        var timeRange = dateDiff(options.max, options.min);
-        var scale = lineSize / timeRange;
-        var weekStartDay = options.weekStartDay || 0;
-
-        var positions = [ start ];
-        for (var i = 1; i < divisions; i++) {
-            var date = addDuration(options.min, i * step, options.baseUnit, weekStartDay);
-            var pos = start + dateDiff(date, options.min) * scale * dir;
+    }
+
+    getTickPositions(step) {
+        const options = this.options;
+        const { axisDir: dir, lineSize, lineStart: start } = this.lineInfo();
+        const divisions = this.getDivisions(step);
+        const timeRange = dateDiff(options.max, options.min);
+        const scale = lineSize / timeRange;
+        const weekStartDay = options.weekStartDay || 0;
+
+        const positions = [ start ];
+        for (let i = 1; i < divisions; i++) {
+            const date = addDuration(options.min, i * step, options.baseUnit, weekStartDay);
+            const pos = start + dateDiff(date, options.min) * scale * dir;
 
             positions.push(round(pos, COORD_PRECISION));
         }
 
         return positions;
-    };
+    }
 
-    DateValueAxis.prototype.getMajorTickPositions = function getMajorTickPositions () {
+    getMajorTickPositions() {
         return this.getTickPositions(this.options.majorUnit);
-    };
+    }
 
-    DateValueAxis.prototype.getMinorTickPositions = function getMinorTickPositions () {
+    getMinorTickPositions() {
         return this.getTickPositions(this.options.minorUnit);
-    };
+    }
 
-    DateValueAxis.prototype.getSlot = function getSlot (a, b, limit) {
+    getSlot(a, b, limit) {
         return NumericAxis.prototype.getSlot.call(
             this, parseDate(this.intlService, a), parseDate(this.intlService, b), limit
         );
-    };
+    }
 
-    DateValueAxis.prototype.getValue = function getValue (point) {
-        var value = NumericAxis.prototype.getValue.call(this, point);
+    getValue(point) {
+        const value = NumericAxis.prototype.getValue.call(this, point);
 
         return value !== null ? toDate(value) : null;
-    };
+    }
 
-    DateValueAxis.prototype.labelsCount = function labelsCount () {
+    labelsCount() {
         return this.getDivisions(this.options.majorUnit);
-    };
+    }
 
-    DateValueAxis.prototype.createAxisLabel = function createAxisLabel (index, labelOptions, labelContext) {
-        var options = this.options;
-        var offset = index * options.majorUnit;
-        var weekStartDay = options.weekStartDay || 0;
-        var date = options.min;
+    createAxisLabel(index, labelOptions, labelContext) {
+        const options = this.options;
+        const offset = index * options.majorUnit;
+        const weekStartDay = options.weekStartDay || 0;
+        let date = options.min;
 
         if (offset > 0) {
             date = addDuration(date, offset, options.baseUnit, weekStartDay);
         }
 
-        var unitFormat = labelOptions.dateFormats[options.baseUnit];
+        const unitFormat = labelOptions.dateFormats[options.baseUnit];
         labelOptions.format = labelOptions.format || unitFormat;
 
-        var text = this.axisLabelText(date, labelOptions, labelContext);
+        const text = this.axisLabelText(date, labelOptions, labelContext);
         return new AxisLabel(date, text, index, null, labelOptions);
-    };
-
-    DateValueAxis.prototype.translateRange = function translateRange (delta) {
-        var options = this.options;
-        var lineBox = this.lineBox();
-        var vertical = options.vertical;
-        var reverse = options.reverse;
-        var size = vertical ? lineBox.height() : lineBox.width();
-        var range = this.range();
-        var scale = size / dateDiff(range.max, range.min);
-
-        var offset = round(delta / scale, DEFAULT_PRECISION);
+    }
+
+    translateRange(delta) {
+        const options = this.options;
+        const lineBox = this.lineBox();
+        const { vertical, reverse } = options;
+        const size = vertical ? lineBox.height() : lineBox.width();
+        const range = this.range();
+        const scale = size / dateDiff(range.max, range.min);
+
+        let offset = round(delta / scale, DEFAULT_PRECISION);
         if ((vertical || reverse) && !(vertical && reverse )) {
             offset = -offset;
         }
 
-        var from = addTicks(options.min, offset);
-        var to = addTicks(options.max, offset);
+        let from = addTicks(options.min, offset);
+        let to = addTicks(options.max, offset);
 
         return {
             min: from,
             max: to,
             offset: offset
         };
-    };
+    }
 
-    DateValueAxis.prototype.shouldRenderNote = function shouldRenderNote (value) {
-        var range = this.range();
+    shouldRenderNote(value) {
+        const range = this.range();
 
         return dateComparer(value, range.min) >= 0 && dateComparer(value, range.max) <= 0;
-    };
+    }
 
-    DateValueAxis.prototype.pan = function pan (delta) {
-        var range = this.translateRange(delta, true);
-        var limittedRange = this.limitRange(toTime(range.min), toTime(range.max), this.totalMin, this.totalMax, range.offset);
+    pan(delta) {
+        const range = this.translateRange(delta, true);
+        const limittedRange = this.limitRange(toTime(range.min), toTime(range.max), this.totalMin, this.totalMax, range.offset);
 
         if (limittedRange) {
             return {
@@ -164,28 +156,28 @@ var DateValueAxis = (function (Axis) {
                 max: toDate(limittedRange.max)
             };
         }
-    };
+    }
 
-    DateValueAxis.prototype.pointsRange = function pointsRange (start, end) {
-        var startValue = this.getValue(start);
-        var endValue = this.getValue(end);
-        var min = Math.min(startValue, endValue);
-        var max = Math.max(startValue, endValue);
+    pointsRange(start, end) {
+        const startValue = this.getValue(start);
+        const endValue = this.getValue(end);
+        const min = Math.min(startValue, endValue);
+        const max = Math.max(startValue, endValue);
 
         return {
             min: toDate(min),
             max: toDate(max)
         };
-    };
+    }
 
-    DateValueAxis.prototype.scaleRange = function scaleRange (scale, cursor) {
-        var position = Math.abs(this.pointOffset(cursor));
-        var range = this.options.max - this.options.min;
-        var delta = this.scaleToDelta(scale, range);
-        var minDelta = position * delta;
-        var maxDelta = (1 - position) * delta;
-        var min = toDate(toTime(this.options.min) + minDelta);
-        var max = toDate(toTime(this.options.max) - maxDelta);
+    scaleRange(scale, cursor) {
+        const position = Math.abs(this.pointOffset(cursor));
+        const range = this.options.max - this.options.min;
+        const delta = this.scaleToDelta(scale, range);
+        const minDelta = position * delta;
+        const maxDelta = (1 - position) * delta;
+        const min = toDate(toTime(this.options.min) + minDelta);
+        let max = toDate(toTime(this.options.max) - maxDelta);
 
         if (max - min < MIN_VALUE_RANGE) {
             max = toDate(toTime(min) + MIN_VALUE_RANGE);
@@ -195,24 +187,22 @@ var DateValueAxis = (function (Axis) {
             min: min,
             max: max
         };
-    };
+    }
 
-    DateValueAxis.prototype.zoomRange = function zoomRange (scale, cursor) {
-        var range = this.scaleRange(scale, cursor);
-        var min = toDate(limitValue(toTime(range.min), this.totalMin, this.totalMax));
-        var max = toDate(limitValue(toTime(range.max), this.totalMin, this.totalMax));
+    zoomRange(scale, cursor) {
+        const range = this.scaleRange(scale, cursor);
+        const min = toDate(limitValue(toTime(range.min), this.totalMin, this.totalMax));
+        const max = toDate(limitValue(toTime(range.max), this.totalMin, this.totalMax));
 
         return {
-            min: min,
-            max: max
+            min,
+            max
         };
-    };
-
-    return DateValueAxis;
-}(Axis));
+    }
+}
 
 function timeUnits(delta) {
-    var unit = HOURS;
+    let unit = HOURS;
 
     if (delta >= TIME_PER_YEAR) {
         unit = YEARS;
@@ -228,23 +218,23 @@ function timeUnits(delta) {
 }
 
 function applyDefaults(seriesMin, seriesMax, options) {
-    var min = options.min || seriesMin;
-    var max = options.max || seriesMax;
-    var baseUnit = options.baseUnit || (max && min ? timeUnits(absoluteDateDiff(max, min)) : HOURS);
-    var baseUnitTime = TIME_PER_UNIT[baseUnit];
-    var weekStartDay = options.weekStartDay || 0;
-    var autoMin = floorDate(toTime(min) - 1, baseUnit, weekStartDay) || toDate(max);
-    var autoMax = ceilDate(toTime(max) + 1, baseUnit, weekStartDay);
-    var userMajorUnit = options.majorUnit ? options.majorUnit : undefined;
-    var majorUnit = userMajorUnit || ceil(
+    const min = options.min || seriesMin;
+    const max = options.max || seriesMax;
+    const baseUnit = options.baseUnit || (max && min ? timeUnits(absoluteDateDiff(max, min)) : HOURS);
+    const baseUnitTime = TIME_PER_UNIT[baseUnit];
+    const weekStartDay = options.weekStartDay || 0;
+    const autoMin = floorDate(toTime(min) - 1, baseUnit, weekStartDay) || toDate(max);
+    const autoMax = ceilDate(toTime(max) + 1, baseUnit, weekStartDay);
+    const userMajorUnit = options.majorUnit ? options.majorUnit : undefined;
+    const majorUnit = userMajorUnit || ceil(
         autoMajorUnit(autoMin.getTime(), autoMax.getTime()),
         baseUnitTime
     ) / baseUnitTime;
-    var actualUnits = duration(autoMin, autoMax, baseUnit);
-    var totalUnits = ceil(actualUnits, majorUnit);
-    var unitsToAdd = totalUnits - actualUnits;
-    var head = Math.floor(unitsToAdd / 2);
-    var tail = unitsToAdd - head;
+    const actualUnits = duration(autoMin, autoMax, baseUnit);
+    const totalUnits = ceil(actualUnits, majorUnit);
+    const unitsToAdd = totalUnits - actualUnits;
+    const head = Math.floor(unitsToAdd / 2);
+    const tail = unitsToAdd - head;
 
     if (!options.baseUnit) {
         delete options.baseUnit;

package/dist/es/core/float-element.js

@@ -4,18 +4,14 @@ import Box from './box';
 import { X, Y, WIDTH, HEIGHT, RIGHT, BOTTOM, CENTER } from '../common/constants';
 import { round, setDefaultOptions } from '../common';
 
-var FloatElement = (function (ChartElement) {
-    function FloatElement(options) {
-        ChartElement.call(this, options);
+class FloatElement extends ChartElement {
+    constructor(options) {
+        super(options);
         this._initDirection();
     }
 
-    if ( ChartElement ) FloatElement.__proto__ = ChartElement;
-    FloatElement.prototype = Object.create( ChartElement && ChartElement.prototype );
-    FloatElement.prototype.constructor = FloatElement;
-
-    FloatElement.prototype._initDirection = function _initDirection () {
-        var options = this.options;
+    _initDirection() {
+        const options = this.options;
         if (options.vertical) {
             this.groupAxis = X;
             this.elementAxis = Y;
@@ -31,44 +27,34 @@ var FloatElement = (function (ChartElement) {
             this.groupSpacing = options.vSpacing;
             this.elementSpacing = options.spacing;
         }
-    };
+    }
 
-    FloatElement.prototype.reflow = function reflow (targetBox) {
+    reflow(targetBox) {
         this.box = targetBox.clone();
         this.reflowChildren();
-    };
-
-    FloatElement.prototype.reflowChildren = function reflowChildren () {
-        var this$1 = this;
-
-        var ref = this;
-        var box = ref.box;
-        var elementAxis = ref.elementAxis;
-        var groupAxis = ref.groupAxis;
-        var elementSizeField = ref.elementSizeField;
-        var groupSizeField = ref.groupSizeField;
-        var ref$1 = this.groupOptions();
-        var groups = ref$1.groups;
-        var groupsSize = ref$1.groupsSize;
-        var maxGroupElementsSize = ref$1.maxGroupElementsSize;
-        var groupsCount = groups.length;
-        var groupsStart = box[groupAxis + 1] + this.alignStart(groupsSize, box[groupSizeField]());
+    }
+
+    reflowChildren() {
+        const { box, elementAxis, groupAxis, elementSizeField, groupSizeField } = this;
+        const { groups, groupsSize, maxGroupElementsSize } = this.groupOptions();
+        const groupsCount = groups.length;
+        const groupsStart = box[groupAxis + 1] + this.alignStart(groupsSize, box[groupSizeField]());
 
         if (groupsCount) {
-            var groupStart = groupsStart;
+            let groupStart = groupsStart;
 
-            for (var groupIdx = 0; groupIdx < groupsCount; groupIdx++) {
-                var group = groups[groupIdx];
-                var groupElements = group.groupElements;
-                var elementStart = box[elementAxis + 1];
-                var groupElementsCount = groupElements.length;
+            for (let groupIdx = 0; groupIdx < groupsCount; groupIdx++) {
+                let group = groups[groupIdx];
+                let groupElements = group.groupElements;
+                let elementStart = box[elementAxis + 1];
+                let groupElementsCount = groupElements.length;
 
-                for (var idx = 0; idx < groupElementsCount; idx++) {
-                    var element = groupElements[idx];
-                    var elementSize = this$1.elementSize(element);
-                    var groupElementStart = groupStart + this$1.alignStart(elementSize[groupSizeField], group.groupSize);
+                for (let idx = 0; idx < groupElementsCount; idx++) {
+                    let element = groupElements[idx];
+                    let elementSize = this.elementSize(element);
+                    let groupElementStart = groupStart + this.alignStart(elementSize[groupSizeField], group.groupSize);
 
-                    var elementBox = new Box();
+                    let elementBox = new Box();
                     elementBox[groupAxis + 1] = groupElementStart;
                     elementBox[groupAxis + 2] = groupElementStart + elementSize[groupSizeField];
                     elementBox[elementAxis + 1] = elementStart;
@@ -76,55 +62,47 @@ var FloatElement = (function (ChartElement) {
 
                     element.reflow(elementBox);
 
-                    elementStart += elementSize[elementSizeField] + this$1.elementSpacing;
+                    elementStart += elementSize[elementSizeField] + this.elementSpacing;
                 }
-                groupStart += group.groupSize + this$1.groupSpacing;
+                groupStart += group.groupSize + this.groupSpacing;
             }
             box[groupAxis + 1] = groupsStart;
             box[groupAxis + 2] = groupsStart + groupsSize;
             box[elementAxis + 2] = box[elementAxis + 1] + maxGroupElementsSize;
         }
-    };
+    }
 
-    FloatElement.prototype.alignStart = function alignStart (size, maxSize) {
-        var start = 0;
-        var align = this.options.align;
+    alignStart(size, maxSize) {
+        let start = 0;
+        const align = this.options.align;
         if (align === RIGHT || align === BOTTOM) {
             start = maxSize - size;
         } else if (align === CENTER) {
             start = (maxSize - size) / 2;
         }
         return start;
-    };
-
-    FloatElement.prototype.groupOptions = function groupOptions () {
-        var this$1 = this;
-
-        var ref = this;
-        var box = ref.box;
-        var children = ref.children;
-        var elementSizeField = ref.elementSizeField;
-        var groupSizeField = ref.groupSizeField;
-        var elementSpacing = ref.elementSpacing;
-        var groupSpacing = ref.groupSpacing;
-        var maxSize = round(box[elementSizeField]());
-        var childrenCount = children.length;
-        var groups = [];
-
-        var groupSize = 0;
-        var groupElementsSize = 0;
-        var groupsSize = 0;
-        var maxGroupElementsSize = 0;
-        var groupElements = [];
-
-        for (var idx = 0; idx < childrenCount; idx++) {
-            var element = children[idx];
+    }
+
+    groupOptions() {
+        const { box, children, elementSizeField, groupSizeField, elementSpacing, groupSpacing } = this;
+        const maxSize = round(box[elementSizeField]());
+        const childrenCount = children.length;
+        const groups = [];
+
+        let groupSize = 0;
+        let groupElementsSize = 0;
+        let groupsSize = 0;
+        let maxGroupElementsSize = 0;
+        let groupElements = [];
+
+        for (let idx = 0; idx < childrenCount; idx++) {
+            let element = children[idx];
             if (!element.box) {
                 element.reflow(box);
             }
 
-            var elementSize = this$1.elementSize(element);
-            if (this$1.options.wrap && round(groupElementsSize + elementSpacing + elementSize[elementSizeField]) > maxSize) {
+            let elementSize = this.elementSize(element);
+            if (this.options.wrap && round(groupElementsSize + elementSpacing + elementSize[elementSizeField]) > maxSize) {
                 groups.push({
                     groupElements: groupElements,
                     groupSize: groupSize,
@@ -157,19 +135,17 @@ var FloatElement = (function (ChartElement) {
             groupsSize: groupsSize,
             maxGroupElementsSize: maxGroupElementsSize
         };
-    };
+    }
 
-    FloatElement.prototype.elementSize = function elementSize (element) {
+    elementSize(element) {
         return {
             width: element.box.width(),
             height: element.box.height()
         };
-    };
-
-    FloatElement.prototype.createVisual = function createVisual () {};
+    }
 
-    return FloatElement;
-}(ChartElement));
+    createVisual() {}
+}
 
 setDefaultOptions(FloatElement, {
     vertical: true,

package/dist/es/core/gradients.js

@@ -1,9 +1,9 @@
 import { WHITE } from '../common/constants';
 
-var LINEAR = "linear";
-var RADIAL = "radial";
+const LINEAR = "linear";
+const RADIAL = "radial";
 
-var GRADIENTS = {
+const GRADIENTS = {
     glass: {
         type: LINEAR,
         rotation: 0,