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

package/dist/es/core/numeric-axis.js

@@ -13,84 +13,77 @@ import floor from './utils/floor';
 import ceil from './utils/ceil';
 import limitCoordinate from './utils/limit-coordinate';
 
-var MIN_VALUE_RANGE = Math.pow(10, -DEFAULT_PRECISION + 1);
+const MIN_VALUE_RANGE = Math.pow(10, -DEFAULT_PRECISION + 1);
 
-var NumericAxis = (function (Axis) {
-    function NumericAxis(seriesMin, seriesMax, options, chartService) {
-        Axis.call(this, Object.assign({}, options, {
+class NumericAxis extends Axis {
+
+    constructor(seriesMin, seriesMax, options, chartService) {
+        super(Object.assign({}, options, {
             seriesMin: seriesMin,
             seriesMax: seriesMax
         }), chartService);
     }
 
-    if ( Axis ) NumericAxis.__proto__ = Axis;
-    NumericAxis.prototype = Object.create( Axis && Axis.prototype );
-    NumericAxis.prototype.constructor = NumericAxis;
-
-    NumericAxis.prototype.initUserOptions = function initUserOptions (options) {
-        var autoOptions = autoAxisOptions(options.seriesMin, options.seriesMax, options);
+    initUserOptions(options) {
+        const autoOptions = autoAxisOptions(options.seriesMin, options.seriesMax, options);
         this.totalOptions = totalAxisOptions(autoOptions, options);
 
         return axisOptions(autoOptions, options);
-    };
+    }
 
-    NumericAxis.prototype.initFields = function initFields () {
+    initFields() {
         this.totalMin = this.totalOptions.min;
         this.totalMax = this.totalOptions.max;
         this.totalMajorUnit = this.totalOptions.majorUnit;
         this.seriesMin = this.options.seriesMin;
         this.seriesMax = this.options.seriesMax;
-    };
+    }
 
-    NumericAxis.prototype.clone = function clone () {
+    clone() {
         return new NumericAxis(
             this.seriesMin,
             this.seriesMax,
             Object.assign({}, this.options),
             this.chartService
         );
-    };
+    }
 
-    NumericAxis.prototype.startValue = function startValue () {
+    startValue() {
         return 0;
-    };
+    }
 
-    NumericAxis.prototype.range = function range () {
-        var options = this.options;
+    range() {
+        const options = this.options;
         return { min: options.min, max: options.max };
-    };
+    }
 
-    NumericAxis.prototype.getDivisions = function getDivisions (stepValue) {
+    getDivisions(stepValue) {
         if (stepValue === 0) {
             return 1;
         }
 
-        var options = this.options;
-        var range = options.max - options.min;
+        const options = this.options;
+        const range = options.max - options.min;
 
         return Math.floor(round(range / stepValue, COORD_PRECISION)) + 1;
-    };
+    }
 
-    NumericAxis.prototype.getTickPositions = function getTickPositions (unit, skipUnit) {
-        var options = this.options;
-        var ref = this.lineInfo();
-        var axisDir = ref.axisDir;
-        var axisOrigin = ref.axisOrigin;
-        var lineBox = ref.lineBox;
-        var lineSize = ref.lineSize;
-        var range = options.max - options.min;
-        var scale = lineSize / range;
-        var step = unit * scale;
-        var divisions = this.getDivisions(unit);
-        var positions = [];
-        var pos = lineBox[axisOrigin];
-        var skipStep = 0;
+    getTickPositions(unit, skipUnit) {
+        const options = this.options;
+        const { axisDir, axisOrigin, lineBox, lineSize } = this.lineInfo();
+        const range = options.max - options.min;
+        const scale = lineSize / range;
+        const step = unit * scale;
+        const divisions = this.getDivisions(unit);
+        const positions = [];
+        let pos = lineBox[axisOrigin];
+        let skipStep = 0;
 
         if (skipUnit) {
             skipStep = skipUnit / unit;
         }
 
-        for (var idx = 0; idx < divisions; idx++) {
+        for (let idx = 0; idx < divisions; idx++) {
             if (idx % skipStep !== 0) {
                 positions.push(round(pos, COORD_PRECISION));
             }
@@ -99,72 +92,61 @@ var NumericAxis = (function (Axis) {
         }
 
         return positions;
-    };
+    }
 
-    NumericAxis.prototype.getMajorTickPositions = function getMajorTickPositions () {
+    getMajorTickPositions() {
         return this.getTickPositions(this.options.majorUnit);
-    };
+    }
 
-    NumericAxis.prototype.getMinorTickPositions = function getMinorTickPositions () {
+    getMinorTickPositions() {
         return this.getTickPositions(this.options.minorUnit);
-    };
-
-    NumericAxis.prototype.getSlot = function getSlot (a, b, limit) {
-        if ( limit === void 0 ) limit = false;
+    }
 
-        var options = this.options;
-        var ref = this.lineInfo();
-        var axis = ref.axis;
-        var axisDir = ref.axisDir;
-        var lineBox = ref.lineBox;
-        var lineSize = ref.lineSize;
-        var lineStart = ref.lineStart;
-        var step = axisDir * (lineSize / (options.max - options.min));
+    getSlot(a, b, limit = false) {
+        const options = this.options;
+        const { axis, axisDir, lineBox, lineSize, lineStart } = this.lineInfo();
+        const step = axisDir * (lineSize / (options.max - options.min));
 
-        var start = valueOrDefault(a, b || 0);
-        var end = valueOrDefault(b, a || 0);
+        let start = valueOrDefault(a, b || 0);
+        let end = valueOrDefault(b, a || 0);
 
         if (limit) {
             start = limitValue(start, options.min, options.max);
             end = limitValue(end, options.min, options.max);
         }
 
-        var p1 = Math.min(start, end) - options.min;
-        var p2 = Math.max(start, end) - options.min;
+        const p1 = Math.min(start, end) - options.min;
+        const p2 = Math.max(start, end) - options.min;
 
-        var slotBox = new Box(lineBox.x1, lineBox.y1, lineBox.x1, lineBox.y1);
+        const slotBox = new Box(lineBox.x1, lineBox.y1, lineBox.x1, lineBox.y1);
         slotBox[axis + 1] = limitCoordinate(lineStart + step * (axisDir > 0 ? p1 : p2));
         slotBox[axis + 2] = limitCoordinate(lineStart + step * (axisDir > 0 ? p2 : p1));
 
         return slotBox;
-    };
+    }
 
-    NumericAxis.prototype.getValue = function getValue (point) {
-        var options = this.options;
-        var max = Number(options.max);
-        var min = Number(options.min);
-        var offset = this.pointOffset(point);
-        var valueOffset = offset * (max - min);
+    getValue(point) {
+        const options = this.options;
+        const max = Number(options.max);
+        const min = Number(options.min);
+        const offset = this.pointOffset(point);
+        const valueOffset = offset * (max - min);
 
         if (offset < 0 || offset > 1) {
             return null;
         }
 
-        var value = min + valueOffset;
+        const value = min + valueOffset;
         return round(value, DEFAULT_PRECISION);
-    };
+    }
 
-    NumericAxis.prototype.translateRange = function translateRange (delta) {
-        var options = this.options;
-        var vertical = options.vertical;
-        var reverse = options.reverse;
-        var max = options.max;
-        var min = options.min;
-        var ref = this.lineInfo();
-        var lineSize = ref.lineSize;
-        var range = max - min;
-        var scale = lineSize / range;
-        var offset = round(delta / scale, DEFAULT_PRECISION);
+    translateRange(delta) {
+        const options = this.options;
+        const { vertical, reverse, max, min } = options;
+        const { lineSize } = this.lineInfo();
+        const range = max - min;
+        const scale = lineSize / range;
+        let offset = round(delta / scale, DEFAULT_PRECISION);
 
         if ((vertical || reverse) && !(vertical && reverse )) {
             offset = -offset;
@@ -175,35 +157,35 @@ var NumericAxis = (function (Axis) {
             max: max + offset,
             offset: offset
         };
-    };
+    }
 
-    NumericAxis.prototype.labelsCount = function labelsCount () {
+    labelsCount() {
         return this.getDivisions(this.options.majorUnit);
-    };
+    }
 
-    NumericAxis.prototype.createAxisLabel = function createAxisLabel (index, labelOptions, labelContext) {
-        var options = this.options;
-        var value = round(options.min + (index * options.majorUnit), DEFAULT_PRECISION);
-        var text = this.axisLabelText(value, labelOptions, labelContext);
+    createAxisLabel(index, labelOptions, labelContext) {
+        const options = this.options;
+        const value = round(options.min + (index * options.majorUnit), DEFAULT_PRECISION);
+        const text = this.axisLabelText(value, labelOptions, labelContext);
 
         return new AxisLabel(value, text, index, null, labelOptions);
-    };
+    }
 
-    NumericAxis.prototype.shouldRenderNote = function shouldRenderNote (value) {
-        var range = this.range();
+    shouldRenderNote(value) {
+        const range = this.range();
         return range.min <= value && value <= range.max;
-    };
+    }
 
-    NumericAxis.prototype.pan = function pan (delta) {
-        var range = this.translateRange(delta);
+    pan(delta) {
+        const range = this.translateRange(delta);
         return this.limitRange(range.min, range.max, this.totalMin, this.totalMax, range.offset);
-    };
+    }
 
-    NumericAxis.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);
 
         if (this.isValidRange(min, max)) {
             return {
@@ -211,16 +193,16 @@ var NumericAxis = (function (Axis) {
                 max: max
             };
         }
-    };
+    }
 
-    NumericAxis.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 = round(this.options.min + minDelta, DEFAULT_PRECISION);
-        var max = round(this.options.max - maxDelta, DEFAULT_PRECISION);
+    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 = round(this.options.min + minDelta, DEFAULT_PRECISION);
+        let max = round(this.options.max - maxDelta, DEFAULT_PRECISION);
 
         if (max - min < MIN_VALUE_RANGE) {
             max = min + MIN_VALUE_RANGE;
@@ -230,36 +212,32 @@ var NumericAxis = (function (Axis) {
             min: min,
             max: max
         };
-    };
+    }
 
-    NumericAxis.prototype.zoomRange = function zoomRange (scale, cursor) {
-        var ref = this;
-        var totalMin = ref.totalMin;
-        var totalMax = ref.totalMax;
-        var range = this.scaleRange(scale, cursor);
+    zoomRange(scale, cursor) {
+        const { totalMin, totalMax } = this;
+        const range = this.scaleRange(scale, cursor);
 
         return {
             min: limitValue(range.min, totalMin, totalMax),
             max: limitValue(range.max, totalMin, totalMax),
             narrowRange: false
         };
-    };
+    }
 
-    NumericAxis.prototype.isValidRange = function isValidRange (min, max) {
+    isValidRange(min, max) {
         return max - min > MIN_VALUE_RANGE;
-    };
-
-    return NumericAxis;
-}(Axis));
+    }
+}
 
 function autoAxisOptions(seriesMin, seriesMax, options) {
-    var narrowRange = options.narrowRange;
+    const narrowRange = options.narrowRange;
 
-    var autoMin = autoAxisMin(seriesMin, seriesMax, narrowRange);
-    var autoMax = autoAxisMax(seriesMin, seriesMax, narrowRange);
+    let autoMin = autoAxisMin(seriesMin, seriesMax, narrowRange);
+    let autoMax = autoAxisMax(seriesMin, seriesMax, narrowRange);
 
-    var majorUnit = autoMajorUnit(autoMin, autoMax);
-    var autoOptions = {
+    const majorUnit = autoMajorUnit(autoMin, autoMax);
+    const autoOptions = {
         majorUnit: majorUnit
     };
 
@@ -288,8 +266,8 @@ function totalAxisOptions(autoOptions, options) {
 }
 
 function clearNullValues(options, fields) {
-    for (var idx = 0; idx < fields.length; idx++) {
-        var field = fields[idx];
+    for (let idx = 0; idx < fields.length; idx++) {
+        const field = fields[idx];
         if (options[field] === null) {
             options[field] = undefined;
         }
@@ -297,8 +275,8 @@ function clearNullValues(options, fields) {
 }
 
 function axisOptions(autoOptions, userOptions) {
-    var options = userOptions;
-    var userSetMin, userSetMax;
+    let options = userOptions;
+    let userSetMin, userSetMax;
 
     if (userOptions) {
         clearNullValues(userOptions, [ 'min', 'max' ]);
@@ -306,7 +284,7 @@ function axisOptions(autoOptions, userOptions) {
         userSetMin = defined(userOptions.min);
         userSetMax = defined(userOptions.max);
 
-        var userSetLimits = userSetMin || userSetMax;
+        const userSetLimits = userSetMin || userSetMax;
 
         if (userSetLimits) {
             if (userOptions.min === userOptions.max) {
@@ -331,7 +309,7 @@ function axisOptions(autoOptions, userOptions) {
 
     autoOptions.minorUnit = (options.majorUnit || autoOptions.majorUnit) / 5;
 
-    var result = deepExtend(autoOptions, options);
+    const result = deepExtend(autoOptions, options);
     if (result.min >= result.max) {
         if (userSetMin && !userSetMax) {
             result.max = result.min + result.majorUnit;
@@ -344,8 +322,8 @@ function axisOptions(autoOptions, userOptions) {
 }
 
 function remainderClose(value, divisor, ratio) {
-    var remainder = round(Math.abs(value % divisor), DEFAULT_PRECISION);
-    var threshold = divisor * (1 - ratio);
+    const remainder = round(Math.abs(value % divisor), DEFAULT_PRECISION);
+    const threshold = divisor * (1 - ratio);
 
     return remainder === 0 || remainder > threshold;
 }

package/dist/es/core/pattern.js

@@ -1,13 +1,9 @@
 import { drawing } from '@progress/kendo-drawing';
 import { isFunction } from './../common';
 
-var dotsPattern = drawing.dotsPattern;
-var verticalStripesPattern = drawing.verticalStripesPattern;
-var crosshatchPattern = drawing.crosshatchPattern;
-var diagonalStripesPattern = drawing.diagonalStripesPattern;
-var gridPattern = drawing.gridPattern;
+const { dotsPattern, verticalStripesPattern, crosshatchPattern, diagonalStripesPattern, gridPattern } = drawing;
 
-var patternMap = {
+const patternMap = {
     dots: dotsPattern,
     verticalStripes: verticalStripesPattern,
     crosshatch: crosshatchPattern,
@@ -20,8 +16,8 @@ export function evaluatePattern(options, point) {
 }
 
 export function createPatternFill(options, fill, point) {
-    var patternOptions = evaluatePattern(options, point);
-    var pattern = patternOptions && patternMap[patternOptions.type];
+    const patternOptions = evaluatePattern(options, point);
+    const pattern = patternOptions && patternMap[patternOptions.type];
 
     return pattern ? pattern(Object.assign({}, fill, patternOptions)) : fill;
 }

package/dist/es/core/point.js

@@ -1,35 +1,28 @@
 import { COORD_PRECISION } from '../common/constants';
 import { Class, rad, round } from '../common';
 
-var Point = (function (Class) {
-    function Point(x, y) {
-        Class.call(this);
+class Point extends Class {
+    constructor(x, y) {
+        super();
 
         this.x = x || 0;
         this.y = y || 0;
     }
 
-    if ( Class ) Point.__proto__ = Class;
-    Point.prototype = Object.create( Class && Class.prototype );
-    Point.prototype.constructor = Point;
-
-    Point.prototype.clone = function clone () {
+    clone() {
         return new Point(this.x, this.y);
-    };
+    }
 
-    Point.prototype.equals = function equals (point) {
+    equals(point) {
         return point && this.x === point.x && this.y === point.y;
-    };
-
-    Point.prototype.rotate = function rotate (center, degrees) {
-        var theta = rad(degrees);
-        var cosT = Math.cos(theta);
-        var sinT = Math.sin(theta);
-        var cx = center.x;
-        var cy = center.y;
-        var ref = this;
-        var x = ref.x;
-        var y = ref.y;
+    }
+
+    rotate(center, degrees) {
+        const theta = rad(degrees);
+        const cosT = Math.cos(theta);
+        const sinT = Math.sin(theta);
+        const { x: cx, y: cy } = center;
+        const { x, y } = this;
 
         this.x = round(
             cx + (x - cx) * cosT + (y - cy) * sinT,
@@ -42,34 +35,32 @@ var Point = (function (Class) {
         );
 
         return this;
-    };
+    }
 
-    Point.prototype.multiply = function multiply (a) {
+    multiply(a) {
 
         this.x *= a;
         this.y *= a;
 
         return this;
-    };
+    }
 
-    Point.prototype.distanceTo = function distanceTo (point) {
-        var dx = this.x - point.x;
-        var dy = this.y - point.y;
+    distanceTo(point) {
+        const dx = this.x - point.x;
+        const dy = this.y - point.y;
 
         return Math.sqrt(dx * dx + dy * dy);
-    };
+    }
 
-    Point.onCircle = function onCircle (center, angle, radius) {
-        var radians = rad(angle);
+    static onCircle(center, angle, radius) {
+        const radians = rad(angle);
 
         return new Point(
             center.x - radius * Math.cos(radians),
             center.y - radius * Math.sin(radians)
         );
-    };
-
-    return Point;
-}(Class));
+    }
+}
 
 
 export default Point;