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

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

@@ -10,23 +10,23 @@ import limitCoordinate from './utils/limit-coordinate';
 import { DEFAULT_PRECISION, BLACK } from '../common/constants';
 import { deepExtend, defined, inArray, limitValue, round, setDefaultOptions, valueOrDefault } from '../common';
 
-var DEFAULT_MAJOR_UNIT = 10;
-var MIN_VALUE_RANGE = 1e-6;
+const DEFAULT_MAJOR_UNIT = 10;
+const MIN_VALUE_RANGE = 1e-6;
 
-var LogarithmicAxis = (function (Axis) {
-    function LogarithmicAxis(seriesMin, seriesMax, options, chartService) {
+class LogarithmicAxis extends Axis {
+    constructor(seriesMin, seriesMax, options, chartService) {
 
-        var axisOptions = deepExtend({ majorUnit: DEFAULT_MAJOR_UNIT, min: seriesMin, max: seriesMax }, options);
-        var base = axisOptions.majorUnit;
-        var autoMax = autoAxisMax(seriesMax, base);
-        var autoMin = autoAxisMin(seriesMin, seriesMax, axisOptions);
-        var range = initRange(autoMin, autoMax, axisOptions, options);
+        const axisOptions = deepExtend({ majorUnit: DEFAULT_MAJOR_UNIT, min: seriesMin, max: seriesMax }, options);
+        const base = axisOptions.majorUnit;
+        const autoMax = autoAxisMax(seriesMax, base);
+        const autoMin = autoAxisMin(seriesMin, seriesMax, axisOptions);
+        const range = initRange(autoMin, autoMax, axisOptions, options);
 
         axisOptions.max = range.max;
         axisOptions.min = range.min;
         axisOptions.minorUnit = options.minorUnit || round(base - 1, DEFAULT_PRECISION);
 
-        Axis.call(this, axisOptions, chartService);
+        super(axisOptions, chartService);
 
         this.totalMin = defined(options.min) ? Math.min(autoMin, options.min) : autoMin;
         this.totalMax = defined(options.max) ? Math.max(autoMax, options.max) : autoMax;
@@ -38,40 +38,26 @@ var LogarithmicAxis = (function (Axis) {
         this.createLabels();
     }
 
-    if ( Axis ) LogarithmicAxis.__proto__ = Axis;
-    LogarithmicAxis.prototype = Object.create( Axis && Axis.prototype );
-    LogarithmicAxis.prototype.constructor = LogarithmicAxis;
-
-    LogarithmicAxis.prototype.clone = function clone () {
+    clone() {
         return new LogarithmicAxis(
             this.seriesMin,
             this.seriesMax,
             Object.assign({}, this.options),
             this.chartService
         );
-    };
+    }
 
-    LogarithmicAxis.prototype.startValue = function startValue () {
+    startValue() {
         return this.options.min;
-    };
+    }
 
-    LogarithmicAxis.prototype.getSlot = function getSlot (a, b, limit) {
-        var ref = this;
-        var options = ref.options;
-        var logMin = ref.logMin;
-        var logMax = ref.logMax;
-        var base = options.majorUnit;
-        var min = options.min;
-        var max = options.max;
-        var ref$1 = this.lineInfo();
-        var axis = ref$1.axis;
-        var axisDir = ref$1.axisDir;
-        var lineBox = ref$1.lineBox;
-        var lineSize = ref$1.lineSize;
-        var lineStart = ref$1.lineStart;
-        var step = axisDir * (lineSize / (logMax - logMin));
-        var start = valueOrDefault(a, b || 1);
-        var end = valueOrDefault(b, a || 1);
+    getSlot(a, b, limit) {
+        const { options, logMin, logMax } = this;
+        const { majorUnit: base, min, max } = options;
+        const { axis, axisDir, lineBox, lineSize, lineStart } = this.lineInfo();
+        const step = axisDir * (lineSize / (logMax - logMin));
+        let start = valueOrDefault(a, b || 1);
+        let end = valueOrDefault(b, a || 1);
 
         if (start <= 0 || end <= 0) {
             return null;
@@ -85,57 +71,45 @@ var LogarithmicAxis = (function (Axis) {
         start = log(start, base);
         end = log(end, base);
 
-        var p1 = Math.min(start, end) - logMin;
-        var p2 = Math.max(start, end) - logMin;
+        const p1 = Math.min(start, end) - logMin;
+        const p2 = Math.max(start, end) - logMin;
 
-        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;
-    };
+    }
 
-    LogarithmicAxis.prototype.getValue = function getValue (point) {
-        var ref = this;
-        var options = ref.options;
-        var logMin = ref.logMin;
-        var logMax = ref.logMax;
-        var base = options.majorUnit;
-        var ref$1 = this.lineInfo();
-        var axis = ref$1.axis;
-        var axisDir = ref$1.axisDir;
-        var lineStart = ref$1.lineStart;
-        var lineSize = ref$1.lineSize;
-        var step = ((logMax - logMin) / lineSize);
-        var offset = axisDir * (point[axis] - lineStart);
-        var valueOffset = offset * step;
+    getValue(point) {
+        const { options, logMin, logMax } = this;
+        const { majorUnit: base } = options;
+        const { axis, axisDir, lineStart, lineSize } = this.lineInfo();
+        const step = ((logMax - logMin) / lineSize);
+        const offset = axisDir * (point[axis] - lineStart);
+        const valueOffset = offset * step;
 
         if (offset < 0 || offset > lineSize) {
             return null;
         }
 
-        var value = logMin + valueOffset;
+        const value = logMin + valueOffset;
 
         return round(Math.pow(base, value), DEFAULT_PRECISION);
-    };
+    }
 
-    LogarithmicAxis.prototype.range = function range () {
-        var options = this.options;
+    range() {
+        const options = this.options;
         return { min: options.min, max: options.max };
-    };
+    }
 
-    LogarithmicAxis.prototype.translateRange = function translateRange (delta) {
-        var ref = this;
-        var options = ref.options;
-        var logMin = ref.logMin;
-        var logMax = ref.logMax;
-        var reverse = options.reverse;
-        var vertical = options.vertical;
-        var base = options.majorUnit;
-        var lineBox = this.lineBox();
-        var size = vertical ? lineBox.height() : lineBox.width();
-        var scale = size / (logMax - logMin);
-        var offset = round(delta / scale, DEFAULT_PRECISION);
+    translateRange(delta) {
+        const { options, logMin, logMax } = this;
+        const { reverse, vertical, majorUnit: base } = options;
+        const lineBox = this.lineBox();
+        const size = vertical ? lineBox.height() : lineBox.width();
+        const scale = size / (logMax - logMin);
+        let offset = round(delta / scale, DEFAULT_PRECISION);
 
         if ((vertical || reverse) && !(vertical && reverse )) {
             offset = -offset;
@@ -146,34 +120,32 @@ var LogarithmicAxis = (function (Axis) {
             max: Math.pow(base, logMax + offset),
             offset: offset
         };
-    };
+    }
 
-    LogarithmicAxis.prototype.labelsCount = function labelsCount () {
-        var floorMax = Math.floor(this.logMax);
-        var count = Math.floor(floorMax - this.logMin) + 1;
+    labelsCount() {
+        const floorMax = Math.floor(this.logMax);
+        const count = Math.floor(floorMax - this.logMin) + 1;
 
         return count;
-    };
+    }
 
-    LogarithmicAxis.prototype.getMajorTickPositions = function getMajorTickPositions () {
-        var ticks = [];
+    getMajorTickPositions() {
+        const ticks = [];
 
-        this.traverseMajorTicksPositions(function (position) {
+        this.traverseMajorTicksPositions((position) => {
             ticks.push(position);
         }, { step: 1, skip: 0 });
 
         return ticks;
-    };
+    }
 
-    LogarithmicAxis.prototype.createTicks = function createTicks (lineGroup) {
-        var options = this.options;
-        var majorTicks = options.majorTicks;
-        var minorTicks = options.minorTicks;
-        var vertical = options.vertical;
-        var mirror = options.labels.mirror;
-        var lineBox = this.lineBox();
-        var ticks = [];
-        var tickLineOptions = {
+    createTicks(lineGroup) {
+        const options = this.options;
+        const { majorTicks, minorTicks, vertical } = options;
+        const mirror = options.labels.mirror;
+        const lineBox = this.lineBox();
+        const ticks = [];
+        const tickLineOptions = {
             // TODO
             // _alignLines: options._alignLines,
             vertical: vertical
@@ -196,22 +168,20 @@ var LogarithmicAxis = (function (Axis) {
         }
 
         return ticks;
-    };
+    }
 
-    LogarithmicAxis.prototype.createGridLines = function createGridLines (altAxis) {
-        var options = this.options;
-        var minorGridLines = options.minorGridLines;
-        var majorGridLines = options.majorGridLines;
-        var vertical = options.vertical;
-        var lineBox = altAxis.lineBox();
-        var lineOptions = {
+    createGridLines(altAxis) {
+        const options = this.options;
+        const { minorGridLines, majorGridLines, vertical } = options;
+        const lineBox = altAxis.lineBox();
+        const lineOptions = {
             lineStart: lineBox[vertical ? "x1" : "y1"],
             lineEnd: lineBox[vertical ? "x2" : "y2"],
             vertical: vertical
         };
-        var majorTicks = [];
+        const majorTicks = [];
 
-        var container = this.gridLinesVisual();
+        const container = this.gridLinesVisual();
         function render(tickPosition, gridLine) {
             if (!inArray(tickPosition, majorTicks)) {
                 lineOptions.position = tickPosition;
@@ -230,93 +200,78 @@ var LogarithmicAxis = (function (Axis) {
         }
 
         return container.children;
-    };
+    }
 
-    LogarithmicAxis.prototype.traverseMajorTicksPositions = function traverseMajorTicksPositions (callback, tickOptions) {
-        var ref = this.lineInfo();
-        var lineStart = ref.lineStart;
-        var step = ref.step;
-        var ref$1 = this;
-        var logMin = ref$1.logMin;
-        var logMax = ref$1.logMax;
+    traverseMajorTicksPositions(callback, tickOptions) {
+        const { lineStart, step } = this.lineInfo();
+        const { logMin, logMax } = this;
 
-        for (var power = Math.ceil(logMin) + tickOptions.skip; power <= logMax; power += tickOptions.step) {
-            var position = round(lineStart + step * (power - logMin), DEFAULT_PRECISION);
+        for (let power = Math.ceil(logMin) + tickOptions.skip; power <= logMax; power += tickOptions.step) {
+            let position = round(lineStart + step * (power - logMin), DEFAULT_PRECISION);
             callback(position, tickOptions);
         }
-    };
+    }
+
+    traverseMinorTicksPositions(callback, tickOptions) {
+        const { min, max, minorUnit, majorUnit: base } = this.options;
+        const { lineStart, step } = this.lineInfo();
+        const { logMin, logMax } = this;
+        const start = Math.floor(logMin);
 
-    LogarithmicAxis.prototype.traverseMinorTicksPositions = function traverseMinorTicksPositions (callback, tickOptions) {
-        var this$1 = this;
-
-        var ref = this.options;
-        var min = ref.min;
-        var max = ref.max;
-        var minorUnit = ref.minorUnit;
-        var base = ref.majorUnit;
-        var ref$1 = this.lineInfo();
-        var lineStart = ref$1.lineStart;
-        var step = ref$1.step;
-        var ref$2 = this;
-        var logMin = ref$2.logMin;
-        var logMax = ref$2.logMax;
-        var start = Math.floor(logMin);
-
-        for (var power = start; power < logMax; power++) {
-            var minorOptions = this$1._minorIntervalOptions(power);
-            for (var idx = tickOptions.skip; idx < minorUnit; idx += tickOptions.step) {
-                var value = minorOptions.value + idx * minorOptions.minorStep;
+        for (let power = start; power < logMax; power++) {
+            const minorOptions = this._minorIntervalOptions(power);
+            for (let idx = tickOptions.skip; idx < minorUnit; idx += tickOptions.step) {
+                const value = minorOptions.value + idx * minorOptions.minorStep;
                 if (value > max) {
                     break;
                 }
                 if (value >= min) {
-                    var position = round(lineStart + step * (log(value, base) - logMin), DEFAULT_PRECISION);
+                    const position = round(lineStart + step * (log(value, base) - logMin), DEFAULT_PRECISION);
                     callback(position, tickOptions);
                 }
             }
         }
-    };
+    }
 
-    LogarithmicAxis.prototype.createAxisLabel = function createAxisLabel (index, labelOptions, labelContext) {
-        var power = Math.ceil(this.logMin + index);
-        var value = Math.pow(this.options.majorUnit, power);
-        var text = this.axisLabelText(value, labelOptions, labelContext);
+    createAxisLabel(index, labelOptions, labelContext) {
+        const power = Math.ceil(this.logMin + index);
+        const value = Math.pow(this.options.majorUnit, power);
+        const text = this.axisLabelText(value, labelOptions, labelContext);
 
         return new AxisLabel(value, text, index, null, labelOptions);
-    };
+    }
 
-    LogarithmicAxis.prototype.shouldRenderNote = function shouldRenderNote (value) {
-        var range = this.range();
+    shouldRenderNote(value) {
+        const range = this.range();
         return range.min <= value && value <= range.max;
-    };
+    }
 
-    LogarithmicAxis.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);
-    };
+    }
 
-    LogarithmicAxis.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: min,
             max: max
         };
-    };
+    }
 
-    LogarithmicAxis.prototype.scaleRange = function scaleRange (scale, cursor) {
-        var ref = this.options;
-        var base = ref.majorUnit;
-        var logMin = log(this.options.min, base);
-        var logMax = log(this.options.max, base);
-        var position = Math.abs(this.pointOffset(cursor));
-        var range = logMax - logMin;
-        var delta = this.scaleToDelta(scale, range);
-        var min = Math.pow(base, logMin + position * delta);
-        var max = Math.pow(base, logMax - (1 - position) * delta);
+    scaleRange(scale, cursor) {
+        const { majorUnit: base } = this.options;
+        const logMin = log(this.options.min, base);
+        const logMax = log(this.options.max, base);
+        const position = Math.abs(this.pointOffset(cursor));
+        const range = logMax - logMin;
+        const delta = this.scaleToDelta(scale, range);
+        const min = Math.pow(base, logMin + position * delta);
+        let max = Math.pow(base, logMax - (1 - position) * delta);
 
         if (max - min < MIN_VALUE_RANGE) {
             max = min + MIN_VALUE_RANGE;
@@ -326,48 +281,41 @@ var LogarithmicAxis = (function (Axis) {
             min: min,
             max: max
         };
-    };
+    }
 
-    LogarithmicAxis.prototype.zoomRange = function zoomRange (scale, cursor) {
-        var range = this.scaleRange(scale, cursor);
-        var ref = this;
-        var totalMin = ref.totalMin;
-        var totalMax = ref.totalMax;
+    zoomRange(scale, cursor) {
+        const range = this.scaleRange(scale, cursor);
+        const { totalMin, totalMax } = this;
 
         return {
             min: limitValue(range.min, totalMin, totalMax),
             max: limitValue(range.max, totalMin, totalMax)
         };
-    };
+    }
 
-    LogarithmicAxis.prototype._minorIntervalOptions = function _minorIntervalOptions (power) {
-        var ref = this.options;
-        var minorUnit = ref.minorUnit;
-        var base = ref.majorUnit;
-        var value = Math.pow(base, power);
-        var nextValue = Math.pow(base, power + 1);
-        var difference = nextValue - value;
-        var minorStep = difference / minorUnit;
+    _minorIntervalOptions(power) {
+        const { minorUnit, majorUnit: base } = this.options;
+        const value = Math.pow(base, power);
+        const nextValue = Math.pow(base, power + 1);
+        const difference = nextValue - value;
+        const minorStep = difference / minorUnit;
 
         return {
             value: value,
             minorStep: minorStep
         };
-    };
+    }
 
-    LogarithmicAxis.prototype.lineInfo = function lineInfo () {
-        var info = Axis.prototype.lineInfo.call(this);
+    lineInfo() {
+        const info = super.lineInfo();
         info.step = info.axisDir * (info.lineSize / (this.logMax - this.logMin));
 
         return info;
-    };
-
-    return LogarithmicAxis;
-}(Axis));
+    }
+}
 
 function initRange(autoMin, autoMax, axisOptions, options) {
-    var min = axisOptions.min;
-    var max = axisOptions.max;
+    let { min, max } = axisOptions;
 
     if (defined(axisOptions.axisCrossingValue) && axisOptions.axisCrossingValue <= 0) {
         throwNegativeValuesError();
@@ -392,8 +340,8 @@ function initRange(autoMin, autoMax, axisOptions, options) {
 }
 
 function autoAxisMin(min, max, options) {
-    var base = options.majorUnit;
-    var autoMin = min;
+    const base = options.majorUnit;
+    let autoMin = min;
     if (min <= 0) {
         autoMin = max <= 1 ? Math.pow(base, -2) : 1;
     } else if (!options.narrowRange) {
@@ -403,8 +351,8 @@ function autoAxisMin(min, max, options) {
 }
 
 function autoAxisMax(max, base) {
-    var logMaxRemainder = round(log(max, base), DEFAULT_PRECISION) % 1;
-    var autoMax;
+    const logMaxRemainder = round(log(max, base), DEFAULT_PRECISION) % 1;
+    let autoMax;
     if (max <= 0) {
         autoMax = base;
     } else if (logMaxRemainder !== 0 && (logMaxRemainder < 0.3 || logMaxRemainder > 0.9)) {

package/dist/es/core/mixins/grid-lines-mixin.js

@@ -2,13 +2,13 @@ import { geometry as geom, drawing as draw } from '@progress/kendo-drawing';
 
 import { append, map } from '../../common';
 
-var GridLinesMixin = {
+const GridLinesMixin = {
     createGridLines: function(altAxis) {
-        var options = this.options;
-        var radius = Math.abs(this.box.center().y - altAxis.lineBox().y1);
-        var gridLines = [];
-        var skipMajor = false;
-        var majorAngles, minorAngles;
+        const options = this.options;
+        const radius = Math.abs(this.box.center().y - altAxis.lineBox().y1);
+        let gridLines = [];
+        let skipMajor = false;
+        let majorAngles, minorAngles;
 
         if (options.majorGridLines.visible) {
             majorAngles = this.majorGridLineAngles(altAxis);
@@ -35,12 +35,12 @@ var GridLinesMixin = {
     },
 
     renderMinorGridLines: function(angles, radius, options, altAxis, skipMajor) {
-        var radiusCallback = this.radiusCallback && this.radiusCallback(radius, altAxis, skipMajor);
+        const radiusCallback = this.radiusCallback && this.radiusCallback(radius, altAxis, skipMajor);
         return this.renderGridLines(angles, radius, options, radiusCallback);
     },
 
     renderGridLines: function(angles, radius, options, radiusCallback) {
-        var style = {
+        const style = {
             stroke: {
                 width: options.width,
                 color: options.color,
@@ -48,12 +48,12 @@ var GridLinesMixin = {
             }
         };
 
-        var center = this.box.center();
-        var circle = new geom.Circle([ center.x, center.y ], radius);
-        var container = this.gridLinesVisual();
+        const center = this.box.center();
+        const circle = new geom.Circle([ center.x, center.y ], radius);
+        const container = this.gridLinesVisual();
 
-        for (var i = 0; i < angles.length; i++) {
-            var line = new draw.Path(style);
+        for (let i = 0; i < angles.length; i++) {
+            const line = new draw.Path(style);
             if (radiusCallback) {
                 circle.radius = radiusCallback(angles[i]);
             }
@@ -68,14 +68,12 @@ var GridLinesMixin = {
     },
 
     gridLineAngles: function(altAxis, size, skip, step, skipAngles) {
-        var this$1 = this;
+        const divs = this.intervals(size, skip, step, skipAngles);
+        const options = altAxis.options;
+        const altAxisVisible = options.visible && (options.line || {}).visible !== false;
 
-        var divs = this.intervals(size, skip, step, skipAngles);
-        var options = altAxis.options;
-        var altAxisVisible = options.visible && (options.line || {}).visible !== false;
-
-        return map(divs, function (d) {
-            var alpha = this$1.intervalAngle(d);
+        return map(divs, (d) => {
+            const alpha = this.intervalAngle(d);
 
             if (!altAxisVisible || alpha !== 90) {
                 return alpha;